Client bring-up: login, realm list, world auth, character select
- Grunt login ported end to end (SRP6 challenge/proof, version checksum, realm list) and tested against a live server: authenticates, connects to the world server (auth session with proof-of-work, header crypt), receives the character list and shows character select - Glue: realm list UI, character select (list, models, scripts), character create screen + name generator, delete/rename/decline, Enter World up to the loading screen; loading screen drawing and progress - AccountData (times, update, upload/download), BannedAddOns, addon scan and addon info, client cache version, tutorial flags - Shutdown path at login state: world/map/liquid/weather teardown, NetClient, ComSat, streaming stop; Logitech LCD no-device path in Ui/UILCD/Windows - PCRE 5.0 vendored (core stock; chartables and the posix layer from 12340), ValidateName - Fixes: TSGrowableArray::CalcChunkSize clamps to >= 8 (crash on char list), CWorldScene liquid renderer allocation, CMapFootprintTexture element ctor, pointer render states on x64, CFrustum/CWFrustum layout, M2 draw callback arguments, 37 class/struct forward-declaration mismatches - IDB name sync (1217 names), verify aliases, harness large-element instantiation Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
This commit is contained in:
@@ -69,6 +69,7 @@ add_subdirectory(Engine/Source/Images)
|
||||
add_subdirectory(Engine/Source/lua-5.1)
|
||||
add_subdirectory(Engine/Source/Model2)
|
||||
add_subdirectory(Engine/Source/Os)
|
||||
add_subdirectory(Engine/Source/pcre)
|
||||
add_subdirectory(Engine/Source/Scrn)
|
||||
add_subdirectory(Engine/Source/Services)
|
||||
add_subdirectory(Engine/Source/ShaderEffect)
|
||||
|
||||
@@ -493,3 +493,27 @@ int32_t CDataStore::InternalFetchRead(uint32_t pos, uint32_t bytes, uint8_t*& da
|
||||
uint32_t CDataStore::GetHeaderSpace(int32_t bytes) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// VERIFY: 97bd27e2 manual
|
||||
// OFFSET: 0x00465FD0
|
||||
void* CDataStore::Alloc(uint32_t bytes, const char* fileName, int32_t lineNumber) {
|
||||
if (!bytes) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (fileName) {
|
||||
return SMemAlloc(bytes, fileName, lineNumber, 0);
|
||||
}
|
||||
|
||||
return SMemAlloc(bytes, __FILE__, __LINE__, 0);
|
||||
}
|
||||
|
||||
// VERIFY: 5f3c641c manual
|
||||
// OFFSET: 0x00466010
|
||||
void* CDataStore::ReAlloc(void* ptr, uint32_t bytes, const char* fileName, int32_t lineNumber) {
|
||||
if (fileName) {
|
||||
return SMemReAlloc(ptr, bytes, fileName, lineNumber, 0);
|
||||
}
|
||||
|
||||
return SMemReAlloc(ptr, bytes, __FILE__, __LINE__, 0);
|
||||
}
|
||||
|
||||
@@ -2,9 +2,14 @@
|
||||
#define ENGINE_SOURCE_BASE_CDATASTORE_H
|
||||
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include "Engine/Source/Storm/H/storm.h"
|
||||
|
||||
class CDataStore {
|
||||
public:
|
||||
static void* Alloc(uint32_t bytes, const char* fileName, int32_t lineNumber);
|
||||
static void* ReAlloc(void* ptr, uint32_t bytes, const char* fileName, int32_t lineNumber);
|
||||
|
||||
/* 0004 */ uint8_t* m_data;
|
||||
/* 0008 */ uint32_t m_base;
|
||||
/* 000C */ uint32_t m_alloc;
|
||||
@@ -50,4 +55,116 @@ class CDataStore {
|
||||
CDataStore& Set(uint32_t pos, uint32_t val);
|
||||
};
|
||||
|
||||
template <uint32_t size>
|
||||
class CDataStoreCache : public CDataStore {
|
||||
public:
|
||||
/* 0018 */ uint8_t m_cache[size];
|
||||
|
||||
void InternalInitialize(uint8_t*& data, uint32_t& base, uint32_t& alloc) override;
|
||||
void InternalDestroy(uint8_t*& data, uint32_t& base, uint32_t& alloc) override;
|
||||
int32_t InternalFetchWrite(uint32_t pos, uint32_t bytes, uint8_t*& data, uint32_t& base, uint32_t& alloc, const char* fileName, int32_t lineNumber) override;
|
||||
~CDataStoreCache() override;
|
||||
void DetachBuffer(void** data, uint32_t* size, uint32_t* alloc) override;
|
||||
|
||||
CDataStoreCache();
|
||||
};
|
||||
|
||||
// INLINED
|
||||
template <uint32_t size>
|
||||
CDataStoreCache<size>::CDataStoreCache() {
|
||||
this->InternalInitialize(this->m_data, this->m_base, this->m_alloc);
|
||||
}
|
||||
|
||||
// VERIFY: 929e0c1c manual
|
||||
// OFFSET: 0x008CD160
|
||||
template <uint32_t size>
|
||||
CDataStoreCache<size>::~CDataStoreCache() {
|
||||
if (this->m_alloc != -1) {
|
||||
this->InternalDestroy(this->m_data, this->m_base, this->m_alloc);
|
||||
}
|
||||
}
|
||||
|
||||
// VERIFY: 3368e2bb auto
|
||||
// OFFSET: [0x008CCF30, 0x008CD090]
|
||||
template <uint32_t size>
|
||||
void CDataStoreCache<size>::InternalInitialize(uint8_t*& data, uint32_t& base, uint32_t& alloc) {
|
||||
data = this->m_cache;
|
||||
alloc = size;
|
||||
}
|
||||
|
||||
// VERIFY: 91276e33 manual
|
||||
// OFFSET: 0x008CCF50
|
||||
template <uint32_t size>
|
||||
void CDataStoreCache<size>::InternalDestroy(uint8_t*& data, uint32_t& base, uint32_t& alloc) {
|
||||
if (data == this->m_cache) {
|
||||
data = nullptr;
|
||||
alloc = 0;
|
||||
} else {
|
||||
if (data) {
|
||||
SMemFree(data, __FILE__, __LINE__, 0);
|
||||
}
|
||||
|
||||
data = nullptr;
|
||||
alloc = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// VERIFY: a0ace69c auto
|
||||
// OFFSET: 0x008CD0B0
|
||||
template <uint32_t size>
|
||||
int32_t CDataStoreCache<size>::InternalFetchWrite(uint32_t pos, uint32_t bytes, uint8_t*& data, uint32_t& base, uint32_t& alloc, const char* fileName, int32_t lineNumber) {
|
||||
uint32_t newAlloc = pos + bytes;
|
||||
|
||||
if (newAlloc <= alloc) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (data != this->m_cache) {
|
||||
data = static_cast<uint8_t*>(CDataStore::ReAlloc(data, newAlloc, fileName, lineNumber));
|
||||
alloc = newAlloc;
|
||||
return 1;
|
||||
}
|
||||
|
||||
uint8_t* newData;
|
||||
|
||||
if (newAlloc) {
|
||||
newData = static_cast<uint8_t*>(fileName ? SMemAlloc(newAlloc, fileName, lineNumber, 0) : SMemAlloc(newAlloc, __FILE__, __LINE__, 0));
|
||||
} else {
|
||||
newData = nullptr;
|
||||
}
|
||||
|
||||
data = newData;
|
||||
memcpy(newData, this->m_cache, pos < alloc ? pos : alloc);
|
||||
alloc = newAlloc;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// VERIFY: 1f74376a auto
|
||||
// OFFSET: 0x008CCFC0
|
||||
template <uint32_t size>
|
||||
void CDataStoreCache<size>::DetachBuffer(void** data, uint32_t* size_, uint32_t* alloc) {
|
||||
void* detachedData;
|
||||
uint32_t detachedSize;
|
||||
|
||||
CDataStore::DetachBuffer(&detachedData, &detachedSize, alloc);
|
||||
|
||||
if (detachedData == this->m_cache && detachedSize) {
|
||||
detachedData = SMemAlloc(detachedSize, __FILE__, __LINE__, 0);
|
||||
memcpy(detachedData, this->m_cache, detachedSize);
|
||||
|
||||
if (alloc) {
|
||||
*alloc = detachedSize;
|
||||
}
|
||||
}
|
||||
|
||||
if (data) {
|
||||
*data = detachedData;
|
||||
}
|
||||
|
||||
if (size_) {
|
||||
*size_ = detachedSize;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1088,6 +1088,59 @@ int32_t STORMAPI SFile::ReadFile(SArchive* archive, const char* name, void** dat
|
||||
return 1;
|
||||
}
|
||||
|
||||
// VERIFY: a77cc075 manual
|
||||
// OFFSET: 0x00424FA0
|
||||
int32_t STORMAPI SFile::List(SArchive* archive, int32_t (*callback)(const char* fileName, void* param), void* param) {
|
||||
if (archive->unk_0000 != 0 && archive->unk_0000 != 1) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
SFileImpl* file;
|
||||
|
||||
if (!SFile::OpenEx(archive, "(listfile)", 0, &file)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t size = SFileGetFileSize(file, nullptr);
|
||||
char* data = static_cast<char*>(Blizzard::Memory::Allocate(size));
|
||||
uint32_t bytesRead;
|
||||
|
||||
if (!SFileReadFile(file, data, size, &bytesRead, nullptr, 0)) {
|
||||
Blizzard::Memory::Free(data, 0, __FILE__, __LINE__);
|
||||
SFileCloseFile(file);
|
||||
return 0;
|
||||
}
|
||||
|
||||
SFileCloseFile(file);
|
||||
|
||||
char* end = data + size;
|
||||
char name[512];
|
||||
char* dest = name;
|
||||
name[0] = '\0';
|
||||
|
||||
for (char* src = data; src < end; src++) {
|
||||
char c = *src;
|
||||
|
||||
if (c == '\r' || c == '\n') {
|
||||
*dest = '\0';
|
||||
|
||||
if (name[0]) {
|
||||
if (!Blizzard::String::EqualI(Blizzard::String::FindExtension(name), "md5") && !callback(name, param)) {
|
||||
break;
|
||||
}
|
||||
|
||||
dest = name;
|
||||
}
|
||||
} else if (dest < &name[sizeof(name) - 1]) {
|
||||
*dest++ = c;
|
||||
}
|
||||
}
|
||||
|
||||
Blizzard::Memory::Free(data);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// VERIFY: 9a40aba6 auto
|
||||
// OFFSET: 0x00424F50
|
||||
int32_t STORMAPI SFile::LoadFile(const char* name, void** data, uint32_t* size, uint32_t extra, SOVERLAPPED* overlapped) {
|
||||
|
||||
@@ -93,6 +93,7 @@ class SFile {
|
||||
static int32_t InitializeStreaming(const char* mfilPath);
|
||||
static int32_t IsTrial();
|
||||
static void SetStreamingStatus(bool enabled, bool initialized, bool flag2, bool flag3, uint32_t build);
|
||||
static int32_t STORMAPI List(SArchive* archive, int32_t (*callback)(const char* fileName, void* param), void* param);
|
||||
static int32_t STORMAPI LoadFile(const char* name, void** data, uint32_t* size, uint32_t extra, SOVERLAPPED* overlapped);
|
||||
static int32_t STORMAPI MakeFileLocal(const char* name, int32_t priority, bool wait);
|
||||
static int32_t STORMAPI MakeFileLocal(SFileImpl* file, int32_t priority, bool wait);
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include "Engine/Source/BlizzardCore/SFile2-Core.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/File/File.h"
|
||||
@@ -120,3 +121,29 @@ void Blizzard::Time::GetElapsedSinceStart(bool start) {
|
||||
s_elapsedSinceStart = Blizzard::Time::GetTimestamp() - s_startTime;
|
||||
}
|
||||
}
|
||||
|
||||
// INLINED
|
||||
Blizzard::Streaming::DownloadProgress::DownloadProgress() {
|
||||
this->ResetTime();
|
||||
}
|
||||
|
||||
// INLINED
|
||||
Blizzard::Streaming::DownloadProgress::~DownloadProgress() {
|
||||
this->unk_0018 = 0;
|
||||
this->unk_0354 = nullptr;
|
||||
memset(this->unk_0020, 0, sizeof(this->unk_0020));
|
||||
}
|
||||
|
||||
// VERIFY: 1ed002c0 manual
|
||||
// OFFSET: 0x00438300
|
||||
void Blizzard::Streaming::DownloadProgress::ResetTime() {
|
||||
this->unk_0018 = static_cast<uint32_t>(Blizzard::Time::Milliseconds());
|
||||
}
|
||||
|
||||
// VERIFY: d9c84ab5 auto
|
||||
// OFFSET: 0x00420930
|
||||
void ShutdownStreamingIfTrial() {
|
||||
if (CheckIfStreamingAndTrial()) {
|
||||
GetStreamingManagerSingleton()->Shutdown();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,11 +2,77 @@
|
||||
#define ENGINE_SOURCE_BLIZZARDCORE_SOURCE_PACKAGES_STREAMING_STREAMING_H
|
||||
|
||||
#include <cstdint>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include "Engine/Source/BlizzardCore/Include/Blizzard/Util/Digest.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/File/Types.h"
|
||||
|
||||
namespace Blizzard {
|
||||
namespace Streaming {
|
||||
|
||||
struct FILE_THREAD_CMD {
|
||||
/* 0000 */ uint32_t unk_0000;
|
||||
/* 0004 */ uint32_t unk_0004;
|
||||
/* 0008 */ uint32_t unk_0008;
|
||||
/* 000C */ uint32_t unk_000C;
|
||||
/* 0010 */ void* unk_0010;
|
||||
};
|
||||
|
||||
struct DownloadSlot {
|
||||
/* 0000 */ uint32_t unk_0000;
|
||||
/* 0004 */ uint32_t unk_0004;
|
||||
/* 0008 */ uint32_t unk_0008;
|
||||
/* 000C */ uint32_t unk_000C;
|
||||
/* 0010 */ uint32_t unk_0010;
|
||||
};
|
||||
|
||||
struct DigestState {
|
||||
/* 0000 */ int32_t unk_0000;
|
||||
/* 0004 */ int32_t unk_0004;
|
||||
};
|
||||
|
||||
struct StorageEntry {
|
||||
/* 0000 */ uint8_t unk_0000[168];
|
||||
|
||||
~StorageEntry();
|
||||
};
|
||||
|
||||
class SourceManifest {
|
||||
public:
|
||||
/* 0000 */ uint8_t unk_0000[80];
|
||||
|
||||
~SourceManifest();
|
||||
};
|
||||
|
||||
struct ProgressSample {
|
||||
/* 0000 */ int64_t unk_0000;
|
||||
/* 0008 */ int32_t unk_0008;
|
||||
/* 000C */ uint8_t unk_000C[4];
|
||||
};
|
||||
|
||||
typedef void (*PROGRESSCALLBACK)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, int32_t);
|
||||
|
||||
class DownloadProgress {
|
||||
public:
|
||||
/* 0000 */ uint32_t unk_0000[6];
|
||||
/* 0018 */ uint32_t unk_0018;
|
||||
/* 001C */ uint8_t unk_001C[4];
|
||||
/* 0020 */ ProgressSample unk_0020[51];
|
||||
/* 0350 */ uint32_t unk_0350;
|
||||
/* 0354 */ PROGRESSCALLBACK unk_0354;
|
||||
/* 0358 */ bool unk_0358;
|
||||
|
||||
DownloadProgress();
|
||||
~DownloadProgress();
|
||||
int32_t FindNextSlot();
|
||||
void FireCallback();
|
||||
void ResetTime();
|
||||
};
|
||||
|
||||
typedef std::map<Blizzard::Util::Digest<16>, DigestState> DigestStateMap;
|
||||
typedef std::map<std::string, std::string> PathMap;
|
||||
typedef std::map<std::string, StorageEntry> StorageEntryMap;
|
||||
|
||||
extern bool s_streamingReady;
|
||||
extern bool s_isStreamingTrial;
|
||||
|
||||
@@ -20,9 +86,19 @@ void MakePartFileName(char* name, uint32_t size);
|
||||
}
|
||||
}
|
||||
|
||||
class StreamingManager {
|
||||
public:
|
||||
void Shutdown();
|
||||
};
|
||||
|
||||
bool CheckIfStreamingAndTrial();
|
||||
StreamingManager* GetStreamingManagerSingleton();
|
||||
void ShutdownStreamingIfTrial();
|
||||
void StopStreaming();
|
||||
int32_t StreamingGetRace();
|
||||
bool StreamingIsRaceDataReady(int32_t raceID);
|
||||
void StreamingSetRace(int32_t raceID);
|
||||
void StreamingSetState(int32_t state);
|
||||
char* GetComponentVersionData(uint32_t* size);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -2,8 +2,76 @@
|
||||
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <deque>
|
||||
#include <windows.h>
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Streaming/Streaming.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/File/File.h"
|
||||
|
||||
// STATIC: 0x00B3252C
|
||||
static HANDLE unk_B3252C;
|
||||
|
||||
// STATIC: 0x00B32530
|
||||
static CRITICAL_SECTION unk_B32530;
|
||||
|
||||
// STATIC: 0x00B32548
|
||||
static HANDLE unk_B32548[2];
|
||||
|
||||
// STATIC: 0x00B32550
|
||||
static HANDLE unk_B32550;
|
||||
|
||||
// STATIC: 0x00B32554
|
||||
static Blizzard::Streaming::DownloadSlot* unk_B32554[2];
|
||||
|
||||
// STATIC: 0x00B3255C
|
||||
static std::deque<Blizzard::Streaming::FILE_THREAD_CMD>* unk_B3255C[7];
|
||||
|
||||
// STATIC: 0x00B325A0
|
||||
static CRITICAL_SECTION unk_B325A0;
|
||||
|
||||
// STATIC: 0x00B325B8
|
||||
static bool unk_B325B8;
|
||||
|
||||
// STATIC: 0x00B325C0
|
||||
static CRITICAL_SECTION unk_B325C0;
|
||||
|
||||
// STATIC: 0x00B325D8
|
||||
static HANDLE unk_B325D8;
|
||||
|
||||
// STATIC: 0x00B325DC
|
||||
static HANDLE unk_B325DC;
|
||||
|
||||
// STATIC: 0x00B38170
|
||||
static Blizzard::Streaming::SourceManifest* unk_B38170;
|
||||
|
||||
// STATIC: 0x00B38174
|
||||
static Blizzard::Streaming::StorageEntryMap* unk_B38174;
|
||||
|
||||
// STATIC: 0x00B38178
|
||||
static Blizzard::File::StreamRecord* unk_B38178;
|
||||
|
||||
// STATIC: 0x00B3817C
|
||||
static bool unk_B3817C;
|
||||
|
||||
// STATIC: 0x00B3817E
|
||||
static bool unk_B3817E;
|
||||
|
||||
// STATIC: 0x00B3817F
|
||||
static bool unk_B3817F;
|
||||
|
||||
// STATIC: 0x00B38182
|
||||
static bool unk_B38182;
|
||||
|
||||
// STATIC: 0x00B38184
|
||||
static int32_t unk_B38184;
|
||||
|
||||
// STATIC: 0x00B38294
|
||||
static Blizzard::Streaming::DigestStateMap* unk_B38294;
|
||||
|
||||
// STATIC: 0x00B38298
|
||||
static Blizzard::Streaming::PathMap* unk_B38298;
|
||||
|
||||
// STATIC: 0x00B386D0
|
||||
static Blizzard::Streaming::DownloadProgress unk_B386D0;
|
||||
|
||||
// VERIFY: 63d60986 auto
|
||||
// OFFSET: 0x004294C0
|
||||
@@ -32,4 +100,74 @@ char* GetComponentVersionData(uint32_t* size) {
|
||||
return data;
|
||||
}
|
||||
|
||||
// VERIFY: 5b965645 manual
|
||||
// OFFSET: 0x004508B0
|
||||
static void StopThread() {
|
||||
if (unk_B3817C && unk_B38174) {
|
||||
unk_B3817E = true;
|
||||
SetEvent(unk_B325D8);
|
||||
|
||||
while (!unk_B3817F) {
|
||||
Sleep(10);
|
||||
}
|
||||
|
||||
CloseHandle(unk_B325D8);
|
||||
DeleteCriticalSection(&unk_B325C0);
|
||||
unk_B325C0.DebugInfo = nullptr;
|
||||
|
||||
if (unk_B38178) {
|
||||
Blizzard::File::Close(unk_B38178);
|
||||
}
|
||||
}
|
||||
|
||||
delete unk_B38174;
|
||||
unk_B38174 = nullptr;
|
||||
}
|
||||
|
||||
// VERIFY: a9cb82c4 manual
|
||||
// OFFSET: 0x00457680
|
||||
void StopStreaming() {
|
||||
if (Blizzard::Streaming::s_streamingReady) {
|
||||
unk_B386D0.FireCallback();
|
||||
unk_B38182 = true;
|
||||
SetEvent(unk_B325DC);
|
||||
SetEvent(unk_B3252C);
|
||||
unk_B325B8 = false;
|
||||
SetEvent(unk_B32550);
|
||||
|
||||
while (unk_B38184 > 0) {
|
||||
Sleep(10);
|
||||
}
|
||||
|
||||
CloseHandle(unk_B325DC);
|
||||
CloseHandle(unk_B3252C);
|
||||
|
||||
for (uint32_t i = 0; i < sizeof(unk_B32548) / sizeof(unk_B32548[0]); i++) {
|
||||
CloseHandle(unk_B32548[i]);
|
||||
delete unk_B32554[i];
|
||||
}
|
||||
|
||||
DeleteCriticalSection(&unk_B32530);
|
||||
unk_B32530.DebugInfo = nullptr;
|
||||
CloseHandle(unk_B32550);
|
||||
DeleteCriticalSection(&unk_B325A0);
|
||||
unk_B325A0.DebugInfo = nullptr;
|
||||
|
||||
delete unk_B38294;
|
||||
|
||||
for (uint32_t i = 0; i < sizeof(unk_B3255C) / sizeof(unk_B3255C[0]); i++) {
|
||||
delete unk_B3255C[i];
|
||||
}
|
||||
|
||||
delete unk_B38298;
|
||||
unk_B38298 = nullptr;
|
||||
Blizzard::Streaming::s_streamingReady = false;
|
||||
}
|
||||
|
||||
StopThread();
|
||||
|
||||
delete unk_B38170;
|
||||
unk_B38170 = nullptr;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -2,8 +2,76 @@
|
||||
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <deque>
|
||||
#include <windows.h>
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Streaming/Streaming.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/File/File.h"
|
||||
|
||||
// STATIC: 0x00B3252C
|
||||
static HANDLE unk_B3252C;
|
||||
|
||||
// STATIC: 0x00B32530
|
||||
static CRITICAL_SECTION unk_B32530;
|
||||
|
||||
// STATIC: 0x00B32548
|
||||
static HANDLE unk_B32548[2];
|
||||
|
||||
// STATIC: 0x00B32550
|
||||
static HANDLE unk_B32550;
|
||||
|
||||
// STATIC: 0x00B32554
|
||||
static Blizzard::Streaming::DownloadSlot* unk_B32554[2];
|
||||
|
||||
// STATIC: 0x00B3255C
|
||||
static std::deque<Blizzard::Streaming::FILE_THREAD_CMD>* unk_B3255C[7];
|
||||
|
||||
// STATIC: 0x00B325A0
|
||||
static CRITICAL_SECTION unk_B325A0;
|
||||
|
||||
// STATIC: 0x00B325B8
|
||||
static bool unk_B325B8;
|
||||
|
||||
// STATIC: 0x00B325C0
|
||||
static CRITICAL_SECTION unk_B325C0;
|
||||
|
||||
// STATIC: 0x00B325D8
|
||||
static HANDLE unk_B325D8;
|
||||
|
||||
// STATIC: 0x00B325DC
|
||||
static HANDLE unk_B325DC;
|
||||
|
||||
// STATIC: 0x00B38170
|
||||
static Blizzard::Streaming::SourceManifest* unk_B38170;
|
||||
|
||||
// STATIC: 0x00B38174
|
||||
static Blizzard::Streaming::StorageEntryMap* unk_B38174;
|
||||
|
||||
// STATIC: 0x00B38178
|
||||
static Blizzard::File::StreamRecord* unk_B38178;
|
||||
|
||||
// STATIC: 0x00B3817C
|
||||
static bool unk_B3817C;
|
||||
|
||||
// STATIC: 0x00B3817E
|
||||
static bool unk_B3817E;
|
||||
|
||||
// STATIC: 0x00B3817F
|
||||
static bool unk_B3817F;
|
||||
|
||||
// STATIC: 0x00B38182
|
||||
static bool unk_B38182;
|
||||
|
||||
// STATIC: 0x00B38184
|
||||
static int32_t unk_B38184;
|
||||
|
||||
// STATIC: 0x00B38294
|
||||
static Blizzard::Streaming::DigestStateMap* unk_B38294;
|
||||
|
||||
// STATIC: 0x00B38298
|
||||
static Blizzard::Streaming::PathMap* unk_B38298;
|
||||
|
||||
// STATIC: 0x00B386D0
|
||||
static Blizzard::Streaming::DownloadProgress unk_B386D0;
|
||||
|
||||
// OFFSET: 0x004294C0
|
||||
char* GetComponentVersionData(uint32_t* size) {
|
||||
@@ -31,4 +99,72 @@ char* GetComponentVersionData(uint32_t* size) {
|
||||
return data;
|
||||
}
|
||||
|
||||
// OFFSET: 0x004508B0
|
||||
static void StopThread() {
|
||||
if (unk_B3817C && unk_B38174) {
|
||||
unk_B3817E = true;
|
||||
SetEvent(unk_B325D8);
|
||||
|
||||
while (!unk_B3817F) {
|
||||
Sleep(10);
|
||||
}
|
||||
|
||||
CloseHandle(unk_B325D8);
|
||||
DeleteCriticalSection(&unk_B325C0);
|
||||
unk_B325C0.DebugInfo = nullptr;
|
||||
|
||||
if (unk_B38178) {
|
||||
Blizzard::File::Close(unk_B38178);
|
||||
}
|
||||
}
|
||||
|
||||
delete unk_B38174;
|
||||
unk_B38174 = nullptr;
|
||||
}
|
||||
|
||||
// OFFSET: 0x00457680
|
||||
void StopStreaming() {
|
||||
if (Blizzard::Streaming::s_streamingReady) {
|
||||
unk_B386D0.FireCallback();
|
||||
unk_B38182 = true;
|
||||
SetEvent(unk_B325DC);
|
||||
SetEvent(unk_B3252C);
|
||||
unk_B325B8 = false;
|
||||
SetEvent(unk_B32550);
|
||||
|
||||
while (unk_B38184 > 0) {
|
||||
Sleep(10);
|
||||
}
|
||||
|
||||
CloseHandle(unk_B325DC);
|
||||
CloseHandle(unk_B3252C);
|
||||
|
||||
for (uint32_t i = 0; i < sizeof(unk_B32548) / sizeof(unk_B32548[0]); i++) {
|
||||
CloseHandle(unk_B32548[i]);
|
||||
delete unk_B32554[i];
|
||||
}
|
||||
|
||||
DeleteCriticalSection(&unk_B32530);
|
||||
unk_B32530.DebugInfo = nullptr;
|
||||
CloseHandle(unk_B32550);
|
||||
DeleteCriticalSection(&unk_B325A0);
|
||||
unk_B325A0.DebugInfo = nullptr;
|
||||
|
||||
delete unk_B38294;
|
||||
|
||||
for (uint32_t i = 0; i < sizeof(unk_B3255C) / sizeof(unk_B3255C[0]); i++) {
|
||||
delete unk_B3255C[i];
|
||||
}
|
||||
|
||||
delete unk_B38298;
|
||||
unk_B38298 = nullptr;
|
||||
Blizzard::Streaming::s_streamingReady = false;
|
||||
}
|
||||
|
||||
StopThread();
|
||||
|
||||
delete unk_B38170;
|
||||
unk_B38170 = nullptr;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
#include "ComSatInterface.h"
|
||||
#include "Engine/Source/ComSat/ComSatSoundIOSoundEngine.h"
|
||||
|
||||
// STATIC: 0x00D43988
|
||||
static ComSat::Sound::Manager* unk_D43988;
|
||||
|
||||
// STATIC: 0x00D4398C
|
||||
static ComSat::Network::Manager* unk_D4398C;
|
||||
|
||||
// INLINED
|
||||
ComSat::Allocator::~Allocator() {
|
||||
}
|
||||
|
||||
// VERIFY: d03c9b46 auto
|
||||
// OFFSET: 0x00880B30
|
||||
void ComSat::Interface::Destroy(ComSat::Interface* comsat, ComSat::Allocator& allocator) {
|
||||
if (comsat) {
|
||||
comsat->~Interface();
|
||||
allocator.Free(comsat);
|
||||
}
|
||||
|
||||
if (unk_D43988) {
|
||||
ComSat::Sound::Manager* soundManager = unk_D43988;
|
||||
soundManager->~Manager();
|
||||
allocator.Free(soundManager);
|
||||
unk_D43988 = nullptr;
|
||||
}
|
||||
|
||||
if (unk_D4398C) {
|
||||
ComSat::Network::Manager* networkManager = unk_D4398C;
|
||||
networkManager->~Manager();
|
||||
allocator.Free(networkManager);
|
||||
unk_D4398C = nullptr;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
#ifndef ENGINE_SOURCE_COMSAT_COMSATINTERFACE_H
|
||||
#define ENGINE_SOURCE_COMSAT_COMSATINTERFACE_H
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
|
||||
namespace ComSat {
|
||||
|
||||
class Allocator {
|
||||
public:
|
||||
virtual ~Allocator();
|
||||
virtual void* Alloc(uint32_t size) = 0;
|
||||
virtual void Free(void* ptr) = 0;
|
||||
};
|
||||
|
||||
class Interface {
|
||||
public:
|
||||
static void Destroy(Interface* comsat, Allocator& allocator);
|
||||
|
||||
virtual ~Interface();
|
||||
};
|
||||
|
||||
namespace Network {
|
||||
|
||||
class Manager {
|
||||
public:
|
||||
~Manager();
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -39,10 +39,12 @@ struct Session {
|
||||
namespace ComSat {
|
||||
namespace Sound {
|
||||
struct Manager {
|
||||
/* 0000 */ uint8_t unk_0000 [12];
|
||||
/* 0004 */ uint8_t unk_0004 [8];
|
||||
/* 000C */ int32_t unk_000C;
|
||||
/* 0010 */ uint8_t unk_0010 [8];
|
||||
/* 0018 */ int32_t unk_0018;
|
||||
|
||||
virtual ~Manager();
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
@@ -52,6 +52,25 @@ int32_t FrameScript_GetColor(lua_State* L, int32_t index, CImVector& color) {
|
||||
return index;
|
||||
}
|
||||
|
||||
// VERIFY: 51dc23ed manual
|
||||
// OFFSET: 0x0061BE50
|
||||
int32_t FrameScript_GetColorNoAlpha(lua_State* L, int32_t index, CImVector& color) {
|
||||
float r = lua_tonumber(L, index);
|
||||
r = r < 0.0f ? 0.0f : (r >= 1.0f ? 1.0f : r);
|
||||
index++;
|
||||
|
||||
float g = lua_tonumber(L, index);
|
||||
g = g < 0.0f ? 0.0f : (g >= 1.0f ? 1.0f : g);
|
||||
index++;
|
||||
|
||||
float b = lua_tonumber(L, index);
|
||||
b = b < 0.0f ? 0.0f : (b >= 1.0f ? 1.0f : b);
|
||||
index++;
|
||||
|
||||
color.Set(1.0f, r, g, b);
|
||||
return index;
|
||||
}
|
||||
|
||||
// VERIFY: cb764878 auto
|
||||
// OFFSET: 0x00960530
|
||||
static int32_t Script_SetModel(lua_State* L) {
|
||||
|
||||
@@ -2100,3 +2100,9 @@ void CGxDevice::RsInit() {
|
||||
this->RsSet(Unk84, 0.0f);
|
||||
this->RsSet(GxRs_ColorMaterial, 0);
|
||||
}
|
||||
|
||||
// INLINED
|
||||
CGxMonitorMode::CGxMonitorMode() {
|
||||
this->m_size.x = 0;
|
||||
this->m_size.y = 0;
|
||||
}
|
||||
|
||||
@@ -36,6 +36,8 @@ class CGxMonitorMode {
|
||||
/* 0000 */ C2iVector m_size;
|
||||
/* 0008 */ uint32_t m_bpp;
|
||||
/* 000C */ uint32_t m_refreshRate;
|
||||
|
||||
CGxMonitorMode();
|
||||
};
|
||||
|
||||
enum EGxMasterEnables {
|
||||
|
||||
@@ -1126,3 +1126,10 @@ void GxDevDestroy(CGxDevice* device) {
|
||||
// OFFSET: 0x005EEB70
|
||||
void GxPrimUnlockVertexPtrs() {
|
||||
}
|
||||
|
||||
// INLINED
|
||||
GxDrawListEntry::GxDrawListEntry() {
|
||||
this->m_item = nullptr;
|
||||
this->m_depth = 0.0f;
|
||||
this->m_vtxStream = 0;
|
||||
}
|
||||
|
||||
@@ -45,6 +45,8 @@ class GxDrawListEntry {
|
||||
/* 0000 */ GxuDrawListItem* m_item;
|
||||
/* 0004 */ float m_depth;
|
||||
/* 0008 */ uint32_t m_vtxStream;
|
||||
|
||||
GxDrawListEntry();
|
||||
};
|
||||
|
||||
CGxDevice* CreateCGxDeviceD3d();
|
||||
|
||||
@@ -632,3 +632,8 @@ TEXTLINETEXTURE::TEXTLINETEXTURE() {
|
||||
this->m_verts.m_chunk = 128;
|
||||
this->m_colors.m_chunk = 128;
|
||||
}
|
||||
|
||||
// INLINED
|
||||
TEXTURECACHEROW::TEXTURECACHEROW() {
|
||||
this->m_widestFreeSlot = 0;
|
||||
}
|
||||
|
||||
@@ -95,6 +95,7 @@ struct TEXTURECACHEROW {
|
||||
/* 0000 */ uint32_t m_widestFreeSlot;
|
||||
/* 0004 */ TSExplicitList<CHARCODEDESC, offsetof(CHARCODEDESC, m_textureRowLink)> m_glyphlist;
|
||||
|
||||
TEXTURECACHEROW();
|
||||
CHARCODEDESC* CreateNewDesc(GLYPHBITMAPDATA* data, uint32_t rowNumber, uint32_t cellHeight);
|
||||
void EvictGlyph(CHARCODEDESC* desc);
|
||||
};
|
||||
|
||||
@@ -955,3 +955,17 @@ uint32_t CGxString::GetEmbeddedTextureInfo(const GXUEMBEDDEDTEXTUREINFO*& info)
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
// INLINED
|
||||
GXUFONTHYPERLINKINFO::GXUFONTHYPERLINKINFO() {
|
||||
this->m_lineHeight = 0.0f;
|
||||
this->m_indentation = 0.0f;
|
||||
this->m_baseLineHeight = 0.0f;
|
||||
this->m_right = 0.0f;
|
||||
this->m_linkData = nullptr;
|
||||
this->m_linkDataLength = 0;
|
||||
this->m_linkText = nullptr;
|
||||
this->m_linkTextLength = 0;
|
||||
this->m_colorCode = nullptr;
|
||||
this->m_colorCodeLength = 0;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
#include "Engine/Source/Gxu/GxuScene.h"
|
||||
|
||||
// VERIFY: 900a5aaa manual
|
||||
// OFFSET: 0x009A8180
|
||||
GxuScene::~GxuScene() {
|
||||
}
|
||||
|
||||
// VERIFY: b534d669 auto
|
||||
// OFFSET: 0x009A81C0
|
||||
void GxuScene::Clear() {
|
||||
for (uint32_t i = 0; i < this->m_objects.Count(); i++) {
|
||||
this->m_objects[i]->Unk04();
|
||||
}
|
||||
|
||||
this->m_objects.SetCount(0);
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
#ifndef ENGINE_SOURCE_GXU_GXUSCENE_H
|
||||
#define ENGINE_SOURCE_GXU_GXUSCENE_H
|
||||
|
||||
#include <cstdint>
|
||||
#include "Engine/Source/Storm/H/stpl.h"
|
||||
|
||||
class GxuSceneObject {
|
||||
public:
|
||||
virtual void Unk00();
|
||||
virtual void Unk04();
|
||||
};
|
||||
|
||||
class GxuScene {
|
||||
public:
|
||||
/* 0004 */ TSGrowableArray<GxuSceneObject*> m_objects;
|
||||
|
||||
virtual ~GxuScene();
|
||||
void Clear();
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -51,6 +51,8 @@ struct GXUFONTHYPERLINKINFO {
|
||||
/* 001C */ uint32_t m_linkTextLength;
|
||||
/* 0020 */ const char* m_colorCode;
|
||||
/* 0024 */ uint32_t m_colorCodeLength;
|
||||
|
||||
GXUFONTHYPERLINKINFO();
|
||||
};
|
||||
|
||||
struct HFACE__ {
|
||||
|
||||
@@ -909,13 +909,13 @@ void CM2SceneRender::BeginFixed(const C3Vector& position) {
|
||||
g_theGxDevicePtr->RsPush();
|
||||
}
|
||||
|
||||
// VERIFY: 4b28d1ab manual
|
||||
// VERIFY: 10b5aef5 auto
|
||||
// OFFSET: 0x008230D0
|
||||
void CM2SceneRender::DrawCallback() {
|
||||
DebugLog("Callback");
|
||||
|
||||
this->BeginFixed(C3Vector(0.0f, 0.0f, 0.0f));
|
||||
this->m_curModel->m_drawCallback(this->m_curModel);
|
||||
this->m_curModel->m_drawCallback(this->m_curModel, this->m_curModel->m_currentLighting, this->m_curModel->m_drawArg);
|
||||
CM2SceneRender::EndFixed();
|
||||
CShaderEffect::UpdateProjMatrix();
|
||||
}
|
||||
|
||||
@@ -3836,7 +3836,7 @@ CM2Model::CM2Model() {
|
||||
this->m_emissiveColor.y = 0.0f;
|
||||
this->m_emissiveColor.z = 0.0f;
|
||||
this->m_drawCallback = nullptr;
|
||||
this->unk_01C0 = 0;
|
||||
this->m_drawArg = nullptr;
|
||||
this->unk_01B8 = 1.0f;
|
||||
this->m_eventCallback = nullptr;
|
||||
this->m_eventCallbackParam = 0;
|
||||
@@ -5814,6 +5814,13 @@ void CM2Model::AnimateParticleST(float deltaTime, uint32_t index) {
|
||||
}
|
||||
}
|
||||
|
||||
// VERIFY: 68879b30 auto
|
||||
// OFFSET: 0x004E2790
|
||||
C3Vector CM2Model::GetWorldPosition() {
|
||||
this->Animate();
|
||||
return *reinterpret_cast<const C3Vector*>(&this->m_matrixF4.d0) * this->m_scene->m_viewInv;
|
||||
}
|
||||
|
||||
// VERIFY: a046dcf2 manual
|
||||
// OFFSET: 0x00830DC0
|
||||
void CM2Model::Animate() {
|
||||
|
||||
@@ -200,8 +200,8 @@ class CM2Model {
|
||||
/* 01A0 */ C3Vector m_diffuseColor;
|
||||
/* 01AC */ C3Vector m_emissiveColor;
|
||||
/* 01B8 */ float unk_01B8;
|
||||
/* 01BC */ void (*m_drawCallback)(CM2Model*);
|
||||
/* 01C0 */ uint32_t unk_01C0;
|
||||
/* 01BC */ void (*m_drawCallback)(CM2Model*, const CM2Lighting*, void*);
|
||||
/* 01C0 */ void* m_drawArg;
|
||||
/* 01C4 */ void* m_eventCallback;
|
||||
/* 01C8 */ uint64_t m_eventCallbackParam;
|
||||
/* 01D0 */ M2ModelLight* m_lights;
|
||||
@@ -277,6 +277,7 @@ class CM2Model {
|
||||
CAaSphere GetMaxBoundingSpherePlusAttachments();
|
||||
uint32_t GetSequenceVariationCount(uint32_t id);
|
||||
CAaBox GetSplitBodyBoundingBox(uint32_t boneId);
|
||||
C3Vector GetWorldPosition();
|
||||
int32_t HasBone(uint32_t boneId);
|
||||
int32_t HasSequence(const M2Data* data, uint32_t id);
|
||||
int32_t HasSequence(uint32_t id);
|
||||
|
||||
@@ -18,6 +18,15 @@ class IOsVersionHashCallback {
|
||||
virtual void Process(const void* data, uint32_t size) = 0;
|
||||
};
|
||||
|
||||
template <class T>
|
||||
class IOsVersionHashCallback2 : public IOsVersionHashCallback {
|
||||
public:
|
||||
/* 0004 */ T* m_object;
|
||||
|
||||
IOsVersionHashCallback2(T* object);
|
||||
void Process(const void* data, uint32_t size) override;
|
||||
};
|
||||
|
||||
struct OsVersionHashEntry {
|
||||
/* 0000 */ uint32_t m_offset;
|
||||
/* 0004 */ uint32_t m_size;
|
||||
@@ -38,4 +47,16 @@ class OsVersionHash {
|
||||
|
||||
int32_t IOsVersionChecksum(IOsVersionHashCallback& callback, const char* path, int32_t loaded);
|
||||
|
||||
// INLINED
|
||||
template <class T>
|
||||
IOsVersionHashCallback2<T>::IOsVersionHashCallback2(T* object) : m_object(object) {
|
||||
}
|
||||
|
||||
// VERIFY: 99333a2f auto
|
||||
// OFFSET: 0x006B9CE0
|
||||
template <class T>
|
||||
void IOsVersionHashCallback2<T>::Process(const void* data, uint32_t size) {
|
||||
this->m_object->Process(data, size);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -90,6 +90,18 @@ void ScrnLayerSetRect(HLAYER layer, const RECTF* rect) {
|
||||
reinterpret_cast<CILayer*>(layer)->m_rect = *rect;
|
||||
}
|
||||
|
||||
// VERIFY: e30052be auto
|
||||
// OFFSET: 0x004A8530
|
||||
uint32_t ScrnLayerGetFlags(HLAYER layer) {
|
||||
return reinterpret_cast<CILayer*>(layer)->m_flags;
|
||||
}
|
||||
|
||||
// VERIFY: 4573bf37 auto
|
||||
// OFFSET: 0x004A8540
|
||||
void ScrnLayerSetFlags(HLAYER layer, uint32_t flags) {
|
||||
reinterpret_cast<CILayer*>(layer)->m_flags = flags;
|
||||
}
|
||||
|
||||
// VERIFY: 90b31936 auto
|
||||
// OFFSET: 0x004A8570
|
||||
static int32_t CaptureScreen() {
|
||||
|
||||
@@ -6,6 +6,8 @@
|
||||
#include "Engine/Source/Services/Types.h"
|
||||
#include "Engine/Source/Storm/H/Types.h"
|
||||
|
||||
uint32_t ScrnLayerGetFlags(HLAYER layer);
|
||||
void ScrnLayerSetFlags(HLAYER layer, uint32_t flags);
|
||||
void ScrnLayerSetRect(HLAYER layer, const RECTF* rect);
|
||||
void ScrnLayerCreate(const RECTF* rect, float zorder, uint32_t flags, void* param, void (*paintFunc)(void* param, const RECTF* rect, const RECTF* visible, float elapsedSec), HLAYER* layer);
|
||||
|
||||
|
||||
@@ -450,9 +450,9 @@ void CShadowCache::SetShadowMapDetailDoodad() {
|
||||
}
|
||||
}
|
||||
|
||||
// VERIFY: 2584124d manual
|
||||
// VERIFY: 2396207d manual
|
||||
// OFFSET: 0x00874890
|
||||
void CShadowCache::GatherBands(CShadowCacheQueryData& data, const C3Vector& pos, CWFrustum& frustum, int32_t useCullFrustum) {
|
||||
void CShadowCache::GatherBands(CShadowCacheQueryData& data, const C3Vector& pos, CFrustum& frustum, int32_t useCullFrustum) {
|
||||
uint32_t frame = 0;
|
||||
|
||||
if (CShadowCache::GetShadowMode() < SHADOW_VERY_HIGH) {
|
||||
@@ -935,7 +935,7 @@ void CShadowCache::Init() {
|
||||
CShadowCache::s_cutoffPlane.w = 0.0f;
|
||||
}
|
||||
|
||||
// VERIFY: 6f6e0a5e auto
|
||||
// VERIFY: 2346cbd1 auto
|
||||
// OFFSET: 0x00875F80
|
||||
int32_t CShadowCache::Update(const C3Vector& pos, int32_t useCullFrustum) {
|
||||
int32_t recreate = CShadowCache::s_recreateTextures;
|
||||
@@ -1050,7 +1050,7 @@ int32_t CShadowCache::Update(const C3Vector& pos, int32_t useCullFrustum) {
|
||||
|
||||
if (useCullFrustum || mode < SHADOW_VERY_HIGH) {
|
||||
int32_t useBandCull = 0;
|
||||
CWFrustum frustum;
|
||||
CFrustum frustum;
|
||||
|
||||
if (mode < SHADOW_VERY_HIGH) {
|
||||
data.m_useFrustum = 0;
|
||||
|
||||
@@ -8,9 +8,8 @@
|
||||
#include "Engine/Source/Tempest/C44Matrix.h"
|
||||
#include "Engine/Source/Tempest/C4Vector.h"
|
||||
#include "Engine/Source/Tempest/CAaBox.h"
|
||||
#include "_Triage/CWFrustum.h"
|
||||
#include "Engine/Source/Tempest/CFrustum.h"
|
||||
|
||||
class CFrustum;
|
||||
class CGxTex;
|
||||
class CTexture;
|
||||
struct CShadowCacheQueryData;
|
||||
@@ -38,9 +37,9 @@ struct CShadowCacheQueryData {
|
||||
/* 000C */ int32_t m_active[3];
|
||||
/* 0018 */ int32_t m_useCullFrustum[3];
|
||||
/* 0024 */ CAaBox m_extents[3];
|
||||
/* 006C */ CWFrustum m_frustums[3];
|
||||
/* 0348 */ CWFrustum m_cullFrustums[3];
|
||||
/* 0624 */ CWFrustum unk_0624[3];
|
||||
/* 006C */ CFrustum m_frustums[3];
|
||||
/* 0348 */ CFrustum m_cullFrustums[3];
|
||||
/* 0624 */ CFrustum unk_0624[3];
|
||||
/* 0900 */ float m_cullRects[3][4];
|
||||
/* 0930 */ C3Vector m_pos[3];
|
||||
/* 0954 */ uint8_t m_textureIndex[3];
|
||||
@@ -86,7 +85,7 @@ class CShadowCache {
|
||||
|
||||
static void ClearBandTextures();
|
||||
static void Destroy();
|
||||
static void GatherBands(CShadowCacheQueryData& data, const C3Vector& pos, CWFrustum& frustum, int32_t useCullFrustum);
|
||||
static void GatherBands(CShadowCacheQueryData& data, const C3Vector& pos, CFrustum& frustum, int32_t useCullFrustum);
|
||||
static uint32_t GetMaxShadowMode();
|
||||
static EShadowMode GetShadowMode();
|
||||
static const char* GetShadowModeDesc(uint32_t mode);
|
||||
|
||||
@@ -60,6 +60,12 @@ struct HSLOG__ {
|
||||
|
||||
typedef HSLOG__* HSLOG;
|
||||
|
||||
struct SARC4Key {
|
||||
/* 0000 */ uint8_t m_state [256];
|
||||
/* 0100 */ uint8_t m_x;
|
||||
/* 0101 */ uint8_t m_y;
|
||||
};
|
||||
|
||||
struct _CMDERROR {
|
||||
/* 0000 */ uint32_t errorcode;
|
||||
/* 0004 */ const char* itemstr;
|
||||
|
||||
@@ -106,6 +106,9 @@ struct HINSTANCE__;
|
||||
struct HWND__;
|
||||
struct SSignatureData;
|
||||
|
||||
void SARC4PrepareKey(const void* key, uint32_t length, SARC4Key* outKey);
|
||||
void SARC4ProcessBuffer(uint8_t* data, uint32_t length, const SARC4Key* inKey, SARC4Key* outKey);
|
||||
|
||||
void STORMAPI SBigAdd(BigData* a, const BigData* b, const BigData* c);
|
||||
void STORMAPI SBigBitLen(BigData* a, uint32_t* bits);
|
||||
int32_t STORMAPI SBigCompare(const BigData* a, const BigData* b);
|
||||
|
||||
@@ -112,6 +112,15 @@ class TSFixedArray : public TSBaseArray<T> {
|
||||
void SetCount(uint32_t count);
|
||||
};
|
||||
|
||||
template <class T>
|
||||
class TSBitField {
|
||||
public:
|
||||
/* 0000 */ uint32_t m_count;
|
||||
/* 0004 */ T m_bits;
|
||||
|
||||
void Load(const void* data, uint32_t bytes, int32_t bits);
|
||||
};
|
||||
|
||||
template <class T>
|
||||
class TSGrowableArray : public TSFixedArray<T> {
|
||||
public:
|
||||
@@ -822,11 +831,11 @@ uint32_t TSGrowableArray<T>::Add(uint32_t count, uint32_t incr, const T* data) {
|
||||
return this->m_count - count;
|
||||
}
|
||||
|
||||
// VERIFY: 6cd6a5cc manual
|
||||
// VERIFY: 52330a88 manual
|
||||
// OFFSET: [0x004BBD60, 0x00548600, 0x0057C0E0, 0x00590830, 0x00590AE0, 0x005D0040, 0x006C41D0, 0x00790400, 0x007AE270, 0x007F7980]
|
||||
template <class T>
|
||||
uint32_t TSGrowableArray<T>::CalcChunkSize(uint32_t count) {
|
||||
uint32_t maxchunk = 256 / sizeof(T);
|
||||
uint32_t maxchunk = 256 / sizeof(T) > 8 ? 256 / sizeof(T) : 8;
|
||||
|
||||
if (count >= maxchunk) {
|
||||
this->m_chunk = maxchunk;
|
||||
@@ -1183,7 +1192,8 @@ int32_t TSHashTable<T, TKey>::MonitorFullness(uint32_t slot) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// INLINED
|
||||
// VERIFY: f5512cc0 auto
|
||||
// OFFSET: [0x0067B660]
|
||||
template <class T, class TKey>
|
||||
T* TSHashTable<T, TKey>::New(uint32_t hashval, const TKey& key, size_t extrabytes, uint32_t flags) {
|
||||
T* node = this->InternalNewNode(hashval, extrabytes, flags);
|
||||
@@ -1212,7 +1222,7 @@ T* TSHashTable<T, TKey>::New(const char* str, size_t extrabytes, uint32_t flags)
|
||||
}
|
||||
|
||||
// VERIFY: cb777ac9 manual
|
||||
// OFFSET: [0x004B6D90, 0x004BB1E0, 0x00505480, 0x006BBD40, 0x006C2A50, 0x006F6020, 0x007B0690, 0x007BDD80, 0x007BDDF0, 0x00810970]
|
||||
// OFFSET: [0x004B6D90, 0x004BB1E0, 0x004D4BB0, 0x00505480, 0x00679350, 0x006BBD40, 0x006C2A50, 0x006F6020, 0x007B0690, 0x007BDD80, 0x007BDDF0, 0x00810970]
|
||||
template <class T, class TKey>
|
||||
T* TSHashTable<T, TKey>::Ptr(uint32_t hashval, const TKey& key) {
|
||||
if (this->m_slotmask == 0xFFFFFFFF) {
|
||||
@@ -1510,4 +1520,13 @@ inline bool HASHKEY_UTF8I::operator==(const char* str) {
|
||||
return SStrCmpUTF8I(this->m_str, str, STORM_MAX_STR) == 0;
|
||||
}
|
||||
|
||||
// INLINED
|
||||
template <class T>
|
||||
void TSBitField<T>::Load(const void* data, uint32_t bytes, int32_t bits) {
|
||||
uint32_t count = bits == -1 ? bytes * 8 : bits;
|
||||
this->m_count = count;
|
||||
this->m_bits.SetCount(count ? ((count - 1) >> 5) + 1 : 0);
|
||||
memcpy(this->m_bits.m_data, data, bytes);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,95 @@
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include "Engine/Source/Storm/H/storm.h"
|
||||
|
||||
// VERIFY: c3553682 manual
|
||||
// OFFSET: 0x00774EA0
|
||||
void SARC4ProcessBuffer(uint8_t* data, uint32_t length, const SARC4Key* inKey, SARC4Key* outKey) {
|
||||
if (inKey != outKey) {
|
||||
memcpy(outKey, inKey, sizeof(SARC4Key));
|
||||
}
|
||||
|
||||
uint8_t* state = outKey->m_state;
|
||||
uint8_t x = outKey->m_x;
|
||||
uint8_t y = outKey->m_y;
|
||||
uint32_t i = 0;
|
||||
|
||||
for (; i < (length & ~3u); i += 4) {
|
||||
uint8_t swap;
|
||||
|
||||
x++;
|
||||
y += state[x];
|
||||
swap = state[x];
|
||||
state[x] = state[y];
|
||||
state[y] = swap;
|
||||
uint32_t stream = state[static_cast<uint8_t>(state[x] + state[y])];
|
||||
|
||||
x++;
|
||||
y += state[x];
|
||||
swap = state[x];
|
||||
state[x] = state[y];
|
||||
state[y] = swap;
|
||||
stream |= state[static_cast<uint8_t>(state[x] + state[y])] << 8;
|
||||
|
||||
x++;
|
||||
y += state[x];
|
||||
swap = state[x];
|
||||
state[x] = state[y];
|
||||
state[y] = swap;
|
||||
stream |= state[static_cast<uint8_t>(state[x] + state[y])] << 16;
|
||||
|
||||
x++;
|
||||
y += state[x];
|
||||
swap = state[x];
|
||||
state[x] = state[y];
|
||||
state[y] = swap;
|
||||
stream |= state[static_cast<uint8_t>(state[x] + state[y])] << 24;
|
||||
|
||||
*reinterpret_cast<uint32_t*>(data + i) ^= stream;
|
||||
}
|
||||
|
||||
for (; i < length; i++) {
|
||||
x++;
|
||||
y += state[x];
|
||||
|
||||
uint8_t swap = state[x];
|
||||
state[x] = state[y];
|
||||
state[y] = swap;
|
||||
|
||||
data[i] ^= state[static_cast<uint8_t>(state[x] + state[y])];
|
||||
}
|
||||
|
||||
outKey->m_y = y;
|
||||
outKey->m_x = x;
|
||||
}
|
||||
|
||||
// VERIFY: 765600fe manual
|
||||
// OFFSET: 0x00775040
|
||||
void SARC4PrepareKey(const void* key, uint32_t length, SARC4Key* outKey) {
|
||||
if (!key) {
|
||||
SErrSetLastError(STORM_ERROR_INVALID_PARAMETER);
|
||||
return;
|
||||
}
|
||||
|
||||
const uint8_t* bytes = static_cast<const uint8_t*>(key);
|
||||
|
||||
for (uint32_t i = 0; i < 256; i++) {
|
||||
outKey->m_state[i] = i;
|
||||
}
|
||||
|
||||
outKey->m_x = 0;
|
||||
outKey->m_y = 0;
|
||||
|
||||
uint32_t keyIndex = 0;
|
||||
uint8_t j = 0;
|
||||
|
||||
for (uint32_t i = 0; i < 256; i++) {
|
||||
j += outKey->m_state[i] + bytes[keyIndex];
|
||||
|
||||
uint8_t swap = outKey->m_state[i];
|
||||
outKey->m_state[i] = outKey->m_state[j];
|
||||
outKey->m_state[j] = swap;
|
||||
|
||||
keyIndex = (keyIndex + 1) % length;
|
||||
}
|
||||
}
|
||||
@@ -27,6 +27,8 @@ class SSyncObject {
|
||||
|
||||
SSyncObject();
|
||||
~SSyncObject();
|
||||
void Close();
|
||||
int32_t Valid();
|
||||
uint32_t Wait(uint32_t timeout);
|
||||
};
|
||||
|
||||
|
||||
@@ -251,6 +251,12 @@ void CSRWLock::Leave(int32_t fromwriting) {
|
||||
SRWLock::SURWLockLeave(&this->m_opaqueData, fromwriting);
|
||||
}
|
||||
|
||||
// VERIFY: 772d14e5 auto
|
||||
// OFFSET: 0x00774680
|
||||
int32_t SSyncObject::Valid() {
|
||||
return this->m_opaqueData != nullptr;
|
||||
}
|
||||
|
||||
// VERIFY: 5c31264f auto
|
||||
// OFFSET: 0x00774690
|
||||
uint32_t SSyncObject::Wait(uint32_t timeout) {
|
||||
@@ -405,6 +411,13 @@ SSyncObject::~SSyncObject() {
|
||||
}
|
||||
}
|
||||
|
||||
void SSyncObject::Close() {
|
||||
if (this->m_opaqueData) {
|
||||
CloseHandle(this->m_opaqueData);
|
||||
this->m_opaqueData = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
// VERIFY: a506d9c5 auto
|
||||
// OFFSET: 0x00774900
|
||||
SEvent::SEvent(int32_t manualReset, int32_t initialState) {
|
||||
|
||||
@@ -238,6 +238,11 @@ void CSRWLock::Leave(int32_t fromwriting) {
|
||||
SRWLock::SURWLockLeave(&this->m_opaqueData, fromwriting);
|
||||
}
|
||||
|
||||
// OFFSET: 0x00774680
|
||||
int32_t SSyncObject::Valid() {
|
||||
return this->m_opaqueData != nullptr;
|
||||
}
|
||||
|
||||
// OFFSET: 0x00774690
|
||||
uint32_t SSyncObject::Wait(uint32_t timeout) {
|
||||
return WaitForSingleObject(this->m_opaqueData, timeout);
|
||||
@@ -380,6 +385,13 @@ SSyncObject::~SSyncObject() {
|
||||
}
|
||||
}
|
||||
|
||||
void SSyncObject::Close() {
|
||||
if (this->m_opaqueData) {
|
||||
CloseHandle(this->m_opaqueData);
|
||||
this->m_opaqueData = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
// OFFSET: 0x00774900
|
||||
SEvent::SEvent(int32_t manualReset, int32_t initialState) {
|
||||
this->m_opaqueData = CreateEventA(nullptr, manualReset, initialState, nullptr);
|
||||
|
||||
@@ -4,6 +4,27 @@
|
||||
#include "Engine/Source/Tempest/C44Matrix.h"
|
||||
#include "Engine/Source/Tempest/C4Quaternion.h"
|
||||
|
||||
// VERIFY: cbb36d4b auto
|
||||
// OFFSET: 0x004E26F0
|
||||
C44Matrix::C44Matrix(float scale) {
|
||||
this->a0 = scale;
|
||||
this->a1 = 0.0f;
|
||||
this->a2 = 0.0f;
|
||||
this->a3 = 0.0f;
|
||||
this->b0 = 0.0f;
|
||||
this->b1 = scale;
|
||||
this->b2 = 0.0f;
|
||||
this->b3 = 0.0f;
|
||||
this->c0 = 0.0f;
|
||||
this->c1 = 0.0f;
|
||||
this->c2 = scale;
|
||||
this->c3 = 0.0f;
|
||||
this->d0 = 0.0f;
|
||||
this->d1 = 0.0f;
|
||||
this->d2 = 0.0f;
|
||||
this->d3 = 1.0f;
|
||||
}
|
||||
|
||||
// INLINED
|
||||
C44Matrix::C44Matrix(float a0, float a1, float a2, float a3, float b0, float b1, float b2, float b3, float c0, float c1, float c2, float c3, float d0, float d1, float d2, float d3) {
|
||||
this->a0 = a0;
|
||||
|
||||
@@ -36,6 +36,7 @@ class C44Matrix {
|
||||
/* 003C */ float d3;
|
||||
|
||||
C44Matrix();
|
||||
explicit C44Matrix(float scale);
|
||||
C44Matrix(float a0, float a1, float a2, float a3, float b0, float b1, float b2, float b3, float c0, float c1, float c2, float c3, float d0, float d1, float d2, float d3);
|
||||
C44Matrix(const C33Matrix& m);
|
||||
C44Matrix(const C34Matrix& m);
|
||||
|
||||
@@ -130,6 +130,33 @@ uint32_t CFrustum::Cull(const C3Vector& center, float radius) {
|
||||
return this->Cull(sphere);
|
||||
}
|
||||
|
||||
// VERIFY: 0ece7724 manual
|
||||
// OFFSET: 0x00601650
|
||||
CFrustum::CFrustum() {
|
||||
for (uint32_t i = 0; i < 6; i++) {
|
||||
this->planes[i].n.x = 0.0f;
|
||||
this->planes[i].n.y = 0.0f;
|
||||
this->planes[i].d = 0.0f;
|
||||
this->planes[i].n.z = 1.0f;
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < 8; i++) {
|
||||
this->corners[i].x = 0.0f;
|
||||
this->corners[i].y = 0.0f;
|
||||
this->corners[i].z = 0.0f;
|
||||
}
|
||||
|
||||
this->lookPos.x = 0.0f;
|
||||
this->lookPos.y = 0.0f;
|
||||
this->lookPos.z = 0.0f;
|
||||
this->lookAt.x = 0.0f;
|
||||
this->lookAt.y = 0.0f;
|
||||
this->lookAt.z = 0.0f;
|
||||
this->lookUp.x = 0.0f;
|
||||
this->lookUp.y = 0.0f;
|
||||
this->lookUp.z = 0.0f;
|
||||
}
|
||||
|
||||
// VERIFY: 6f48db85 manual
|
||||
// OFFSET: 0x00983FE0
|
||||
CFrustum::CFrustum(const C3Vector* corners) {
|
||||
@@ -156,3 +183,27 @@ void CFrustum::CalcPlanesFromCorners(const C3Vector* corners) {
|
||||
|
||||
this->CalcPlanesFromCorners();
|
||||
}
|
||||
|
||||
// VERIFY: 1bd5200d auto
|
||||
// OFFSET: 0x00790020
|
||||
CFrustum& CFrustum::operator=(const CFrustum& source) {
|
||||
if (this != &source) {
|
||||
for (uint32_t i = 0; i < 6; i++) {
|
||||
this->planes[i] = source.planes[i];
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < 8; i++) {
|
||||
this->corners[i] = source.corners[i];
|
||||
}
|
||||
|
||||
this->lookPos = source.lookPos;
|
||||
this->lookAt = source.lookAt;
|
||||
this->lookUp = source.lookUp;
|
||||
this->fovy = source.fovy;
|
||||
this->aspect = source.aspect;
|
||||
this->minz = source.minz;
|
||||
this->maxz = source.maxz;
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
@@ -17,7 +17,12 @@ class CFrustum {
|
||||
/* 00C0 */ C3Vector lookPos;
|
||||
/* 00CC */ C3Vector lookAt;
|
||||
/* 00D8 */ C3Vector lookUp;
|
||||
/* 00E4 */ float fovy;
|
||||
/* 00E8 */ float aspect;
|
||||
/* 00EC */ float minz;
|
||||
/* 00F0 */ float maxz;
|
||||
|
||||
CFrustum();
|
||||
CFrustum(const C3Vector* corners);
|
||||
void CalcPlanesFromCorners();
|
||||
void CalcPlanesFromCorners(const C3Vector* corners);
|
||||
@@ -27,8 +32,10 @@ class CFrustum {
|
||||
uint32_t Cull(const C3Vector& center, float radius);
|
||||
uint32_t CullInv(const CAaBox& box);
|
||||
void Extents(CAaBox& box);
|
||||
void InvertPlanes();
|
||||
void Transform(const C44Matrix& m);
|
||||
void Translate(const C3Vector& v);
|
||||
CFrustum& operator=(const CFrustum& source);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
file(GLOB_RECURSE PRIVATE_SOURCES CONFIGURE_DEPENDS "*.cpp")
|
||||
|
||||
add_library(pcreposix STATIC
|
||||
${PRIVATE_SOURCES}
|
||||
)
|
||||
|
||||
target_include_directories(pcreposix
|
||||
PUBLIC
|
||||
${CMAKE_SOURCE_DIR}
|
||||
)
|
||||
|
||||
target_link_libraries(pcreposix
|
||||
PRIVATE
|
||||
pcre
|
||||
)
|
||||
@@ -0,0 +1,243 @@
|
||||
#include "pcreposix.h"
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include "pcre.h"
|
||||
|
||||
static const int32_t POSIX_MALLOC_THRESHOLD = 10;
|
||||
|
||||
// STATIC: 0x00A46180
|
||||
static const char* const estring[] = {
|
||||
"\\ at end of pattern",
|
||||
"\\c at end of pattern",
|
||||
"unrecognized character follows \\",
|
||||
"numbers out of order in {} quantifier",
|
||||
"number too big in {} quantifier",
|
||||
"missing terminating ] for character class",
|
||||
"invalid escape sequence in character class",
|
||||
"range out of order in character class",
|
||||
"nothing to repeat",
|
||||
"operand of unlimited repeat could match the empty string",
|
||||
"internal error: unexpected repeat",
|
||||
"unrecognized character after (?",
|
||||
"POSIX named classes are supported only within a class",
|
||||
"missing )",
|
||||
"reference to non-existent subpattern",
|
||||
"erroffset passed as NULL",
|
||||
"unknown option bit(s) set",
|
||||
"missing ) after comment",
|
||||
"parentheses nested too deeply",
|
||||
"regular expression too large",
|
||||
"failed to get memory",
|
||||
"unmatched parentheses",
|
||||
"internal error: code overflow",
|
||||
"unrecognized character after (?<",
|
||||
"lookbehind assertion is not fixed length",
|
||||
"malformed number after (?(",
|
||||
"conditional group contains more than two branches",
|
||||
"(?R or (?digits must be followed by )",
|
||||
"(?R or (?digits must be followed by )",
|
||||
"unknown POSIX class name",
|
||||
"POSIX collating elements are not supported",
|
||||
"this version of PCRE is not compiled with PCRE_UTF8 support",
|
||||
"spare error",
|
||||
"character value in \\x{...} sequence is too large",
|
||||
"invalid condition (?(0)",
|
||||
"\\C not allowed in lookbehind assertion",
|
||||
"PCRE does not support \\L, \\l, \\N, \\U, or \\u",
|
||||
"number after (?C is > 255",
|
||||
"closing ) for (?C expected",
|
||||
"recursive call could loop indefinitely",
|
||||
"unrecognized character after (?P",
|
||||
"syntax error after (?P",
|
||||
"two named groups have the same name",
|
||||
"invalid UTF-8 string",
|
||||
"support for \\P, \\p, and \\X has not been compiled",
|
||||
"malformed \\P or \\p sequence",
|
||||
"unknown property name after \\P or \\p"
|
||||
};
|
||||
|
||||
// STATIC: 0x00A46240
|
||||
static const int32_t eint[] = {
|
||||
REG_EESCAPE,
|
||||
REG_EESCAPE,
|
||||
REG_EESCAPE,
|
||||
REG_BADBR,
|
||||
REG_BADBR,
|
||||
REG_EBRACK,
|
||||
REG_ECTYPE,
|
||||
REG_ERANGE,
|
||||
REG_BADRPT,
|
||||
REG_BADRPT,
|
||||
REG_ASSERT,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_EPAREN,
|
||||
REG_ESUBREG,
|
||||
REG_INVARG,
|
||||
REG_INVARG,
|
||||
REG_EPAREN,
|
||||
REG_ESIZE,
|
||||
REG_ESIZE,
|
||||
REG_ESPACE,
|
||||
REG_EPAREN,
|
||||
REG_ASSERT,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_ECTYPE,
|
||||
REG_BADPAT,
|
||||
REG_INVARG,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_EESCAPE,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT,
|
||||
REG_BADPAT
|
||||
};
|
||||
|
||||
// VERIFY: 6b643012 manual
|
||||
// OFFSET: 0x0083DEC0
|
||||
static int32_t pcre_posix_error_code(const char* s) {
|
||||
for (size_t i = 0; i < sizeof(estring) / sizeof(estring[0]); i++) {
|
||||
if (strcmp(s, estring[i]) == 0) {
|
||||
return eint[i];
|
||||
}
|
||||
}
|
||||
|
||||
return REG_ASSERT;
|
||||
}
|
||||
|
||||
// VERIFY: 086e456f manual
|
||||
// OFFSET: 0x0083DF20
|
||||
int32_t regcomp(regex_t* preg, const char* pattern, int32_t cflags) {
|
||||
const char* errorptr;
|
||||
int erroffset;
|
||||
int options = PCRE_UTF8 | PCRE_NO_UTF8_CHECK;
|
||||
|
||||
if ((cflags & REG_ICASE) != 0) {
|
||||
options |= PCRE_CASELESS;
|
||||
}
|
||||
|
||||
if ((cflags & REG_NEWLINE) != 0) {
|
||||
options |= PCRE_MULTILINE;
|
||||
}
|
||||
|
||||
preg->re_pcre = pcre_compile(pattern, options, &errorptr, &erroffset, nullptr);
|
||||
preg->re_erroffset = erroffset;
|
||||
|
||||
if (preg->re_pcre == nullptr) {
|
||||
return pcre_posix_error_code(errorptr);
|
||||
}
|
||||
|
||||
preg->re_extra = nullptr;
|
||||
preg->re_nsub = pcre_info(static_cast<const pcre*>(preg->re_pcre), nullptr, nullptr);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// VERIFY: 50a3d188 manual
|
||||
// OFFSET: 0x0083DFA0
|
||||
int32_t regexec(const regex_t* preg, const char* string, size_t nmatch, regmatch_t pmatch[], int32_t eflags) {
|
||||
int rc;
|
||||
int options = PCRE_NO_UTF8_CHECK;
|
||||
int* ovector = nullptr;
|
||||
int small_ovector[POSIX_MALLOC_THRESHOLD * 3];
|
||||
bool allocated_ovector = false;
|
||||
|
||||
if ((eflags & REG_NOTBOL) != 0) {
|
||||
options |= PCRE_NOTBOL;
|
||||
}
|
||||
|
||||
if ((eflags & REG_NOTEOL) != 0) {
|
||||
options |= PCRE_NOTEOL;
|
||||
}
|
||||
|
||||
const_cast<regex_t*>(preg)->re_erroffset = static_cast<size_t>(-1);
|
||||
|
||||
if (nmatch > 0) {
|
||||
if (nmatch <= POSIX_MALLOC_THRESHOLD) {
|
||||
ovector = &small_ovector[0];
|
||||
} else {
|
||||
ovector = static_cast<int*>(malloc(sizeof(int) * nmatch * 3));
|
||||
|
||||
if (ovector == nullptr) {
|
||||
return REG_ESPACE;
|
||||
}
|
||||
|
||||
allocated_ovector = true;
|
||||
}
|
||||
}
|
||||
|
||||
rc = pcre_exec(static_cast<const pcre*>(preg->re_pcre), preg->re_extra, string, static_cast<int>(strlen(string)), 0, options, ovector, static_cast<int>(nmatch * 3));
|
||||
|
||||
if (rc == 0) {
|
||||
rc = static_cast<int>(nmatch);
|
||||
}
|
||||
|
||||
if (rc >= 0) {
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < static_cast<size_t>(rc); i++) {
|
||||
pmatch[i].rm_so = ovector[i * 2];
|
||||
pmatch[i].rm_eo = ovector[i * 2 + 1];
|
||||
}
|
||||
|
||||
if (allocated_ovector) {
|
||||
free(ovector);
|
||||
}
|
||||
|
||||
for (; i < nmatch; i++) {
|
||||
pmatch[i].rm_so = pmatch[i].rm_eo = -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (allocated_ovector) {
|
||||
free(ovector);
|
||||
}
|
||||
|
||||
switch (rc) {
|
||||
case PCRE_ERROR_NOMATCH:
|
||||
return REG_NOMATCH;
|
||||
|
||||
case PCRE_ERROR_NULL:
|
||||
return REG_INVARG;
|
||||
|
||||
case PCRE_ERROR_BADOPTION:
|
||||
return REG_INVARG;
|
||||
|
||||
case PCRE_ERROR_BADMAGIC:
|
||||
return REG_INVARG;
|
||||
|
||||
case PCRE_ERROR_UNKNOWN_NODE:
|
||||
return REG_ASSERT;
|
||||
|
||||
case PCRE_ERROR_NOMEMORY:
|
||||
return REG_ESPACE;
|
||||
|
||||
case PCRE_ERROR_MATCHLIMIT:
|
||||
return REG_ESPACE;
|
||||
|
||||
case PCRE_ERROR_BADUTF8:
|
||||
return REG_INVARG;
|
||||
|
||||
case PCRE_ERROR_BADUTF8_OFFSET:
|
||||
return REG_INVARG;
|
||||
|
||||
default:
|
||||
return REG_ASSERT;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
#ifndef ENGINE_SOURCE_PCRE_PCREPOSIX_H
|
||||
#define ENGINE_SOURCE_PCRE_PCREPOSIX_H
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
|
||||
struct pcre_extra;
|
||||
|
||||
enum {
|
||||
REG_ICASE = 0x0001,
|
||||
REG_NEWLINE = 0x0002,
|
||||
REG_NOTBOL = 0x0004,
|
||||
REG_NOTEOL = 0x0008
|
||||
};
|
||||
|
||||
enum {
|
||||
REG_ASSERT = 1,
|
||||
REG_BADBR,
|
||||
REG_BADPAT,
|
||||
REG_BADRPT,
|
||||
REG_EBRACE,
|
||||
REG_EBRACK,
|
||||
REG_ECOLLATE,
|
||||
REG_ECTYPE,
|
||||
REG_EESCAPE,
|
||||
REG_EMPTY,
|
||||
REG_EPAREN,
|
||||
REG_ERANGE,
|
||||
REG_ESIZE,
|
||||
REG_ESPACE,
|
||||
REG_ESUBREG,
|
||||
REG_INVARG,
|
||||
REG_NOMATCH
|
||||
};
|
||||
|
||||
typedef int32_t regoff_t;
|
||||
|
||||
struct regex_t {
|
||||
/* 0000 */ void* re_pcre;
|
||||
/* 0004 */ pcre_extra* re_extra;
|
||||
/* 0008 */ size_t re_nsub;
|
||||
/* 000C */ size_t re_erroffset;
|
||||
};
|
||||
|
||||
struct regmatch_t {
|
||||
/* 0000 */ regoff_t rm_so;
|
||||
/* 0004 */ regoff_t rm_eo;
|
||||
};
|
||||
|
||||
int32_t regcomp(regex_t* preg, const char* pattern, int32_t cflags);
|
||||
int32_t regexec(const regex_t* preg, const char* string, size_t nmatch, regmatch_t pmatch[], int32_t eflags);
|
||||
|
||||
#endif
|
||||
Vendored
+20
@@ -110,6 +110,26 @@ target_include_directories(expat
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/expat/lib
|
||||
)
|
||||
|
||||
add_library(pcre STATIC
|
||||
pcre/pcre.c
|
||||
pcre/get.c
|
||||
pcre/study.c
|
||||
pcre/maketables.c
|
||||
)
|
||||
|
||||
target_compile_definitions(pcre
|
||||
PUBLIC
|
||||
PCRE_STATIC
|
||||
PRIVATE
|
||||
SUPPORT_UTF8
|
||||
SUPPORT_UCP
|
||||
)
|
||||
|
||||
target_include_directories(pcre
|
||||
PUBLIC
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/pcre
|
||||
)
|
||||
|
||||
add_library(DivxDecoder INTERFACE)
|
||||
|
||||
target_include_directories(DivxDecoder
|
||||
|
||||
Vendored
+6
@@ -0,0 +1,6 @@
|
||||
Written by: Philip Hazel <[email protected]>
|
||||
|
||||
University of Cambridge Computing Service,
|
||||
Cambridge, England. Phone: +44 1223 334714.
|
||||
|
||||
Copyright (c) 1997-2004 University of Cambridge
|
||||
Vendored
+45
@@ -0,0 +1,45 @@
|
||||
PCRE LICENCE
|
||||
------------
|
||||
|
||||
PCRE is a library of functions to support regular expressions whose syntax
|
||||
and semantics are as close as possible to those of the Perl 5 language.
|
||||
|
||||
Release 5 of PCRE is distributed under the terms of the "BSD" licence, as
|
||||
specified below. The documentation for PCRE, supplied in the "doc"
|
||||
directory, is distributed under the same terms as the software itself.
|
||||
|
||||
Written by: Philip Hazel <[email protected]>
|
||||
|
||||
University of Cambridge Computing Service,
|
||||
Cambridge, England. Phone: +44 1223 334714.
|
||||
|
||||
Copyright (c) 1997-2004 University of Cambridge
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
* Neither the name of the University of Cambridge nor the names of its
|
||||
contributors may be used to endorse or promote products derived from
|
||||
this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
End
|
||||
Vendored
+1611
File diff suppressed because it is too large
Load Diff
Vendored
+185
@@ -0,0 +1,185 @@
|
||||
Basic Installation
|
||||
==================
|
||||
|
||||
These are generic installation instructions that apply to systems that
|
||||
can run the `configure' shell script - Unix systems and any that imitate
|
||||
it. They are not specific to PCRE. There are PCRE-specific instructions
|
||||
for non-Unix systems in the file NON-UNIX-USE.
|
||||
|
||||
The `configure' shell script attempts to guess correct values for
|
||||
various system-dependent variables used during compilation. It uses
|
||||
those values to create a `Makefile' in each directory of the package.
|
||||
It may also create one or more `.h' files containing system-dependent
|
||||
definitions. Finally, it creates a shell script `config.status' that
|
||||
you can run in the future to recreate the current configuration, a file
|
||||
`config.cache' that saves the results of its tests to speed up
|
||||
reconfiguring, and a file `config.log' containing compiler output
|
||||
(useful mainly for debugging `configure').
|
||||
|
||||
If you need to do unusual things to compile the package, please try
|
||||
to figure out how `configure' could check whether to do them, and mail
|
||||
diffs or instructions to the address given in the `README' so they can
|
||||
be considered for the next release. If at some point `config.cache'
|
||||
contains results you don't want to keep, you may remove or edit it.
|
||||
|
||||
The file `configure.in' is used to create `configure' by a program
|
||||
called `autoconf'. You only need `configure.in' if you want to change
|
||||
it or regenerate `configure' using a newer version of `autoconf'.
|
||||
|
||||
The simplest way to compile this package is:
|
||||
|
||||
1. `cd' to the directory containing the package's source code and type
|
||||
`./configure' to configure the package for your system. If you're
|
||||
using `csh' on an old version of System V, you might need to type
|
||||
`sh ./configure' instead to prevent `csh' from trying to execute
|
||||
`configure' itself.
|
||||
|
||||
Running `configure' takes awhile. While running, it prints some
|
||||
messages telling which features it is checking for.
|
||||
|
||||
2. Type `make' to compile the package.
|
||||
|
||||
3. Optionally, type `make check' to run any self-tests that come with
|
||||
the package.
|
||||
|
||||
4. Type `make install' to install the programs and any data files and
|
||||
documentation.
|
||||
|
||||
5. You can remove the program binaries and object files from the
|
||||
source code directory by typing `make clean'. To also remove the
|
||||
files that `configure' created (so you can compile the package for
|
||||
a different kind of computer), type `make distclean'. There is
|
||||
also a `make maintainer-clean' target, but that is intended mainly
|
||||
for the package's developers. If you use it, you may have to get
|
||||
all sorts of other programs in order to regenerate files that came
|
||||
with the distribution.
|
||||
|
||||
Compilers and Options
|
||||
=====================
|
||||
|
||||
Some systems require unusual options for compilation or linking that
|
||||
the `configure' script does not know about. You can give `configure'
|
||||
initial values for variables by setting them in the environment. Using
|
||||
a Bourne-compatible shell, you can do that on the command line like
|
||||
this:
|
||||
CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure
|
||||
|
||||
Or on systems that have the `env' program, you can do it like this:
|
||||
env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure
|
||||
|
||||
Compiling For Multiple Architectures
|
||||
====================================
|
||||
|
||||
You can compile the package for more than one kind of computer at the
|
||||
same time, by placing the object files for each architecture in their
|
||||
own directory. To do this, you must use a version of `make' that
|
||||
supports the `VPATH' variable, such as GNU `make'. `cd' to the
|
||||
directory where you want the object files and executables to go and run
|
||||
the `configure' script. `configure' automatically checks for the
|
||||
source code in the directory that `configure' is in and in `..'.
|
||||
|
||||
If you have to use a `make' that does not supports the `VPATH'
|
||||
variable, you have to compile the package for one architecture at a time
|
||||
in the source code directory. After you have installed the package for
|
||||
one architecture, use `make distclean' before reconfiguring for another
|
||||
architecture.
|
||||
|
||||
Installation Names
|
||||
==================
|
||||
|
||||
By default, `make install' will install the package's files in
|
||||
`/usr/local/bin', `/usr/local/man', etc. You can specify an
|
||||
installation prefix other than `/usr/local' by giving `configure' the
|
||||
option `--prefix=PATH'.
|
||||
|
||||
You can specify separate installation prefixes for
|
||||
architecture-specific files and architecture-independent files. If you
|
||||
give `configure' the option `--exec-prefix=PATH', the package will use
|
||||
PATH as the prefix for installing programs and libraries.
|
||||
Documentation and other data files will still use the regular prefix.
|
||||
|
||||
In addition, if you use an unusual directory layout you can give
|
||||
options like `--bindir=PATH' to specify different values for particular
|
||||
kinds of files. Run `configure --help' for a list of the directories
|
||||
you can set and what kinds of files go in them.
|
||||
|
||||
If the package supports it, you can cause programs to be installed
|
||||
with an extra prefix or suffix on their names by giving `configure' the
|
||||
option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
|
||||
|
||||
Optional Features
|
||||
=================
|
||||
|
||||
Some packages pay attention to `--enable-FEATURE' options to
|
||||
`configure', where FEATURE indicates an optional part of the package.
|
||||
They may also pay attention to `--with-PACKAGE' options, where PACKAGE
|
||||
is something like `gnu-as' or `x' (for the X Window System). The
|
||||
`README' should mention any `--enable-' and `--with-' options that the
|
||||
package recognizes.
|
||||
|
||||
For packages that use the X Window System, `configure' can usually
|
||||
find the X include and library files automatically, but if it doesn't,
|
||||
you can use the `configure' options `--x-includes=DIR' and
|
||||
`--x-libraries=DIR' to specify their locations.
|
||||
|
||||
Specifying the System Type
|
||||
==========================
|
||||
|
||||
There may be some features `configure' can not figure out
|
||||
automatically, but needs to determine by the type of host the package
|
||||
will run on. Usually `configure' can figure that out, but if it prints
|
||||
a message saying it can not guess the host type, give it the
|
||||
`--host=TYPE' option. TYPE can either be a short name for the system
|
||||
type, such as `sun4', or a canonical name with three fields:
|
||||
CPU-COMPANY-SYSTEM
|
||||
|
||||
See the file `config.sub' for the possible values of each field. If
|
||||
`config.sub' isn't included in this package, then this package doesn't
|
||||
need to know the host type.
|
||||
|
||||
If you are building compiler tools for cross-compiling, you can also
|
||||
use the `--target=TYPE' option to select the type of system they will
|
||||
produce code for and the `--build=TYPE' option to select the type of
|
||||
system on which you are compiling the package.
|
||||
|
||||
Sharing Defaults
|
||||
================
|
||||
|
||||
If you want to set default values for `configure' scripts to share,
|
||||
you can create a site shell script called `config.site' that gives
|
||||
default values for variables like `CC', `cache_file', and `prefix'.
|
||||
`configure' looks for `PREFIX/share/config.site' if it exists, then
|
||||
`PREFIX/etc/config.site' if it exists. Or, you can set the
|
||||
`CONFIG_SITE' environment variable to the location of the site script.
|
||||
A warning: not all `configure' scripts look for a site script.
|
||||
|
||||
Operation Controls
|
||||
==================
|
||||
|
||||
`configure' recognizes the following options to control how it
|
||||
operates.
|
||||
|
||||
`--cache-file=FILE'
|
||||
Use and save the results of the tests in FILE instead of
|
||||
`./config.cache'. Set FILE to `/dev/null' to disable caching, for
|
||||
debugging `configure'.
|
||||
|
||||
`--help'
|
||||
Print a summary of the options to `configure', and exit.
|
||||
|
||||
`--quiet'
|
||||
`--silent'
|
||||
`-q'
|
||||
Do not print messages saying which checks are being made. To
|
||||
suppress all normal output, redirect it to `/dev/null' (any error
|
||||
messages will still be shown).
|
||||
|
||||
`--srcdir=DIR'
|
||||
Look for the package's source code in directory DIR. Usually
|
||||
`configure' can determine that directory automatically.
|
||||
|
||||
`--version'
|
||||
Print the version of Autoconf used to generate the `configure'
|
||||
script, and exit.
|
||||
|
||||
`configure' also accepts some other, not widely useful, options.
|
||||
Vendored
+45
@@ -0,0 +1,45 @@
|
||||
PCRE LICENCE
|
||||
------------
|
||||
|
||||
PCRE is a library of functions to support regular expressions whose syntax
|
||||
and semantics are as close as possible to those of the Perl 5 language.
|
||||
|
||||
Release 5 of PCRE is distributed under the terms of the "BSD" licence, as
|
||||
specified below. The documentation for PCRE, supplied in the "doc"
|
||||
directory, is distributed under the same terms as the software itself.
|
||||
|
||||
Written by: Philip Hazel <[email protected]>
|
||||
|
||||
University of Cambridge Computing Service,
|
||||
Cambridge, England. Phone: +44 1223 334714.
|
||||
|
||||
Copyright (c) 1997-2004 University of Cambridge
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
* Neither the name of the University of Cambridge nor the names of its
|
||||
contributors may be used to endorse or promote products derived from
|
||||
this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
End
|
||||
Vendored
+287
@@ -0,0 +1,287 @@
|
||||
|
||||
# Makefile.in for PCRE (Perl-Compatible Regular Expression) library.
|
||||
|
||||
|
||||
#############################################################################
|
||||
|
||||
# PCRE is developed on a Unix system. I do not use Windows or Macs, and know
|
||||
# nothing about building software on them. Although the code of PCRE should
|
||||
# be very portable, the building system in this Makefile is designed for Unix
|
||||
# systems. However, there are features that have been supplied to me by various
|
||||
# people that should make it work on MinGW and Cygwin systems.
|
||||
|
||||
# This setting enables Unix-style directory scanning in pcregrep, triggered
|
||||
# by the -f option. Maybe one day someone will add code for other systems.
|
||||
|
||||
PCREGREP_OSTYPE=-DIS_UNIX
|
||||
|
||||
#############################################################################
|
||||
|
||||
|
||||
#---------------------------------------------------------------------------#
|
||||
# The following lines are modified by "configure" to insert data that it is #
|
||||
# given in its arguments, or which it finds out for itself. #
|
||||
#---------------------------------------------------------------------------#
|
||||
|
||||
SHELL = @SHELL@
|
||||
prefix = @prefix@
|
||||
exec_prefix = @exec_prefix@
|
||||
top_srcdir = @top_srcdir@
|
||||
|
||||
mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
|
||||
|
||||
# NB: top_builddir is not referred to directly below, but it is used in the
|
||||
# setting of $(LIBTOOL), so don't remove it!
|
||||
|
||||
top_builddir = .
|
||||
|
||||
# BINDIR is the directory in which the pcregrep, pcretest, and pcre-config
|
||||
# commands are installed.
|
||||
# INCDIR is the directory in which the public header files pcre.h and
|
||||
# pcreposix.h are installed.
|
||||
# LIBDIR is the directory in which the libraries are installed.
|
||||
# MANDIR is the directory in which the man pages are installed.
|
||||
|
||||
BINDIR = @bindir@
|
||||
LIBDIR = @libdir@
|
||||
INCDIR = @includedir@
|
||||
MANDIR = @mandir@
|
||||
|
||||
# EXEEXT is set by configure to the extention of an executable file
|
||||
# OBJEXT is set by configure to the extention of an object file
|
||||
# The BUILD_* equivalents are the same but for the host we're building on
|
||||
|
||||
EXEEXT = @EXEEXT@
|
||||
OBJEXT = @OBJEXT@
|
||||
# Note that these are just here to have a convenient place to look at the
|
||||
# outcome.
|
||||
BUILD_EXEEXT = @BUILD_EXEEXT@
|
||||
BUILD_OBJEXT = @BUILD_OBJEXT@
|
||||
|
||||
# The compiler, C flags, preprocessor flags, etc
|
||||
|
||||
CC = @CC@
|
||||
CFLAGS = @CFLAGS@
|
||||
CPPFLAGS = @CPPFLAGS@
|
||||
|
||||
CC_FOR_BUILD = @CC_FOR_BUILD@
|
||||
CFLAGS_FOR_BUILD = @CFLAGS_FOR_BUILD@
|
||||
CPPFLAGS_FOR_BUILD = @CPPFLAGS_FOR_BUILD@
|
||||
|
||||
UCP = @UCP@
|
||||
UTF8 = @UTF8@
|
||||
NEWLINE = @NEWLINE@
|
||||
POSIX_MALLOC_THRESHOLD = @POSIX_MALLOC_THRESHOLD@
|
||||
LINK_SIZE = @LINK_SIZE@
|
||||
MATCH_LIMIT = @MATCH_LIMIT@
|
||||
NO_RECURSE = @NO_RECURSE@
|
||||
EBCDIC = @EBCDIC@
|
||||
|
||||
INSTALL = @INSTALL@
|
||||
INSTALL_DATA = @INSTALL_DATA@
|
||||
|
||||
# LIBTOOL enables the building of shared and static libraries. It is set up
|
||||
# to do one or the other or both by ./configure.
|
||||
|
||||
LIBTOOL = @LIBTOOL@
|
||||
LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) -c $(CFLAGS) -I. -I$(top_srcdir) $(NEWLINE) $(LINK_SIZE) $(MATCH_LIMIT) $(NO_RECURSE) $(EBCDIC)
|
||||
@ON_WINDOWS@LINK = $(CC) $(CFLAGS) -I. -I$(top_srcdir) -L.libs
|
||||
@NOT_ON_WINDOWS@LINK = $(LIBTOOL) --mode=link $(CC) $(CFLAGS) -I. -I$(top_srcdir)
|
||||
LINKLIB = $(LIBTOOL) --mode=link $(CC) $(CFLAGS) -I. -I$(top_srcdir)
|
||||
LINK_FOR_BUILD = $(LIBTOOL) --mode=link $(CC_FOR_BUILD) $(CFLAGS_FOR_BUILD) -I. -I$(top_srcdir)
|
||||
|
||||
# These are the version numbers for the shared libraries
|
||||
|
||||
PCRELIBVERSION = @PCRE_LIB_VERSION@
|
||||
PCREPOSIXLIBVERSION = @PCRE_POSIXLIB_VERSION@
|
||||
|
||||
##############################################################################
|
||||
|
||||
|
||||
OBJ = maketables.@OBJEXT@ get.@OBJEXT@ study.@OBJEXT@ pcre.@OBJEXT@ @POSIX_OBJ@
|
||||
LOBJ = maketables.lo get.lo study.lo pcre.lo @POSIX_LOBJ@
|
||||
|
||||
all: libpcre.la @POSIX_LIB@ pcretest@EXEEXT@ pcregrep@EXEEXT@ @ON_WINDOWS@ winshared
|
||||
|
||||
pcregrep@EXEEXT@: libpcre.la pcregrep.@OBJEXT@ @ON_WINDOWS@ winshared
|
||||
$(LINK) -o pcregrep@EXEEXT@ pcregrep.@OBJEXT@ libpcre.la
|
||||
|
||||
pcretest@EXEEXT@: libpcre.la @POSIX_LIB@ pcretest.@OBJEXT@ @ON_WINDOWS@ winshared
|
||||
$(LINK) $(PURIFY) $(EFENCE) -o pcretest@EXEEXT@ pcretest.@OBJEXT@ \
|
||||
libpcre.la @POSIX_LIB@
|
||||
|
||||
libpcre.la: $(OBJ)
|
||||
-rm -f libpcre.la
|
||||
$(LINKLIB) -rpath $(LIBDIR) -version-info \
|
||||
'$(PCRELIBVERSION)' -o libpcre.la $(LOBJ)
|
||||
|
||||
libpcreposix.la: libpcre.la pcreposix.@OBJEXT@
|
||||
-rm -f libpcreposix.la
|
||||
$(LINKLIB) -rpath $(LIBDIR) libpcre.la -version-info \
|
||||
'$(PCREPOSIXLIBVERSION)' -o libpcreposix.la pcreposix.lo
|
||||
|
||||
# Note that chartables.c is in the current directory, not the source directory.
|
||||
|
||||
pcre.@OBJEXT@: chartables.c $(top_srcdir)/pcre.c \
|
||||
$(top_srcdir)/internal.h $(top_srcdir)/printint.c \
|
||||
$(top_srcdir)/ucp.c $(top_srcdir)/ucp.h $(top_srcdir)/ucpinternal.h \
|
||||
$(top_srcdir)/ucptable.c $(top_srcdir)/ucptypetable.c \
|
||||
pcre.h config.h Makefile
|
||||
$(LTCOMPILE) $(UTF8) $(UCP) $(POSIX_MALLOC_THRESHOLD) $(top_srcdir)/pcre.c
|
||||
|
||||
pcreposix.@OBJEXT@: $(top_srcdir)/pcreposix.c $(top_srcdir)/pcreposix.h \
|
||||
$(top_srcdir)/internal.h pcre.h config.h Makefile
|
||||
$(LTCOMPILE) $(POSIX_MALLOC_THRESHOLD) $(top_srcdir)/pcreposix.c
|
||||
|
||||
maketables.@OBJEXT@: $(top_srcdir)/maketables.c $(top_srcdir)/internal.h \
|
||||
pcre.h config.h Makefile
|
||||
$(LTCOMPILE) $(top_srcdir)/maketables.c
|
||||
|
||||
get.@OBJEXT@: $(top_srcdir)/get.c $(top_srcdir)/internal.h \
|
||||
pcre.h config.h Makefile
|
||||
$(LTCOMPILE) $(top_srcdir)/get.c
|
||||
|
||||
study.@OBJEXT@: $(top_srcdir)/study.c $(top_srcdir)/internal.h \
|
||||
pcre.h config.h Makefile
|
||||
$(LTCOMPILE) $(UTF8) $(UCP) $(top_srcdir)/study.c
|
||||
|
||||
pcretest.@OBJEXT@: $(top_srcdir)/pcretest.c $(top_srcdir)/internal.h \
|
||||
$(top_srcdir)/printint.c \
|
||||
pcre.h config.h Makefile
|
||||
$(CC) -c $(CFLAGS) -I. $(UTF8) $(UCP) $(LINK_SIZE) $(top_srcdir)/pcretest.c
|
||||
|
||||
pcregrep.@OBJEXT@: $(top_srcdir)/pcregrep.c pcre.h Makefile config.h
|
||||
$(CC) -c $(CFLAGS) -I. $(UTF8) $(UCP) $(PCREGREP_OSTYPE) $(top_srcdir)/pcregrep.c
|
||||
|
||||
# Some Windows-specific targets for MinGW. Do not use for Cygwin.
|
||||
|
||||
winshared : .libs/@WIN_PREFIX@pcre.dll .libs/@WIN_PREFIX@pcreposix.dll
|
||||
|
||||
.libs/@[email protected] : libpcre.la
|
||||
$(CC) $(CFLAGS) -shared -o $@ \
|
||||
-Wl,--whole-archive .libs/libpcre.a \
|
||||
-Wl,--out-implib,.libs/libpcre.dll.a \
|
||||
-Wl,--output-def,.libs/@[email protected] \
|
||||
-Wl,--export-all-symbols \
|
||||
-Wl,--no-whole-archive
|
||||
sed -e "s#dlname=''#dlname='../bin/@[email protected]'#" \
|
||||
-e "s#library_names=''#library_names='libpcre.dll.a'#" \
|
||||
< .libs/libpcre.lai > .libs/libpcre.lai.tmp && \
|
||||
mv .libs/libpcre.lai.tmp .libs/libpcre.lai
|
||||
sed -e "s#dlname=''#dlname='../bin/@[email protected]'#" \
|
||||
-e "s#library_names=''#library_names='libpcre.dll.a'#" \
|
||||
< libpcre.la > libpcre.la.tmp && \
|
||||
mv libpcre.la.tmp libpcre.la
|
||||
|
||||
|
||||
.libs/@[email protected]: libpcreposix.la libpcre.la
|
||||
$(CC) $(CFLAGS) -shared -o $@ \
|
||||
-Wl,--whole-archive .libs/libpcreposix.a \
|
||||
-Wl,--out-implib,.libs/@[email protected] \
|
||||
-Wl,--output-def,.libs/@[email protected] \
|
||||
-Wl,--export-all-symbols \
|
||||
-Wl,--no-whole-archive .libs/libpcre.a
|
||||
sed -e "s#dlname=''#dlname='../bin/@[email protected]'#" \
|
||||
-e "s#library_names=''#library_names='libpcreposix.dll.a'#"\
|
||||
< .libs/libpcreposix.lai > .libs/libpcreposix.lai.tmp && \
|
||||
mv .libs/libpcreposix.lai.tmp .libs/libpcreposix.lai
|
||||
sed -e "s#dlname=''#dlname='../bin/@[email protected]'#" \
|
||||
-e "s#library_names=''#library_names='libpcreposix.dll.a'#"\
|
||||
< libpcreposix.la > libpcreposix.la.tmp && \
|
||||
mv libpcreposix.la.tmp libpcreposix.la
|
||||
|
||||
|
||||
wininstall : winshared
|
||||
$(mkinstalldirs) $(DESTDIR)$(LIBDIR)
|
||||
$(mkinstalldirs) $(DESTDIR)$(BINDIR)
|
||||
$(INSTALL) .libs/@[email protected] $(DESTDIR)$(BINDIR)/@[email protected]
|
||||
$(INSTALL) .libs/@[email protected] $(DESTDIR)$(BINDIR)/@[email protected]
|
||||
$(INSTALL) .libs/@[email protected] $(DESTDIR)$(LIBDIR)/@[email protected]
|
||||
$(INSTALL) .libs/@[email protected] $(DESTDIR)$(LIBDIR)/@[email protected]
|
||||
-strip -g $(DESTDIR)$(BINDIR)/@[email protected]
|
||||
-strip -g $(DESTDIR)$(BINDIR)/@[email protected]
|
||||
-strip $(DESTDIR)$(BINDIR)/pcregrep@EXEEXT@
|
||||
-strip $(DESTDIR)$(BINDIR)/pcretest@EXEEXT@
|
||||
|
||||
# An auxiliary program makes the default character table source. This is put
|
||||
# in the current directory, NOT the $top_srcdir directory.
|
||||
|
||||
chartables.c: dftables
|
||||
./dftables chartables.c
|
||||
|
||||
dftables.@BUILD_OBJEXT@: $(top_srcdir)/dftables.c $(top_srcdir)/maketables.c \
|
||||
$(top_srcdir)/internal.h pcre.h config.h Makefile
|
||||
$(CC_FOR_BUILD) -c $(CFLAGS_FOR_BUILD) -I. $(top_srcdir)/dftables.c
|
||||
|
||||
dftables: dftables.@BUILD_OBJEXT@
|
||||
$(LINK_FOR_BUILD) -o dftables dftables.@OBJEXT@
|
||||
|
||||
install: all @ON_WINDOWS@ wininstall
|
||||
@NOT_ON_WINDOWS@ $(mkinstalldirs) $(DESTDIR)$(LIBDIR)
|
||||
@NOT_ON_WINDOWS@ echo "$(LIBTOOL) --mode=install $(INSTALL) libpcre.la $(DESTDIR)$(LIBDIR)/libpcre.la"
|
||||
@NOT_ON_WINDOWS@ $(LIBTOOL) --mode=install $(INSTALL) libpcre.la $(DESTDIR)$(LIBDIR)/libpcre.la
|
||||
@NOT_ON_WINDOWS@ echo "$(LIBTOOL) --mode=install $(INSTALL) libpcreposix.la $(DESTDIR)$(LIBDIR)/libpcreposix.la"
|
||||
@NOT_ON_WINDOWS@ $(LIBTOOL) --mode=install $(INSTALL) libpcreposix.la $(DESTDIR)$(LIBDIR)/libpcreposix.la
|
||||
@NOT_ON_WINDOWS@ $(LIBTOOL) --finish $(DESTDIR)$(LIBDIR)
|
||||
$(mkinstalldirs) $(DESTDIR)$(INCDIR)
|
||||
$(INSTALL_DATA) pcre.h $(DESTDIR)$(INCDIR)/pcre.h
|
||||
$(INSTALL_DATA) $(top_srcdir)/pcreposix.h $(DESTDIR)$(INCDIR)/pcreposix.h
|
||||
$(mkinstalldirs) $(DESTDIR)$(MANDIR)/man3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre.3 $(DESTDIR)$(MANDIR)/man3/pcre.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcreapi.3 $(DESTDIR)$(MANDIR)/man3/pcreapi.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcrebuild.3 $(DESTDIR)$(MANDIR)/man3/pcrebuild.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcrecallout.3 $(DESTDIR)$(MANDIR)/man3/pcrecallout.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcrecompat.3 $(DESTDIR)$(MANDIR)/man3/pcrecompat.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcrepattern.3 $(DESTDIR)$(MANDIR)/man3/pcrepattern.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcreperform.3 $(DESTDIR)$(MANDIR)/man3/pcreperform.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcreposix.3 $(DESTDIR)$(MANDIR)/man3/pcreposix.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcresample.3 $(DESTDIR)$(MANDIR)/man3/pcresample.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre_compile.3 $(DESTDIR)$(MANDIR)/man3/pcre_compile.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre_config.3 $(DESTDIR)$(MANDIR)/man3/pcre_config.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre_copy_named_substring.3 $(DESTDIR)$(MANDIR)/man3/pcre_copy_named_substring.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre_copy_substring.3 $(DESTDIR)$(MANDIR)/man3/pcre_copy_substring.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre_exec.3 $(DESTDIR)$(MANDIR)/man3/pcre_exec.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre_free_substring.3 $(DESTDIR)$(MANDIR)/man3/pcre_free_substring.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre_free_substring_list.3 $(DESTDIR)$(MANDIR)/man3/pcre_free_substring_list.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre_fullinfo.3 $(DESTDIR)$(MANDIR)/man3/pcre_fullinfo.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre_get_named_substring.3 $(DESTDIR)$(MANDIR)/man3/pcre_get_named_substring.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre_get_stringnumber.3 $(DESTDIR)$(MANDIR)/man3/pcre_get_stringnumber.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre_get_substring.3 $(DESTDIR)$(MANDIR)/man3/pcre_get_substring.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre_get_substring_list.3 $(DESTDIR)$(MANDIR)/man3/pcre_get_substring_list.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre_info.3 $(DESTDIR)$(MANDIR)/man3/pcre_info.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre_maketables.3 $(DESTDIR)$(MANDIR)/man3/pcre_maketables.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre_study.3 $(DESTDIR)$(MANDIR)/man3/pcre_study.3
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcre_version.3 $(DESTDIR)$(MANDIR)/man3/pcre_version.3
|
||||
$(mkinstalldirs) $(DESTDIR)$(MANDIR)/man1
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcregrep.1 $(DESTDIR)$(MANDIR)/man1/pcregrep.1
|
||||
$(INSTALL_DATA) $(top_srcdir)/doc/pcretest.1 $(DESTDIR)$(MANDIR)/man1/pcretest.1
|
||||
$(mkinstalldirs) $(DESTDIR)$(BINDIR)
|
||||
$(LIBTOOL) --mode=install $(INSTALL) pcregrep@EXEEXT@ $(DESTDIR)$(BINDIR)/pcregrep@EXEEXT@
|
||||
$(LIBTOOL) --mode=install $(INSTALL) pcretest@EXEEXT@ $(DESTDIR)$(BINDIR)/pcretest@EXEEXT@
|
||||
$(INSTALL) pcre-config $(DESTDIR)$(BINDIR)/pcre-config
|
||||
$(mkinstalldirs) $(DESTDIR)$(LIBDIR)/pkgconfig
|
||||
$(INSTALL) libpcre.pc $(DESTDIR)$(LIBDIR)/pkgconfig/libpcre.pc
|
||||
|
||||
# We deliberately omit dftables and chartables.c from 'make clean'; once made
|
||||
# chartables.c shouldn't change, and if people have edited the tables by hand,
|
||||
# you don't want to throw them away.
|
||||
|
||||
clean:; -rm -rf *.@OBJEXT@ *.lo *.a *.la .libs pcretest@EXEEXT@ pcregrep@EXEEXT@ testtry
|
||||
|
||||
# But "make distclean" should get back to a virgin distribution
|
||||
|
||||
distclean: clean
|
||||
-rm -f chartables.c libtool pcre-config pcre.h \
|
||||
Makefile config.h config.status config.log config.cache
|
||||
|
||||
check: runtest
|
||||
|
||||
@[email protected] : winshared
|
||||
cp .libs/@[email protected] .
|
||||
|
||||
test: runtest
|
||||
|
||||
runtest: all @ON_WINDOWS@ @WIN_PREFIX@pcre.dll
|
||||
@./RunTest
|
||||
|
||||
# End
|
||||
Vendored
+201
@@ -0,0 +1,201 @@
|
||||
News about PCRE releases
|
||||
------------------------
|
||||
|
||||
Release 5.0 13-Sep-04
|
||||
---------------------
|
||||
|
||||
The licence under which PCRE is released has been changed to the more
|
||||
conventional "BSD" licence.
|
||||
|
||||
In the code, some bugs have been fixed, and there are also some major changes
|
||||
in this release (which is why I've increased the number to 5.0). Some changes
|
||||
are internal rearrangements, and some provide a number of new facilities. The
|
||||
new features are:
|
||||
|
||||
1. There's an "automatic callout" feature that inserts callouts before every
|
||||
item in the regex, and there's a new callout field that gives the position
|
||||
in the pattern - useful for debugging and tracing.
|
||||
|
||||
2. The extra_data structure can now be used to pass in a set of character
|
||||
tables at exec time. This is useful if compiled regex are saved and re-used
|
||||
at a later time when the tables may not be at the same address. If the
|
||||
default internal tables are used, the pointer saved with the compiled
|
||||
pattern is now set to NULL, which means that you don't need to do anything
|
||||
special unless you are using custom tables.
|
||||
|
||||
3. It is possible, with some restrictions on the content of the regex, to
|
||||
request "partial" matching. A special return code is given if all of the
|
||||
subject string matched part of the regex. This could be useful for testing
|
||||
an input field as it is being typed.
|
||||
|
||||
4. There is now some optional support for Unicode character properties, which
|
||||
means that the patterns items such as \p{Lu} and \X can now be used. Only
|
||||
the general category properties are supported. If PCRE is compiled with this
|
||||
support, an additional 90K data structure is include, which increases the
|
||||
size of the library dramatically.
|
||||
|
||||
5. There is support for saving compiled patterns and re-using them later.
|
||||
|
||||
6. There is support for running regular expressions that were compiled on a
|
||||
different host with the opposite endianness.
|
||||
|
||||
7. The pcretest program has been extended to accommodate the new features.
|
||||
|
||||
The main internal rearrangement is that sequences of literal characters are no
|
||||
longer handled as strings. Instead, each character is handled on its own. This
|
||||
makes some UTF-8 handling easier, and makes the support of partial matching
|
||||
possible. Compiled patterns containing long literal strings will be larger as a
|
||||
result of this change; I hope that performance will not be much affected.
|
||||
|
||||
|
||||
Release 4.5 01-Dec-03
|
||||
---------------------
|
||||
|
||||
Again mainly a bug-fix and tidying release, with only a couple of new features:
|
||||
|
||||
1. It's possible now to compile PCRE so that it does not use recursive
|
||||
function calls when matching. Instead it gets memory from the heap. This slows
|
||||
things down, but may be necessary on systems with limited stacks.
|
||||
|
||||
2. UTF-8 string checking has been tightened to reject overlong sequences and to
|
||||
check that a starting offset points to the start of a character. Failure of the
|
||||
latter returns a new error code: PCRE_ERROR_BADUTF8_OFFSET.
|
||||
|
||||
3. PCRE can now be compiled for systems that use EBCDIC code.
|
||||
|
||||
|
||||
Release 4.4 21-Aug-03
|
||||
---------------------
|
||||
|
||||
This is mainly a bug-fix and tidying release. The only new feature is that PCRE
|
||||
checks UTF-8 strings for validity by default. There is an option to suppress
|
||||
this, just in case anybody wants that teeny extra bit of performance.
|
||||
|
||||
|
||||
Releases 4.1 - 4.3
|
||||
------------------
|
||||
|
||||
Sorry, I forgot about updating the NEWS file for these releases. Please take a
|
||||
look at ChangeLog.
|
||||
|
||||
|
||||
Release 4.0 17-Feb-03
|
||||
---------------------
|
||||
|
||||
There have been a lot of changes for the 4.0 release, adding additional
|
||||
functionality and mending bugs. Below is a list of the highlights of the new
|
||||
functionality. For full details of these features, please consult the
|
||||
documentation. For a complete list of changes, see the ChangeLog file.
|
||||
|
||||
1. Support for Perl's \Q...\E escapes.
|
||||
|
||||
2. "Possessive quantifiers" ?+, *+, ++, and {,}+ which come from Sun's Java
|
||||
package. They provide some syntactic sugar for simple cases of "atomic
|
||||
grouping".
|
||||
|
||||
3. Support for the \G assertion. It is true when the current matching position
|
||||
is at the start point of the match.
|
||||
|
||||
4. A new feature that provides some of the functionality that Perl provides
|
||||
with (?{...}). The facility is termed a "callout". The way it is done in PCRE
|
||||
is for the caller to provide an optional function, by setting pcre_callout to
|
||||
its entry point. To get the function called, the regex must include (?C) at
|
||||
appropriate points.
|
||||
|
||||
5. Support for recursive calls to individual subpatterns. This makes it really
|
||||
easy to get totally confused.
|
||||
|
||||
6. Support for named subpatterns. The Python syntax (?P<name>...) is used to
|
||||
name a group.
|
||||
|
||||
7. Several extensions to UTF-8 support; it is now fairly complete. There is an
|
||||
option for pcregrep to make it operate in UTF-8 mode.
|
||||
|
||||
8. The single man page has been split into a number of separate man pages.
|
||||
These also give rise to individual HTML pages which are put in a separate
|
||||
directory. There is an index.html page that lists them all. Some hyperlinking
|
||||
between the pages has been installed.
|
||||
|
||||
|
||||
Release 3.5 15-Aug-01
|
||||
---------------------
|
||||
|
||||
1. The configuring system has been upgraded to use later versions of autoconf
|
||||
and libtool. By default it builds both a shared and a static library if the OS
|
||||
supports it. You can use --disable-shared or --disable-static on the configure
|
||||
command if you want only one of them.
|
||||
|
||||
2. The pcretest utility is now installed along with pcregrep because it is
|
||||
useful for users (to test regexs) and by doing this, it automatically gets
|
||||
relinked by libtool. The documentation has been turned into a man page, so
|
||||
there are now .1, .txt, and .html versions in /doc.
|
||||
|
||||
3. Upgrades to pcregrep:
|
||||
(i) Added long-form option names like gnu grep.
|
||||
(ii) Added --help to list all options with an explanatory phrase.
|
||||
(iii) Added -r, --recursive to recurse into sub-directories.
|
||||
(iv) Added -f, --file to read patterns from a file.
|
||||
|
||||
4. Added --enable-newline-is-cr and --enable-newline-is-lf to the configure
|
||||
script, to force use of CR or LF instead of \n in the source. On non-Unix
|
||||
systems, the value can be set in config.h.
|
||||
|
||||
5. The limit of 200 on non-capturing parentheses is a _nesting_ limit, not an
|
||||
absolute limit. Changed the text of the error message to make this clear, and
|
||||
likewise updated the man page.
|
||||
|
||||
6. The limit of 99 on the number of capturing subpatterns has been removed.
|
||||
The new limit is 65535, which I hope will not be a "real" limit.
|
||||
|
||||
|
||||
Release 3.3 01-Aug-00
|
||||
---------------------
|
||||
|
||||
There is some support for UTF-8 character strings. This is incomplete and
|
||||
experimental. The documentation describes what is and what is not implemented.
|
||||
Otherwise, this is just a bug-fixing release.
|
||||
|
||||
|
||||
Release 3.0 01-Feb-00
|
||||
---------------------
|
||||
|
||||
1. A "configure" script is now used to configure PCRE for Unix systems. It
|
||||
builds a Makefile, a config.h file, and the pcre-config script.
|
||||
|
||||
2. PCRE is built as a shared library by default.
|
||||
|
||||
3. There is support for POSIX classes such as [:alpha:].
|
||||
|
||||
5. There is an experimental recursion feature.
|
||||
|
||||
----------------------------------------------------------------------------
|
||||
IMPORTANT FOR THOSE UPGRADING FROM VERSIONS BEFORE 2.00
|
||||
|
||||
Please note that there has been a change in the API such that a larger
|
||||
ovector is required at matching time, to provide some additional workspace.
|
||||
The new man page has details. This change was necessary in order to support
|
||||
some of the new functionality in Perl 5.005.
|
||||
|
||||
IMPORTANT FOR THOSE UPGRADING FROM VERSION 2.00
|
||||
|
||||
Another (I hope this is the last!) change has been made to the API for the
|
||||
pcre_compile() function. An additional argument has been added to make it
|
||||
possible to pass over a pointer to character tables built in the current
|
||||
locale by pcre_maketables(). To use the default tables, this new arguement
|
||||
should be passed as NULL.
|
||||
|
||||
IMPORTANT FOR THOSE UPGRADING FROM VERSION 2.05
|
||||
|
||||
Yet another (and again I hope this really is the last) change has been made
|
||||
to the API for the pcre_exec() function. An additional argument has been
|
||||
added to make it possible to start the match other than at the start of the
|
||||
subject string. This is important if there are lookbehinds. The new man
|
||||
page has the details, but you just want to convert existing programs, all
|
||||
you need to do is to stick in a new fifth argument to pcre_exec(), with a
|
||||
value of zero. For example, change
|
||||
|
||||
pcre_exec(pattern, extra, subject, length, options, ovec, ovecsize)
|
||||
to
|
||||
pcre_exec(pattern, extra, subject, length, 0, options, ovec, ovecsize)
|
||||
|
||||
****
|
||||
Vendored
+244
@@ -0,0 +1,244 @@
|
||||
Compiling PCRE on non-Unix systems
|
||||
----------------------------------
|
||||
|
||||
See below for comments on Cygwin or MinGW and OpenVMS usage. I (Philip Hazel)
|
||||
have no knowledge of Windows or VMS sytems and how their libraries work. The
|
||||
items in the PCRE Makefile that relate to anything other than Unix-like systems
|
||||
have been contributed by PCRE users. There are some other comments and files in
|
||||
the Contrib directory on the ftp site that you may find useful. See
|
||||
|
||||
ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/Contrib
|
||||
|
||||
If you want to compile PCRE for a non-Unix system (or perhaps, more strictly,
|
||||
for a system that does not support "configure" and "make" files), note that
|
||||
PCRE consists entirely of code written in Standard C, and so should compile
|
||||
successfully on any system that has a Standard C compiler and library.
|
||||
|
||||
|
||||
GENERIC INSTRUCTIONS
|
||||
|
||||
The following are generic comments about building PCRE. The interspersed
|
||||
indented commands are suggestions from Mark Tetrode as to which commands you
|
||||
might use on a Windows system to build a static library.
|
||||
|
||||
(1) Copy or rename the file config.in as config.h, and change the macros that
|
||||
define HAVE_STRERROR and HAVE_MEMMOVE to define them as 1 rather than 0.
|
||||
Unfortunately, because of the way Unix autoconf works, the default setting has
|
||||
to be 0. You may also want to make changes to other macros in config.h. In
|
||||
particular, if you want to force a specific value for newline, you can define
|
||||
the NEWLINE macro. The default is to use '\n', thereby using whatever value
|
||||
your compiler gives to '\n'.
|
||||
|
||||
rem Mark Tetrode's commands
|
||||
copy config.in config.h
|
||||
rem Use write, because notepad cannot handle UNIX files. Change values.
|
||||
write config.h
|
||||
|
||||
(2) Copy or rename the file pcre.in as pcre.h, and change the macro definitions
|
||||
for PCRE_MAJOR, PCRE_MINOR, and PCRE_DATE near its start to the values set in
|
||||
configure.in.
|
||||
|
||||
rem Mark Tetrode's commands
|
||||
copy pcre.in pcre.h
|
||||
rem Read values from configure.in
|
||||
write configure.in
|
||||
rem Change values
|
||||
write pcre.h
|
||||
|
||||
(3) Compile dftables.c as a stand-alone program, and then run it with
|
||||
the single argument "chartables.c". This generates a set of standard
|
||||
character tables and writes them to that file.
|
||||
|
||||
rem Mark Tetrode's commands
|
||||
rem Compile & run
|
||||
cl -DSUPPORT_UTF8 dftables.c
|
||||
dftables.exe > chartables.c
|
||||
|
||||
(4) Compile maketables.c, get.c, study.c and pcre.c and link them all
|
||||
together into an object library in whichever form your system keeps such
|
||||
libraries. This is the pcre library (chartables.c is included by means of an
|
||||
#include directive). If your system has static and shared libraries, you may
|
||||
have to do this once for each type.
|
||||
|
||||
rem Mark Tetrode's commands, for a static library
|
||||
rem Compile & lib
|
||||
cl -DSUPPORT_UTF8 -DPOSIX_MALLOC_THRESHOLD=10 /c maketables.c get.c study.c pcre.c
|
||||
lib /OUT:pcre.lib maketables.obj get.obj study.obj pcre.obj
|
||||
|
||||
(5) Similarly, compile pcreposix.c and link it (on its own) as the pcreposix
|
||||
library.
|
||||
|
||||
rem Mark Tetrode's commands, for a static library
|
||||
rem Compile & lib
|
||||
cl -DSUPPORT_UTF8 -DPOSIX_MALLOC_THRESHOLD=10 /c pcreposix.c
|
||||
lib /OUT:pcreposix.lib pcreposix.obj
|
||||
|
||||
(6) Compile the test program pcretest.c. This needs the functions in the
|
||||
pcre and pcreposix libraries when linking.
|
||||
|
||||
rem Mark Tetrode's commands
|
||||
rem compile & link
|
||||
cl pcretest.c pcre.lib pcreposix.lib
|
||||
|
||||
(7) Run pcretest on the testinput files in the testdata directory, and check
|
||||
that the output matches the corresponding testoutput files. You must use the
|
||||
-i option when checking testinput2. Note that the supplied files are in Unix
|
||||
format, with just LF characters as line terminators. You may need to edit them
|
||||
to change this if your system uses a different convention.
|
||||
|
||||
rem Mark Tetrode's commands
|
||||
rem Make a change, i.e. space, backspace, and save again - do this for all
|
||||
rem to change UNIX to Win, \n to \n\r
|
||||
write testoutput1
|
||||
write testoutput2
|
||||
write testoutput3
|
||||
write testoutput4
|
||||
write testoutput5
|
||||
pcretest testdata\testinput1 testdata\myoutput1
|
||||
windiff testdata\testoutput1 testdata\myoutput1
|
||||
pcretest -i testdata\testinput2 testdata\myoutput2
|
||||
windiff testdata\testoutput2 testdata\myoutput2
|
||||
pcretest testdata\testinput3 testdata\myoutput3
|
||||
windiff testdata\testoutput3 testdata\myoutput3
|
||||
pcretest testdata\testinput4 testdata\myoutput4
|
||||
windiff testdata\testoutput4 testdata\myoutput4
|
||||
pcretest testdata\testinput5 testdata\myoutput5
|
||||
windiff testdata\testoutput5 testdata\myoutput5
|
||||
|
||||
|
||||
FURTHER REMARKS
|
||||
|
||||
If you have a system without "configure" but where you can use a Makefile, edit
|
||||
Makefile.in to create Makefile, substituting suitable values for the variables
|
||||
at the head of the file.
|
||||
|
||||
Some help in building a Win32 DLL of PCRE in GnuWin32 environments was
|
||||
contributed by Paul Sokolovsky. These environments are Mingw32
|
||||
(http://www.xraylith.wisc.edu/~khan/software/gnu-win32/) and CygWin
|
||||
(http://sourceware.cygnus.com/cygwin/). Paul comments:
|
||||
|
||||
For CygWin, set CFLAGS=-mno-cygwin, and do 'make dll'. You'll get
|
||||
pcre.dll (containing pcreposix also), libpcre.dll.a, and dynamically
|
||||
linked pgrep and pcretest. If you have /bin/sh, run RunTest (three
|
||||
main test go ok, locale not supported).
|
||||
|
||||
Changes to do MinGW with autoconf 2.50 were supplied by Fred Cox
|
||||
<[email protected]>, who comments as follows:
|
||||
|
||||
If you are using the PCRE DLL, the normal Unix style configure && make &&
|
||||
make check && make install should just work[*]. If you want to statically
|
||||
link against the .a file, you must define PCRE_STATIC before including
|
||||
pcre.h, otherwise the pcre_malloc and pcre_free exported functions will be
|
||||
declared __declspec(dllimport), with hilarious results. See the configure.in
|
||||
and pcretest.c for how it is done for the static test.
|
||||
|
||||
Also, there will only be a libpcre.la, not a libpcreposix.la, as you
|
||||
would expect from the Unix version. The single DLL includes the pcreposix
|
||||
interface.
|
||||
|
||||
[*] But note that the supplied test files are in Unix format, with just LF
|
||||
characters as line terminators. You will have to edit them to change to CR LF
|
||||
terminators.
|
||||
|
||||
A script for building PCRE using Borland's C++ compiler for use with VPASCAL
|
||||
was contributed by Alexander Tokarev. It is called makevp.bat.
|
||||
|
||||
These are some further comments about Win32 builds from Mark Evans. They
|
||||
were contributed before Fred Cox's changes were made, so it is possible that
|
||||
they may no longer be relevant.
|
||||
|
||||
"The documentation for Win32 builds is a bit shy. Under MSVC6 I
|
||||
followed their instructions to the letter, but there were still
|
||||
some things missing.
|
||||
|
||||
(1) Must #define STATIC for entire project if linking statically.
|
||||
(I see no reason to use DLLs for code this compact.) This of
|
||||
course is a project setting in MSVC under Preprocessor.
|
||||
|
||||
(2) Missing some #ifdefs relating to the function pointers
|
||||
pcre_malloc and pcre_free. See my solution below. (The stubs
|
||||
may not be mandatory but they made me feel better.)"
|
||||
|
||||
=========================
|
||||
#ifdef _WIN32
|
||||
#include <malloc.h>
|
||||
|
||||
void* malloc_stub(size_t N)
|
||||
{ return malloc(N); }
|
||||
void free_stub(void* p)
|
||||
{ free(p); }
|
||||
void *(*pcre_malloc)(size_t) = &malloc_stub;
|
||||
void (*pcre_free)(void *) = &free_stub;
|
||||
|
||||
#else
|
||||
|
||||
void *(*pcre_malloc)(size_t) = malloc;
|
||||
void (*pcre_free)(void *) = free;
|
||||
|
||||
#endif
|
||||
=========================
|
||||
|
||||
|
||||
BUILDING PCRE ON OPENVMS
|
||||
|
||||
Dan Mooney sent the following comments about building PCRE on OpenVMS:
|
||||
|
||||
"It was quite easy to compile and link the library. I don't have a formal
|
||||
make file but the attached file [reproduced below] contains the OpenVMS DCL
|
||||
commands I used to build the library. I had to add #define
|
||||
POSIX_MALLOC_THRESHOLD 10 to pcre.h since it was not defined anywhere.
|
||||
|
||||
The library was built on:
|
||||
O/S: HP OpenVMS v7.3-1
|
||||
Compiler: Compaq C v6.5-001-48BCD
|
||||
Linker: vA13-01
|
||||
|
||||
The test results did not match 100% due to the issues you mention in your
|
||||
documentation regarding isprint(), iscntrl(), isgraph() and ispunct(). I
|
||||
modified some of the character tables temporarily and was able to get the
|
||||
results to match. Tests using the fr locale did not match since I don't have
|
||||
that locale loaded. The study size was always reported to be 3 less than the
|
||||
value in the standard test output files."
|
||||
|
||||
=========================
|
||||
$! This DCL procedure builds PCRE on OpenVMS
|
||||
$!
|
||||
$! I followed the instructions in the non-unix-use file in the distribution.
|
||||
$!
|
||||
$ COMPILE == "CC/LIST/NOMEMBER_ALIGNMENT/PREFIX_LIBRARY_ENTRIES=ALL_ENTRIES
|
||||
$ COMPILE DFTABLES.C
|
||||
$ LINK/EXE=DFTABLES.EXE DFTABLES.OBJ
|
||||
$ RUN DFTABLES.EXE/OUTPUT=CHARTABLES.C
|
||||
$ COMPILE MAKETABLES.C
|
||||
$ COMPILE GET.C
|
||||
$ COMPILE STUDY.C
|
||||
$! I had to set POSIX_MALLOC_THRESHOLD to 10 in PCRE.H since the symbol
|
||||
$! did not seem to be defined anywhere.
|
||||
$! I edited pcre.h and added #DEFINE SUPPORT_UTF8 to enable UTF8 support.
|
||||
$ COMPILE PCRE.C
|
||||
$ LIB/CREATE PCRE MAKETABLES.OBJ, GET.OBJ, STUDY.OBJ, PCRE.OBJ
|
||||
$! I had to set POSIX_MALLOC_THRESHOLD to 10 in PCRE.H since the symbol
|
||||
$! did not seem to be defined anywhere.
|
||||
$ COMPILE PCREPOSIX.C
|
||||
$ LIB/CREATE PCREPOSIX PCREPOSIX.OBJ
|
||||
$ COMPILE PCRETEST.C
|
||||
$ LINK/EXE=PCRETEST.EXE PCRETEST.OBJ, PCRE/LIB, PCREPOSIX/LIB
|
||||
$! C programs that want access to command line arguments must be
|
||||
$! defined as a symbol
|
||||
$ PCRETEST :== "$ SYS$ROADSUSERS:[DMOONEY.REGEXP]PCRETEST.EXE"
|
||||
$! Arguments must be enclosed in quotes.
|
||||
$ PCRETEST "-C"
|
||||
$! Test results:
|
||||
$!
|
||||
$! The test results did not match 100%. The functions isprint(), iscntrl(),
|
||||
$! isgraph() and ispunct() on OpenVMS must not produce the same results
|
||||
$! as the system that built the test output files provided with the
|
||||
$! distribution.
|
||||
$!
|
||||
$! The study size did not match and was always 3 less on OpenVMS.
|
||||
$!
|
||||
$! Locale could not be set to fr
|
||||
$!
|
||||
=========================
|
||||
|
||||
****
|
||||
Vendored
+427
@@ -0,0 +1,427 @@
|
||||
README file for PCRE (Perl-compatible regular expression library)
|
||||
-----------------------------------------------------------------
|
||||
|
||||
The latest release of PCRE is always available from
|
||||
|
||||
ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre-xxx.tar.gz
|
||||
|
||||
Please read the NEWS file if you are upgrading from a previous release.
|
||||
|
||||
PCRE has its own native API, but a set of "wrapper" functions that are based on
|
||||
the POSIX API are also supplied in the library libpcreposix. Note that this
|
||||
just provides a POSIX calling interface to PCRE: the regular expressions
|
||||
themselves still follow Perl syntax and semantics. The header file
|
||||
for the POSIX-style functions is called pcreposix.h. The official POSIX name is
|
||||
regex.h, but I didn't want to risk possible problems with existing files of
|
||||
that name by distributing it that way. To use it with an existing program that
|
||||
uses the POSIX API, it will have to be renamed or pointed at by a link.
|
||||
|
||||
If you are using the POSIX interface to PCRE and there is already a POSIX regex
|
||||
library installed on your system, you must take care when linking programs to
|
||||
ensure that they link with PCRE's libpcreposix library. Otherwise they may pick
|
||||
up the "real" POSIX functions of the same name.
|
||||
|
||||
|
||||
Documentation for PCRE
|
||||
----------------------
|
||||
|
||||
If you install PCRE in the normal way, you will end up with an installed set of
|
||||
man pages whose names all start with "pcre". The one that is called "pcre"
|
||||
lists all the others. In addition to these man pages, the PCRE documentation is
|
||||
supplied in two other forms; however, as there is no standard place to install
|
||||
them, they are left in the doc directory of the unpacked source distribution.
|
||||
These forms are:
|
||||
|
||||
1. Files called doc/pcre.txt, doc/pcregrep.txt, and doc/pcretest.txt. The
|
||||
first of these is a concatenation of the text forms of all the section 3
|
||||
man pages except those that summarize individual functions. The other two
|
||||
are the text forms of the section 1 man pages for the pcregrep and
|
||||
pcretest commands. Text forms are provided for ease of scanning with text
|
||||
editors or similar tools.
|
||||
|
||||
2. A subdirectory called doc/html contains all the documentation in HTML
|
||||
form, hyperlinked in various ways, and rooted in a file called
|
||||
doc/index.html.
|
||||
|
||||
|
||||
Contributions by users of PCRE
|
||||
------------------------------
|
||||
|
||||
You can find contributions from PCRE users in the directory
|
||||
|
||||
ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/Contrib
|
||||
|
||||
where there is also a README file giving brief descriptions of what they are.
|
||||
Several of them provide support for compiling PCRE on various flavours of
|
||||
Windows systems (I myself do not use Windows). Some are complete in themselves;
|
||||
others are pointers to URLs containing relevant files.
|
||||
|
||||
|
||||
Building PCRE on a Unix-like system
|
||||
-----------------------------------
|
||||
|
||||
To build PCRE on a Unix-like system, first run the "configure" command from the
|
||||
PCRE distribution directory, with your current directory set to the directory
|
||||
where you want the files to be created. This command is a standard GNU
|
||||
"autoconf" configuration script, for which generic instructions are supplied in
|
||||
INSTALL.
|
||||
|
||||
Most commonly, people build PCRE within its own distribution directory, and in
|
||||
this case, on many systems, just running "./configure" is sufficient, but the
|
||||
usual methods of changing standard defaults are available. For example:
|
||||
|
||||
CFLAGS='-O2 -Wall' ./configure --prefix=/opt/local
|
||||
|
||||
specifies that the C compiler should be run with the flags '-O2 -Wall' instead
|
||||
of the default, and that "make install" should install PCRE under /opt/local
|
||||
instead of the default /usr/local.
|
||||
|
||||
If you want to build in a different directory, just run "configure" with that
|
||||
directory as current. For example, suppose you have unpacked the PCRE source
|
||||
into /source/pcre/pcre-xxx, but you want to build it in /build/pcre/pcre-xxx:
|
||||
|
||||
cd /build/pcre/pcre-xxx
|
||||
/source/pcre/pcre-xxx/configure
|
||||
|
||||
There are some optional features that can be included or omitted from the PCRE
|
||||
library. You can read more about them in the pcrebuild man page.
|
||||
|
||||
. If you want to make use of the support for UTF-8 character strings in PCRE,
|
||||
you must add --enable-utf8 to the "configure" command. Without it, the code
|
||||
for handling UTF-8 is not included in the library. (Even when included, it
|
||||
still has to be enabled by an option at run time.)
|
||||
|
||||
. If, in addition to support for UTF-8 character strings, you want to include
|
||||
support for the \P, \p, and \X sequences that recognize Unicode character
|
||||
properties, you must add --enable-unicode-properties to the "configure"
|
||||
command. This adds about 90K to the size of the library (in the form of a
|
||||
property table); only the basic two-letter properties such as Lu are
|
||||
supported.
|
||||
|
||||
. You can build PCRE to recognized CR or NL as the newline character, instead
|
||||
of whatever your compiler uses for "\n", by adding --newline-is-cr or
|
||||
--newline-is-nl to the "configure" command, respectively. Only do this if you
|
||||
really understand what you are doing. On traditional Unix-like systems, the
|
||||
newline character is NL.
|
||||
|
||||
. When called via the POSIX interface, PCRE uses malloc() to get additional
|
||||
storage for processing capturing parentheses if there are more than 10 of
|
||||
them. You can increase this threshold by setting, for example,
|
||||
|
||||
--with-posix-malloc-threshold=20
|
||||
|
||||
on the "configure" command.
|
||||
|
||||
. PCRE has a counter which can be set to limit the amount of resources it uses.
|
||||
If the limit is exceeded during a match, the match fails. The default is ten
|
||||
million. You can change the default by setting, for example,
|
||||
|
||||
--with-match-limit=500000
|
||||
|
||||
on the "configure" command. This is just the default; individual calls to
|
||||
pcre_exec() can supply their own value. There is discussion on the pcreapi
|
||||
man page.
|
||||
|
||||
. The default maximum compiled pattern size is around 64K. You can increase
|
||||
this by adding --with-link-size=3 to the "configure" command. You can
|
||||
increase it even more by setting --with-link-size=4, but this is unlikely
|
||||
ever to be necessary. If you build PCRE with an increased link size, test 2
|
||||
(and 5 if you are using UTF-8) will fail. Part of the output of these tests
|
||||
is a representation of the compiled pattern, and this changes with the link
|
||||
size.
|
||||
|
||||
. You can build PCRE so that its match() function does not call itself
|
||||
recursively. Instead, it uses blocks of data from the heap via special
|
||||
functions pcre_stack_malloc() and pcre_stack_free() to save data that would
|
||||
otherwise be saved on the stack. To build PCRE like this, use
|
||||
|
||||
--disable-stack-for-recursion
|
||||
|
||||
on the "configure" command. PCRE runs more slowly in this mode, but it may be
|
||||
necessary in environments with limited stack sizes.
|
||||
|
||||
The "configure" script builds seven files:
|
||||
|
||||
. pcre.h is build by copying pcre.in and making substitutions
|
||||
. Makefile is built by copying Makefile.in and making substitutions.
|
||||
. config.h is built by copying config.in and making substitutions.
|
||||
. pcre-config is built by copying pcre-config.in and making substitutions.
|
||||
. libpcre.pc is data for the pkg-config command, built from libpcre.pc.in
|
||||
. libtool is a script that builds shared and/or static libraries
|
||||
. RunTest is a script for running tests
|
||||
|
||||
Once "configure" has run, you can run "make". It builds two libraries called
|
||||
libpcre and libpcreposix, a test program called pcretest, and the pcregrep
|
||||
command. You can use "make install" to copy these, the public header files
|
||||
pcre.h and pcreposix.h, and the man pages to appropriate live directories on
|
||||
your system, in the normal way.
|
||||
|
||||
|
||||
Retrieving configuration information on Unix-like systems
|
||||
---------------------------------------------------------
|
||||
|
||||
Running "make install" also installs the command pcre-config, which can be used
|
||||
to recall information about the PCRE configuration and installation. For
|
||||
example:
|
||||
|
||||
pcre-config --version
|
||||
|
||||
prints the version number, and
|
||||
|
||||
pcre-config --libs
|
||||
|
||||
outputs information about where the library is installed. This command can be
|
||||
included in makefiles for programs that use PCRE, saving the programmer from
|
||||
having to remember too many details.
|
||||
|
||||
The pkg-config command is another system for saving and retrieving information
|
||||
about installed libraries. Instead of separate commands for each library, a
|
||||
single command is used. For example:
|
||||
|
||||
pkg-config --cflags pcre
|
||||
|
||||
The data is held in *.pc files that are installed in a directory called
|
||||
pkgconfig.
|
||||
|
||||
|
||||
Shared libraries on Unix-like systems
|
||||
-------------------------------------
|
||||
|
||||
The default distribution builds PCRE as two shared libraries and two static
|
||||
libraries, as long as the operating system supports shared libraries. Shared
|
||||
library support relies on the "libtool" script which is built as part of the
|
||||
"configure" process.
|
||||
|
||||
The libtool script is used to compile and link both shared and static
|
||||
libraries. They are placed in a subdirectory called .libs when they are newly
|
||||
built. The programs pcretest and pcregrep are built to use these uninstalled
|
||||
libraries (by means of wrapper scripts in the case of shared libraries). When
|
||||
you use "make install" to install shared libraries, pcregrep and pcretest are
|
||||
automatically re-built to use the newly installed shared libraries before being
|
||||
installed themselves. However, the versions left in the source directory still
|
||||
use the uninstalled libraries.
|
||||
|
||||
To build PCRE using static libraries only you must use --disable-shared when
|
||||
configuring it. For example:
|
||||
|
||||
./configure --prefix=/usr/gnu --disable-shared
|
||||
|
||||
Then run "make" in the usual way. Similarly, you can use --disable-static to
|
||||
build only shared libraries.
|
||||
|
||||
|
||||
Cross-compiling on a Unix-like system
|
||||
-------------------------------------
|
||||
|
||||
You can specify CC and CFLAGS in the normal way to the "configure" command, in
|
||||
order to cross-compile PCRE for some other host. However, during the building
|
||||
process, the dftables.c source file is compiled *and run* on the local host, in
|
||||
order to generate the default character tables (the chartables.c file). It
|
||||
therefore needs to be compiled with the local compiler, not the cross compiler.
|
||||
You can do this by specifying CC_FOR_BUILD (and if necessary CFLAGS_FOR_BUILD)
|
||||
when calling the "configure" command. If they are not specified, they default
|
||||
to the values of CC and CFLAGS.
|
||||
|
||||
|
||||
Building on non-Unix systems
|
||||
----------------------------
|
||||
|
||||
For a non-Unix system, read the comments in the file NON-UNIX-USE, though if
|
||||
the system supports the use of "configure" and "make" you may be able to build
|
||||
PCRE in the same way as for Unix systems.
|
||||
|
||||
PCRE has been compiled on Windows systems and on Macintoshes, but I don't know
|
||||
the details because I don't use those systems. It should be straightforward to
|
||||
build PCRE on any system that has a Standard C compiler, because it uses only
|
||||
Standard C functions.
|
||||
|
||||
|
||||
Testing PCRE
|
||||
------------
|
||||
|
||||
To test PCRE on a Unix system, run the RunTest script that is created by the
|
||||
configuring process. (This can also be run by "make runtest", "make check", or
|
||||
"make test".) For other systems, see the instructions in NON-UNIX-USE.
|
||||
|
||||
The script runs the pcretest test program (which is documented in its own man
|
||||
page) on each of the testinput files (in the testdata directory) in turn,
|
||||
and compares the output with the contents of the corresponding testoutput file.
|
||||
A file called testtry is used to hold the main output from pcretest
|
||||
(testsavedregex is also used as a working file). To run pcretest on just one of
|
||||
the test files, give its number as an argument to RunTest, for example:
|
||||
|
||||
RunTest 2
|
||||
|
||||
The first file can also be fed directly into the perltest script to check that
|
||||
Perl gives the same results. The only difference you should see is in the first
|
||||
few lines, where the Perl version is given instead of the PCRE version.
|
||||
|
||||
The second set of tests check pcre_fullinfo(), pcre_info(), pcre_study(),
|
||||
pcre_copy_substring(), pcre_get_substring(), pcre_get_substring_list(), error
|
||||
detection, and run-time flags that are specific to PCRE, as well as the POSIX
|
||||
wrapper API. It also uses the debugging flag to check some of the internals of
|
||||
pcre_compile().
|
||||
|
||||
If you build PCRE with a locale setting that is not the standard C locale, the
|
||||
character tables may be different (see next paragraph). In some cases, this may
|
||||
cause failures in the second set of tests. For example, in a locale where the
|
||||
isprint() function yields TRUE for characters in the range 128-255, the use of
|
||||
[:isascii:] inside a character class defines a different set of characters, and
|
||||
this shows up in this test as a difference in the compiled code, which is being
|
||||
listed for checking. Where the comparison test output contains [\x00-\x7f] the
|
||||
test will contain [\x00-\xff], and similarly in some other cases. This is not a
|
||||
bug in PCRE.
|
||||
|
||||
The third set of tests checks pcre_maketables(), the facility for building a
|
||||
set of character tables for a specific locale and using them instead of the
|
||||
default tables. The tests make use of the "fr_FR" (French) locale. Before
|
||||
running the test, the script checks for the presence of this locale by running
|
||||
the "locale" command. If that command fails, or if it doesn't include "fr_FR"
|
||||
in the list of available locales, the third test cannot be run, and a comment
|
||||
is output to say why. If running this test produces instances of the error
|
||||
|
||||
** Failed to set locale "fr_FR"
|
||||
|
||||
in the comparison output, it means that locale is not available on your system,
|
||||
despite being listed by "locale". This does not mean that PCRE is broken.
|
||||
|
||||
The fourth test checks the UTF-8 support. It is not run automatically unless
|
||||
PCRE is built with UTF-8 support. To do this you must set --enable-utf8 when
|
||||
running "configure". This file can be also fed directly to the perltest script,
|
||||
provided you are running Perl 5.8 or higher. (For Perl 5.6, a small patch,
|
||||
commented in the script, can be be used.)
|
||||
|
||||
The fifth test checks error handling with UTF-8 encoding, and internal UTF-8
|
||||
features of PCRE that are not relevant to Perl.
|
||||
|
||||
The sixth and final test checks the support for Unicode character properties.
|
||||
It it not run automatically unless PCRE is built with Unicode property support.
|
||||
To to this you must set --enable-unicode-properties when running "configure".
|
||||
|
||||
|
||||
Character tables
|
||||
----------------
|
||||
|
||||
PCRE uses four tables for manipulating and identifying characters whose values
|
||||
are less than 256. The final argument of the pcre_compile() function is a
|
||||
pointer to a block of memory containing the concatenated tables. A call to
|
||||
pcre_maketables() can be used to generate a set of tables in the current
|
||||
locale. If the final argument for pcre_compile() is passed as NULL, a set of
|
||||
default tables that is built into the binary is used.
|
||||
|
||||
The source file called chartables.c contains the default set of tables. This is
|
||||
not supplied in the distribution, but is built by the program dftables
|
||||
(compiled from dftables.c), which uses the ANSI C character handling functions
|
||||
such as isalnum(), isalpha(), isupper(), islower(), etc. to build the table
|
||||
sources. This means that the default C locale which is set for your system will
|
||||
control the contents of these default tables. You can change the default tables
|
||||
by editing chartables.c and then re-building PCRE. If you do this, you should
|
||||
probably also edit Makefile to ensure that the file doesn't ever get
|
||||
re-generated.
|
||||
|
||||
The first two 256-byte tables provide lower casing and case flipping functions,
|
||||
respectively. The next table consists of three 32-byte bit maps which identify
|
||||
digits, "word" characters, and white space, respectively. These are used when
|
||||
building 32-byte bit maps that represent character classes.
|
||||
|
||||
The final 256-byte table has bits indicating various character types, as
|
||||
follows:
|
||||
|
||||
1 white space character
|
||||
2 letter
|
||||
4 decimal digit
|
||||
8 hexadecimal digit
|
||||
16 alphanumeric or '_'
|
||||
128 regular expression metacharacter or binary zero
|
||||
|
||||
You should not alter the set of characters that contain the 128 bit, as that
|
||||
will cause PCRE to malfunction.
|
||||
|
||||
|
||||
Manifest
|
||||
--------
|
||||
|
||||
The distribution should contain the following files:
|
||||
|
||||
(A) The actual source files of the PCRE library functions and their
|
||||
headers:
|
||||
|
||||
dftables.c auxiliary program for building chartables.c
|
||||
|
||||
get.c )
|
||||
maketables.c )
|
||||
study.c ) source of the functions
|
||||
pcre.c ) in the library
|
||||
pcreposix.c )
|
||||
printint.c )
|
||||
|
||||
ucp.c )
|
||||
ucp.h ) source for the code that is used for
|
||||
ucpinternal.h ) Unicode property handling
|
||||
ucptable.c )
|
||||
ucptypetable.c )
|
||||
|
||||
pcre.in "source" for the header for the external API; pcre.h
|
||||
is built from this by "configure"
|
||||
pcreposix.h header for the external POSIX wrapper API
|
||||
internal.h header for internal use
|
||||
config.in template for config.h, which is built by configure
|
||||
|
||||
(B) Auxiliary files:
|
||||
|
||||
AUTHORS information about the author of PCRE
|
||||
ChangeLog log of changes to the code
|
||||
INSTALL generic installation instructions
|
||||
LICENCE conditions for the use of PCRE
|
||||
COPYING the same, using GNU's standard name
|
||||
Makefile.in template for Unix Makefile, which is built by configure
|
||||
NEWS important changes in this release
|
||||
NON-UNIX-USE notes on building PCRE on non-Unix systems
|
||||
README this file
|
||||
RunTest.in template for a Unix shell script for running tests
|
||||
config.guess ) files used by libtool,
|
||||
config.sub ) used only when building a shared library
|
||||
configure a configuring shell script (built by autoconf)
|
||||
configure.in the autoconf input used to build configure
|
||||
doc/Tech.Notes notes on the encoding
|
||||
doc/*.3 man page sources for the PCRE functions
|
||||
doc/*.1 man page sources for pcregrep and pcretest
|
||||
doc/html/* HTML documentation
|
||||
doc/pcre.txt plain text version of the man pages
|
||||
doc/pcretest.txt plain text documentation of test program
|
||||
doc/perltest.txt plain text documentation of Perl test program
|
||||
install-sh a shell script for installing files
|
||||
libpcre.pc.in "source" for libpcre.pc for pkg-config
|
||||
ltmain.sh file used to build a libtool script
|
||||
mkinstalldirs script for making install directories
|
||||
pcretest.c comprehensive test program
|
||||
pcredemo.c simple demonstration of coding calls to PCRE
|
||||
perltest Perl test program
|
||||
pcregrep.c source of a grep utility that uses PCRE
|
||||
pcre-config.in source of script which retains PCRE information
|
||||
testdata/testinput1 test data, compatible with Perl
|
||||
testdata/testinput2 test data for error messages and non-Perl things
|
||||
testdata/testinput3 test data for locale-specific tests
|
||||
testdata/testinput4 test data for UTF-8 tests compatible with Perl
|
||||
testdata/testinput5 test data for other UTF-8 tests
|
||||
testdata/testinput6 test data for Unicode property support tests
|
||||
testdata/testoutput1 test results corresponding to testinput1
|
||||
testdata/testoutput2 test results corresponding to testinput2
|
||||
testdata/testoutput3 test results corresponding to testinput3
|
||||
testdata/testoutput4 test results corresponding to testinput4
|
||||
testdata/testoutput5 test results corresponding to testinput5
|
||||
testdata/testoutput6 test results corresponding to testinput6
|
||||
|
||||
(C) Auxiliary files for Win32 DLL
|
||||
|
||||
dll.mk
|
||||
libpcre.def
|
||||
libpcreposix.def
|
||||
pcre.def
|
||||
|
||||
(D) Auxiliary file for VPASCAL
|
||||
|
||||
makevp.bat
|
||||
|
||||
Philip Hazel <[email protected]>
|
||||
September 2004
|
||||
Vendored
+192
@@ -0,0 +1,192 @@
|
||||
#! /bin/sh
|
||||
|
||||
# This file is generated by configure from RunTest.in. Make any changes
|
||||
# to that file.
|
||||
|
||||
# Run PCRE tests
|
||||
|
||||
cf=diff
|
||||
testdata=@top_srcdir@/testdata
|
||||
|
||||
# Select which tests to run; if no selection, run all
|
||||
|
||||
do1=no
|
||||
do2=no
|
||||
do3=no
|
||||
do4=no
|
||||
do5=no
|
||||
do6=no
|
||||
|
||||
while [ $# -gt 0 ] ; do
|
||||
case $1 in
|
||||
1) do1=yes;;
|
||||
2) do2=yes;;
|
||||
3) do3=yes;;
|
||||
4) do4=yes;;
|
||||
5) do5=yes;;
|
||||
6) do6=yes;;
|
||||
*) echo "Unknown test number $1"; exit 1;;
|
||||
esac
|
||||
shift
|
||||
done
|
||||
|
||||
if [ "@LINK_SIZE@" != "" -a "@LINK_SIZE@" != "-DLINK_SIZE=2" ] ; then
|
||||
if [ $do2 = yes ] ; then
|
||||
echo "Can't run test 2 with an internal link size other than 2"
|
||||
exit 1
|
||||
fi
|
||||
if [ $do5 = yes ] ; then
|
||||
echo "Can't run test 5 with an internal link size other than 2"
|
||||
exit 1
|
||||
fi
|
||||
if [ $do6 = yes ] ; then
|
||||
echo "Can't run test 6 with an internal link size other than 2"
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ "@UTF8@" = "" ] ; then
|
||||
if [ $do4 = yes ] ; then
|
||||
echo "Can't run test 4 because UTF-8 support is not configured"
|
||||
exit 1
|
||||
fi
|
||||
if [ $do5 = yes ] ; then
|
||||
echo "Can't run test 5 because UTF-8 support is not configured"
|
||||
exit 1
|
||||
fi
|
||||
if [ $do6 = yes ] ; then
|
||||
echo "Can't run test 6 because UTF-8 support is not configured"
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ "@UCP@" = "" ] ; then
|
||||
if [ $do6 = yes ] ; then
|
||||
echo "Can't run test 6 because Unicode property support is not configured"
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ $do1 = no -a $do2 = no -a $do3 = no -a $do4 = no -a \
|
||||
$do5 = no -a $do6 = no ] ; then
|
||||
do1=yes
|
||||
do2=yes
|
||||
do3=yes
|
||||
if [ "@UTF8@" != "" ] ; then do4=yes; fi
|
||||
if [ "@UTF8@" != "" ] ; then do5=yes; fi
|
||||
if [ "@UTF8@" != "" -a "@UCP@" != "" ] ; then do6=yes; fi
|
||||
fi
|
||||
|
||||
# Show which release
|
||||
|
||||
./pcretest /dev/null
|
||||
|
||||
# Primary test, Perl-compatible
|
||||
|
||||
if [ $do1 = yes ] ; then
|
||||
echo "Test 1: main functionality (Perl compatible)"
|
||||
./pcretest $testdata/testinput1 testtry
|
||||
if [ $? = 0 ] ; then
|
||||
$cf testtry $testdata/testoutput1
|
||||
if [ $? != 0 ] ; then exit 1; fi
|
||||
echo " "
|
||||
else exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
# PCRE tests that are not Perl-compatible - API & error tests, mostly
|
||||
|
||||
if [ $do2 = yes ] ; then
|
||||
if [ "@LINK_SIZE@" = "" -o "@LINK_SIZE@" = "-DLINK_SIZE=2" ] ; then
|
||||
echo "Test 2: API and error handling (not Perl compatible)"
|
||||
./pcretest -i $testdata/testinput2 testtry
|
||||
if [ $? = 0 ] ; then
|
||||
$cf testtry $testdata/testoutput2
|
||||
if [ $? != 0 ] ; then exit 1; fi
|
||||
else exit 1
|
||||
fi
|
||||
else
|
||||
echo Test 2 skipped for link size other than 2 \(@LINK_SIZE@\)
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ $do1 = yes -a $do2 = yes ] ; then
|
||||
echo " "
|
||||
echo "The two main tests ran OK"
|
||||
echo " "
|
||||
fi
|
||||
|
||||
# Locale-specific tests, provided the "fr_FR" locale is available
|
||||
|
||||
if [ $do3 = yes ] ; then
|
||||
locale -a | grep '^fr_FR$' >/dev/null
|
||||
if [ $? -eq 0 ] ; then
|
||||
echo "Test 3: locale-specific features (using 'fr_FR' locale)"
|
||||
./pcretest $testdata/testinput3 testtry
|
||||
if [ $? = 0 ] ; then
|
||||
$cf testtry $testdata/testoutput3
|
||||
if [ $? != 0 ] ; then
|
||||
echo " "
|
||||
echo "Locale test did not run entirely successfully."
|
||||
echo "This usually means that there is a problem with the locale"
|
||||
echo "settings rather than a bug in PCRE."
|
||||
else
|
||||
echo "Locale test ran OK"
|
||||
fi
|
||||
echo " "
|
||||
else exit 1
|
||||
fi
|
||||
else
|
||||
echo "Cannot test locale-specific features - 'fr_FR' locale not found,"
|
||||
echo "or the \"locale\" command is not available to check for it."
|
||||
echo " "
|
||||
fi
|
||||
fi
|
||||
|
||||
# Additional tests for UTF8 support
|
||||
|
||||
if [ $do4 = yes ] ; then
|
||||
echo "Test 4: UTF-8 support (Perl compatible)"
|
||||
./pcretest $testdata/testinput4 testtry
|
||||
if [ $? = 0 ] ; then
|
||||
$cf testtry $testdata/testoutput4
|
||||
if [ $? != 0 ] ; then exit 1; fi
|
||||
else exit 1
|
||||
fi
|
||||
echo "UTF8 test ran OK"
|
||||
echo " "
|
||||
fi
|
||||
|
||||
if [ $do5 = yes ] ; then
|
||||
if [ "@LINK_SIZE@" = "" -o "@LINK_SIZE@" = "-DLINK_SIZE=2" ] ; then
|
||||
echo "Test 5: API and internals for UTF-8 support (not Perl compatible)"
|
||||
./pcretest $testdata/testinput5 testtry
|
||||
if [ $? = 0 ] ; then
|
||||
$cf testtry $testdata/testoutput5
|
||||
if [ $? != 0 ] ; then exit 1; fi
|
||||
else exit 1
|
||||
fi
|
||||
echo "UTF8 internals test ran OK"
|
||||
echo " "
|
||||
else
|
||||
echo Test 5 skipped for link size other than 2 \(@LINK_SIZE@\)
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ $do6 = yes ] ; then
|
||||
if [ "@LINK_SIZE@" = "" -o "@LINK_SIZE@" = "-DLINK_SIZE=2" ] ; then
|
||||
echo "Test 6: Unicode property support"
|
||||
./pcretest $testdata/testinput6 testtry
|
||||
if [ $? = 0 ] ; then
|
||||
$cf testtry $testdata/testoutput6
|
||||
if [ $? != 0 ] ; then exit 1; fi
|
||||
else exit 1
|
||||
fi
|
||||
echo "Unicode properties test ran OK"
|
||||
echo " "
|
||||
else
|
||||
echo Test 6 skipped for link size other than 2 \(@LINK_SIZE@\)
|
||||
fi
|
||||
fi
|
||||
|
||||
# End
|
||||
Vendored
+189
@@ -0,0 +1,189 @@
|
||||
/*************************************************
|
||||
* Perl-Compatible Regular Expressions *
|
||||
*************************************************/
|
||||
|
||||
/* Not generated here: extracted from Wow.exe 3.3.5a (12340), pcre_default_tables
|
||||
at 0x00B0BD48 (1088 bytes, used by pcre_compile 0x008418F0 and pcre_exec
|
||||
0x00847610). The stock PCRE 5.0 build writes this file with dftables, whose
|
||||
output depends on the build machine's C library. The 12340 tables have ASCII
|
||||
case maps (lower casing and case flipping change only A-Z/a-z) but ISO-8859-1
|
||||
character classes for 0x80-0xFF (0xA0 space, 0xC0-0xFF letters/word except
|
||||
0xD7/0xDE/0xF7, 0x80-0x9F cntrl). A Windows C-locale dftables run gives ASCII-only
|
||||
classes; this combination looks like a dftables run on Mac OS X. The address is
|
||||
listed in re/data/thirdparty_data.tsv so the bytes can be re-checked.
|
||||
|
||||
This file is #included in the compilation of pcre.c to build the default
|
||||
character tables which are used when no tables are passed to the compile
|
||||
function. */
|
||||
|
||||
static unsigned char pcre_default_tables[] = {
|
||||
|
||||
/* This table is a lower casing table. */
|
||||
|
||||
0, 1, 2, 3, 4, 5, 6, 7,
|
||||
8, 9, 10, 11, 12, 13, 14, 15,
|
||||
16, 17, 18, 19, 20, 21, 22, 23,
|
||||
24, 25, 26, 27, 28, 29, 30, 31,
|
||||
32, 33, 34, 35, 36, 37, 38, 39,
|
||||
40, 41, 42, 43, 44, 45, 46, 47,
|
||||
48, 49, 50, 51, 52, 53, 54, 55,
|
||||
56, 57, 58, 59, 60, 61, 62, 63,
|
||||
64, 97, 98, 99,100,101,102,103,
|
||||
104,105,106,107,108,109,110,111,
|
||||
112,113,114,115,116,117,118,119,
|
||||
120,121,122, 91, 92, 93, 94, 95,
|
||||
96, 97, 98, 99,100,101,102,103,
|
||||
104,105,106,107,108,109,110,111,
|
||||
112,113,114,115,116,117,118,119,
|
||||
120,121,122,123,124,125,126,127,
|
||||
128,129,130,131,132,133,134,135,
|
||||
136,137,138,139,140,141,142,143,
|
||||
144,145,146,147,148,149,150,151,
|
||||
152,153,154,155,156,157,158,159,
|
||||
160,161,162,163,164,165,166,167,
|
||||
168,169,170,171,172,173,174,175,
|
||||
176,177,178,179,180,181,182,183,
|
||||
184,185,186,187,188,189,190,191,
|
||||
192,193,194,195,196,197,198,199,
|
||||
200,201,202,203,204,205,206,207,
|
||||
208,209,210,211,212,213,214,215,
|
||||
216,217,218,219,220,221,222,223,
|
||||
224,225,226,227,228,229,230,231,
|
||||
232,233,234,235,236,237,238,239,
|
||||
240,241,242,243,244,245,246,247,
|
||||
248,249,250,251,252,253,254,255,
|
||||
|
||||
/* This table is a case flipping table. */
|
||||
|
||||
0, 1, 2, 3, 4, 5, 6, 7,
|
||||
8, 9, 10, 11, 12, 13, 14, 15,
|
||||
16, 17, 18, 19, 20, 21, 22, 23,
|
||||
24, 25, 26, 27, 28, 29, 30, 31,
|
||||
32, 33, 34, 35, 36, 37, 38, 39,
|
||||
40, 41, 42, 43, 44, 45, 46, 47,
|
||||
48, 49, 50, 51, 52, 53, 54, 55,
|
||||
56, 57, 58, 59, 60, 61, 62, 63,
|
||||
64, 97, 98, 99,100,101,102,103,
|
||||
104,105,106,107,108,109,110,111,
|
||||
112,113,114,115,116,117,118,119,
|
||||
120,121,122, 91, 92, 93, 94, 95,
|
||||
96, 65, 66, 67, 68, 69, 70, 71,
|
||||
72, 73, 74, 75, 76, 77, 78, 79,
|
||||
80, 81, 82, 83, 84, 85, 86, 87,
|
||||
88, 89, 90,123,124,125,126,127,
|
||||
128,129,130,131,132,133,134,135,
|
||||
136,137,138,139,140,141,142,143,
|
||||
144,145,146,147,148,149,150,151,
|
||||
152,153,154,155,156,157,158,159,
|
||||
160,161,162,163,164,165,166,167,
|
||||
168,169,170,171,172,173,174,175,
|
||||
176,177,178,179,180,181,182,183,
|
||||
184,185,186,187,188,189,190,191,
|
||||
192,193,194,195,196,197,198,199,
|
||||
200,201,202,203,204,205,206,207,
|
||||
208,209,210,211,212,213,214,215,
|
||||
216,217,218,219,220,221,222,223,
|
||||
224,225,226,227,228,229,230,231,
|
||||
232,233,234,235,236,237,238,239,
|
||||
240,241,242,243,244,245,246,247,
|
||||
248,249,250,251,252,253,254,255,
|
||||
|
||||
/* This table contains bit maps for various character classes.
|
||||
Each map is 32 bytes long and the bits run from the least
|
||||
significant end of each byte. The classes that have their own
|
||||
maps are: space, xdigit, digit, upper, lower, word, graph
|
||||
print, punct, and cntrl. Other classes are built from combinations. */
|
||||
|
||||
0x00,0x3e,0x00,0x00,0x01,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
|
||||
0x7e,0x00,0x00,0x00,0x7e,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0xfe,0xff,0xff,0x07,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0xff,0xff,0x7f,0xbf,0x00,0x00,0x00,0x00,
|
||||
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0x07,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0xff,0xff,0x7f,0xff,
|
||||
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
|
||||
0xfe,0xff,0xff,0x87,0xfe,0xff,0xff,0x07,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0xff,0xff,0x7f,0xbf,0xff,0xff,0x7f,0xff,
|
||||
|
||||
0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0xff,
|
||||
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f,
|
||||
0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0xff,
|
||||
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
|
||||
|
||||
0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff,
|
||||
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f,
|
||||
0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff,
|
||||
0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
|
||||
|
||||
0x00,0x00,0x00,0x00,0xfe,0xff,0x00,0xfc,
|
||||
0x01,0x00,0x00,0xf8,0x01,0x00,0x00,0x78,
|
||||
0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0xff,
|
||||
0x00,0x00,0x80,0x40,0x00,0x00,0x80,0x00,
|
||||
|
||||
0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,
|
||||
0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
|
||||
/* This table identifies various classes of character by individual bits:
|
||||
0x01 white space character
|
||||
0x02 letter
|
||||
0x04 decimal digit
|
||||
0x08 hexadecimal digit
|
||||
0x10 alphanumeric or '_'
|
||||
0x80 regular expression metacharacter or binary zero
|
||||
*/
|
||||
|
||||
0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x01,0x01,0x00,0x01,0x01,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x01,0x00,0x00,0x00,0x80,0x00,0x00,0x00,
|
||||
0x80,0x80,0x80,0x80,0x00,0x00,0x80,0x00,
|
||||
0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,
|
||||
0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x80,
|
||||
0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12,
|
||||
0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
|
||||
0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
|
||||
0x12,0x12,0x12,0x80,0x00,0x00,0x80,0x10,
|
||||
0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12,
|
||||
0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
|
||||
0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
|
||||
0x12,0x12,0x12,0x80,0x80,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x12,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x12,0x00,0x00,
|
||||
0x00,0x00,0x12,0x00,0x00,0x00,0x00,0x00,
|
||||
0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
|
||||
0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
|
||||
0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x00,
|
||||
0x12,0x12,0x12,0x12,0x12,0x12,0x00,0x12,
|
||||
0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
|
||||
0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
|
||||
0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x00,
|
||||
0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12};
|
||||
|
||||
/* End of chartables.c */
|
||||
Vendored
+1449
File diff suppressed because it is too large
Load Diff
Vendored
+107
@@ -0,0 +1,107 @@
|
||||
|
||||
/* On Unix systems config.in is converted by configure into config.h. PCRE is
|
||||
written in Standard C, but there are a few non-standard things it can cope
|
||||
with, allowing it to run on SunOS4 and other "close to standard" systems.
|
||||
|
||||
On a non-Unix system you should just copy this file into config.h, and set up
|
||||
the macros the way you need them. You should normally change the definitions of
|
||||
HAVE_STRERROR and HAVE_MEMMOVE to 1. Unfortunately, because of the way autoconf
|
||||
works, these cannot be made the defaults. If your system has bcopy() and not
|
||||
memmove(), change the definition of HAVE_BCOPY instead of HAVE_MEMMOVE. If your
|
||||
system has neither bcopy() nor memmove(), leave them both as 0; an emulation
|
||||
function will be used. */
|
||||
|
||||
/* If you are compiling for a system that uses EBCDIC instead of ASCII
|
||||
character codes, define this macro as 1. On systems that can use "configure",
|
||||
this can be done via --enable-ebcdic. */
|
||||
|
||||
#ifndef EBCDIC
|
||||
#define EBCDIC 0
|
||||
#endif
|
||||
|
||||
/* If you are compiling for a system that needs some magic to be inserted
|
||||
before the definition of an exported function, define this macro to contain the
|
||||
relevant magic. It apears at the start of every exported function. */
|
||||
|
||||
#define EXPORT
|
||||
|
||||
/* Define to empty if the "const" keyword does not work. */
|
||||
|
||||
#undef const
|
||||
|
||||
/* Define to "unsigned" if <stddef.h> doesn't define size_t. */
|
||||
|
||||
#undef size_t
|
||||
|
||||
/* The following two definitions are mainly for the benefit of SunOS4, which
|
||||
doesn't have the strerror() or memmove() functions that should be present in
|
||||
all Standard C libraries. The macros HAVE_STRERROR and HAVE_MEMMOVE should
|
||||
normally be defined with the value 1 for other systems, but unfortunately we
|
||||
can't make this the default because "configure" files generated by autoconf
|
||||
will only change 0 to 1; they won't change 1 to 0 if the functions are not
|
||||
found. */
|
||||
|
||||
#define HAVE_STRERROR 1
|
||||
#define HAVE_MEMMOVE 1
|
||||
|
||||
/* There are some non-Unix systems that don't even have bcopy(). If this macro
|
||||
is false, an emulation is used. If HAVE_MEMMOVE is set to 1, the value of
|
||||
HAVE_BCOPY is not relevant. */
|
||||
|
||||
#define HAVE_BCOPY 0
|
||||
|
||||
/* The value of NEWLINE determines the newline character. The default is to
|
||||
leave it up to the compiler, but some sites want to force a particular value.
|
||||
On Unix systems, "configure" can be used to override this default. */
|
||||
|
||||
#ifndef NEWLINE
|
||||
#define NEWLINE '\n'
|
||||
#endif
|
||||
|
||||
/* The value of LINK_SIZE determines the number of bytes used to store
|
||||
links as offsets within the compiled regex. The default is 2, which allows for
|
||||
compiled patterns up to 64K long. This covers the vast majority of cases.
|
||||
However, PCRE can also be compiled to use 3 or 4 bytes instead. This allows for
|
||||
longer patterns in extreme cases. On Unix systems, "configure" can be used to
|
||||
override this default. */
|
||||
|
||||
#ifndef LINK_SIZE
|
||||
#define LINK_SIZE 2
|
||||
#endif
|
||||
|
||||
/* The value of MATCH_LIMIT determines the default number of times the match()
|
||||
function can be called during a single execution of pcre_exec(). (There is a
|
||||
runtime method of setting a different limit.) The limit exists in order to
|
||||
catch runaway regular expressions that take for ever to determine that they do
|
||||
not match. The default is set very large so that it does not accidentally catch
|
||||
legitimate cases. On Unix systems, "configure" can be used to override this
|
||||
default default. */
|
||||
|
||||
#ifndef MATCH_LIMIT
|
||||
#define MATCH_LIMIT 10000000
|
||||
#endif
|
||||
|
||||
/* When calling PCRE via the POSIX interface, additional working storage is
|
||||
required for holding the pointers to capturing substrings because PCRE requires
|
||||
three integers per substring, whereas the POSIX interface provides only two. If
|
||||
the number of expected substrings is small, the wrapper function uses space on
|
||||
the stack, because this is faster than using malloc() for each call. The
|
||||
threshold above which the stack is no longer use is defined by POSIX_MALLOC_
|
||||
THRESHOLD. On Unix systems, "configure" can be used to override this default.
|
||||
*/
|
||||
|
||||
#ifndef POSIX_MALLOC_THRESHOLD
|
||||
#define POSIX_MALLOC_THRESHOLD 10
|
||||
#endif
|
||||
|
||||
/* PCRE uses recursive function calls to handle backtracking while matching.
|
||||
This can sometimes be a problem on systems that have stacks of limited size.
|
||||
Define NO_RECURSE to get a version that doesn't use recursion in the match()
|
||||
function; instead it creates its own stack by steam using pcre_recurse_malloc
|
||||
to get memory. For more detail, see comments and other stuff just above the
|
||||
match() function. On Unix systems, "configure" can be used to set this in the
|
||||
Makefile (use --disable-stack-for-recursion). */
|
||||
|
||||
/* #define NO_RECURSE */
|
||||
|
||||
/* End */
|
||||
Vendored
+107
@@ -0,0 +1,107 @@
|
||||
|
||||
/* On Unix systems config.in is converted by configure into config.h. PCRE is
|
||||
written in Standard C, but there are a few non-standard things it can cope
|
||||
with, allowing it to run on SunOS4 and other "close to standard" systems.
|
||||
|
||||
On a non-Unix system you should just copy this file into config.h, and set up
|
||||
the macros the way you need them. You should normally change the definitions of
|
||||
HAVE_STRERROR and HAVE_MEMMOVE to 1. Unfortunately, because of the way autoconf
|
||||
works, these cannot be made the defaults. If your system has bcopy() and not
|
||||
memmove(), change the definition of HAVE_BCOPY instead of HAVE_MEMMOVE. If your
|
||||
system has neither bcopy() nor memmove(), leave them both as 0; an emulation
|
||||
function will be used. */
|
||||
|
||||
/* If you are compiling for a system that uses EBCDIC instead of ASCII
|
||||
character codes, define this macro as 1. On systems that can use "configure",
|
||||
this can be done via --enable-ebcdic. */
|
||||
|
||||
#ifndef EBCDIC
|
||||
#define EBCDIC 0
|
||||
#endif
|
||||
|
||||
/* If you are compiling for a system that needs some magic to be inserted
|
||||
before the definition of an exported function, define this macro to contain the
|
||||
relevant magic. It apears at the start of every exported function. */
|
||||
|
||||
#define EXPORT
|
||||
|
||||
/* Define to empty if the "const" keyword does not work. */
|
||||
|
||||
#undef const
|
||||
|
||||
/* Define to "unsigned" if <stddef.h> doesn't define size_t. */
|
||||
|
||||
#undef size_t
|
||||
|
||||
/* The following two definitions are mainly for the benefit of SunOS4, which
|
||||
doesn't have the strerror() or memmove() functions that should be present in
|
||||
all Standard C libraries. The macros HAVE_STRERROR and HAVE_MEMMOVE should
|
||||
normally be defined with the value 1 for other systems, but unfortunately we
|
||||
can't make this the default because "configure" files generated by autoconf
|
||||
will only change 0 to 1; they won't change 1 to 0 if the functions are not
|
||||
found. */
|
||||
|
||||
#define HAVE_STRERROR 0
|
||||
#define HAVE_MEMMOVE 0
|
||||
|
||||
/* There are some non-Unix systems that don't even have bcopy(). If this macro
|
||||
is false, an emulation is used. If HAVE_MEMMOVE is set to 1, the value of
|
||||
HAVE_BCOPY is not relevant. */
|
||||
|
||||
#define HAVE_BCOPY 0
|
||||
|
||||
/* The value of NEWLINE determines the newline character. The default is to
|
||||
leave it up to the compiler, but some sites want to force a particular value.
|
||||
On Unix systems, "configure" can be used to override this default. */
|
||||
|
||||
#ifndef NEWLINE
|
||||
#define NEWLINE '\n'
|
||||
#endif
|
||||
|
||||
/* The value of LINK_SIZE determines the number of bytes used to store
|
||||
links as offsets within the compiled regex. The default is 2, which allows for
|
||||
compiled patterns up to 64K long. This covers the vast majority of cases.
|
||||
However, PCRE can also be compiled to use 3 or 4 bytes instead. This allows for
|
||||
longer patterns in extreme cases. On Unix systems, "configure" can be used to
|
||||
override this default. */
|
||||
|
||||
#ifndef LINK_SIZE
|
||||
#define LINK_SIZE 2
|
||||
#endif
|
||||
|
||||
/* The value of MATCH_LIMIT determines the default number of times the match()
|
||||
function can be called during a single execution of pcre_exec(). (There is a
|
||||
runtime method of setting a different limit.) The limit exists in order to
|
||||
catch runaway regular expressions that take for ever to determine that they do
|
||||
not match. The default is set very large so that it does not accidentally catch
|
||||
legitimate cases. On Unix systems, "configure" can be used to override this
|
||||
default default. */
|
||||
|
||||
#ifndef MATCH_LIMIT
|
||||
#define MATCH_LIMIT 10000000
|
||||
#endif
|
||||
|
||||
/* When calling PCRE via the POSIX interface, additional working storage is
|
||||
required for holding the pointers to capturing substrings because PCRE requires
|
||||
three integers per substring, whereas the POSIX interface provides only two. If
|
||||
the number of expected substrings is small, the wrapper function uses space on
|
||||
the stack, because this is faster than using malloc() for each call. The
|
||||
threshold above which the stack is no longer use is defined by POSIX_MALLOC_
|
||||
THRESHOLD. On Unix systems, "configure" can be used to override this default.
|
||||
*/
|
||||
|
||||
#ifndef POSIX_MALLOC_THRESHOLD
|
||||
#define POSIX_MALLOC_THRESHOLD 10
|
||||
#endif
|
||||
|
||||
/* PCRE uses recursive function calls to handle backtracking while matching.
|
||||
This can sometimes be a problem on systems that have stacks of limited size.
|
||||
Define NO_RECURSE to get a version that doesn't use recursion in the match()
|
||||
function; instead it creates its own stack by steam using pcre_recurse_malloc
|
||||
to get memory. For more detail, see comments and other stuff just above the
|
||||
match() function. On Unix systems, "configure" can be used to set this in the
|
||||
Makefile (use --disable-stack-for-recursion). */
|
||||
|
||||
/* #define NO_RECURSE */
|
||||
|
||||
/* End */
|
||||
Vendored
+1552
File diff suppressed because it is too large
Load Diff
Vendored
+20829
File diff suppressed because it is too large
Load Diff
Vendored
+226
@@ -0,0 +1,226 @@
|
||||
dnl Process this file with autoconf to produce a configure script.
|
||||
|
||||
dnl This is required at the start; the name is the name of a file
|
||||
dnl it should be seeing, to verify it is in the same directory.
|
||||
|
||||
AC_INIT(dftables.c)
|
||||
|
||||
dnl A safety precaution
|
||||
|
||||
AC_PREREQ(2.57)
|
||||
|
||||
dnl Arrange to build config.h from config.in. Note that pcre.h is
|
||||
dnl built differently, as it is just a "substitution" file.
|
||||
dnl Manual says this macro should come right after AC_INIT.
|
||||
AC_CONFIG_HEADER(config.h:config.in)
|
||||
|
||||
dnl Provide the current PCRE version information. Do not use numbers
|
||||
dnl with leading zeros for the minor version, as they end up in a C
|
||||
dnl macro, and may be treated as octal constants. Stick to single
|
||||
dnl digits for minor numbers less than 10. There are unlikely to be
|
||||
dnl that many releases anyway.
|
||||
|
||||
PCRE_MAJOR=5
|
||||
PCRE_MINOR=0
|
||||
PCRE_DATE=13-Sep-2004
|
||||
PCRE_VERSION=${PCRE_MAJOR}.${PCRE_MINOR}
|
||||
|
||||
dnl Default values for miscellaneous macros
|
||||
|
||||
POSIX_MALLOC_THRESHOLD=-DPOSIX_MALLOC_THRESHOLD=10
|
||||
|
||||
dnl Provide versioning information for libtool shared libraries that
|
||||
dnl are built by default on Unix systems.
|
||||
|
||||
PCRE_LIB_VERSION=0:1:0
|
||||
PCRE_POSIXLIB_VERSION=0:0:0
|
||||
|
||||
dnl Checks for programs.
|
||||
|
||||
AC_PROG_CC
|
||||
|
||||
dnl The icc compiler has the same options as gcc, so let the rest of the
|
||||
dnl configure script think it has gcc when setting up dnl options etc.
|
||||
dnl This is a nasty hack which no longer seems necessary with the update
|
||||
dnl to the latest libtool files, so I have commented it out.
|
||||
dnl
|
||||
dnl if test "$CC" = "icc" ; then GCC=yes ; fi
|
||||
|
||||
AC_PROG_INSTALL
|
||||
AC_LIBTOOL_WIN32_DLL
|
||||
AC_PROG_LIBTOOL
|
||||
|
||||
dnl We need to find a compiler for compiling a program to run on the local host
|
||||
dnl while building. It needs to be different from CC when cross-compiling.
|
||||
dnl There is a macro called AC_PROG_CC_FOR_BUILD in the GNU archive for
|
||||
dnl figuring this out automatically. Unfortunately, it does not work with the
|
||||
dnl latest versions of autoconf. So for the moment, we just default to the
|
||||
dnl same values as the "main" compiler. People who are corss-compiling will
|
||||
dnl just have to adjust the Makefile by hand or set these values when they
|
||||
dnl run "configure".
|
||||
|
||||
CC_FOR_BUILD=${CC_FOR_BUILD:-'$(CC)'}
|
||||
CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD:-'$(CFLAGS)'}
|
||||
BUILD_EXEEXT=${BUILD_EXEEXT:-'$(EXEEXT)'}
|
||||
BUILD_OBJEXT=${BUILD_OBJEXT:-'$(OBJEXT)'}
|
||||
|
||||
dnl Checks for header files.
|
||||
|
||||
AC_HEADER_STDC
|
||||
AC_CHECK_HEADERS(limits.h)
|
||||
|
||||
dnl Checks for typedefs, structures, and compiler characteristics.
|
||||
|
||||
AC_C_CONST
|
||||
AC_TYPE_SIZE_T
|
||||
|
||||
dnl Checks for library functions.
|
||||
|
||||
AC_CHECK_FUNCS(bcopy memmove strerror)
|
||||
|
||||
dnl Handle --enable-utf8
|
||||
|
||||
AC_ARG_ENABLE(utf8,
|
||||
[ --enable-utf8 enable UTF8 support],
|
||||
if test "$enableval" = "yes"; then
|
||||
UTF8=-DSUPPORT_UTF8
|
||||
fi
|
||||
)
|
||||
|
||||
dnl Handle --enable-unicode-properties
|
||||
|
||||
AC_ARG_ENABLE(unicode-properties,
|
||||
[ --enable-unicode-properties enable Unicode properties support],
|
||||
if test "$enableval" = "yes"; then
|
||||
UCP=-DSUPPORT_UCP
|
||||
fi
|
||||
)
|
||||
|
||||
dnl Handle --enable-newline-is-cr
|
||||
|
||||
AC_ARG_ENABLE(newline-is-cr,
|
||||
[ --enable-newline-is-cr use CR as the newline character],
|
||||
if test "$enableval" = "yes"; then
|
||||
NEWLINE=-DNEWLINE=13
|
||||
fi
|
||||
)
|
||||
|
||||
dnl Handle --enable-newline-is-lf
|
||||
|
||||
AC_ARG_ENABLE(newline-is-lf,
|
||||
[ --enable-newline-is-lf use LF as the newline character],
|
||||
if test "$enableval" = "yes"; then
|
||||
NEWLINE=-DNEWLINE=10
|
||||
fi
|
||||
)
|
||||
|
||||
dnl Handle --enable-ebcdic
|
||||
|
||||
AC_ARG_ENABLE(ebcdic,
|
||||
[ --enable-ebcdic assume EBCDIC coding rather than ASCII],
|
||||
if test "$enableval" == "yes"; then
|
||||
EBCDIC=-DEBCDIC=1
|
||||
fi
|
||||
)
|
||||
|
||||
dnl Handle --disable-stack-for-recursion
|
||||
|
||||
AC_ARG_ENABLE(stack-for-recursion,
|
||||
[ --disable-stack-for-recursion disable use of stack recursion when matching],
|
||||
if test "$enableval" = "no"; then
|
||||
NO_RECURSE=-DNO_RECURSE
|
||||
fi
|
||||
)
|
||||
|
||||
dnl There doesn't seem to be a straightforward way of having parameters
|
||||
dnl that set values, other than fudging the --with thing. So that's what
|
||||
dnl I've done.
|
||||
|
||||
dnl Handle --with-posix-malloc-threshold=n
|
||||
|
||||
AC_ARG_WITH(posix-malloc-threshold,
|
||||
[ --with-posix-malloc-threshold=5 threshold for POSIX malloc usage],
|
||||
POSIX_MALLOC_THRESHOLD=-DPOSIX_MALLOC_THRESHOLD=$withval
|
||||
)
|
||||
|
||||
dnl Handle --with-link-size=n
|
||||
|
||||
AC_ARG_WITH(link-size,
|
||||
[ --with-link-size=2 internal link size (2, 3, or 4 allowed)],
|
||||
LINK_SIZE=-DLINK_SIZE=$withval
|
||||
)
|
||||
|
||||
dnl Handle --with-match_limit=n
|
||||
|
||||
AC_ARG_WITH(match-limit,
|
||||
[ --with-match-limit=10000000 default limit on internal looping)],
|
||||
MATCH_LIMIT=-DMATCH_LIMIT=$withval
|
||||
)
|
||||
|
||||
dnl Now arrange to build libtool
|
||||
|
||||
AC_PROG_LIBTOOL
|
||||
|
||||
dnl Unicode character property support implies UTF-8 support
|
||||
|
||||
if test "$UCP" != "" ; then
|
||||
UTF8=-DSUPPORT_UTF8
|
||||
fi
|
||||
|
||||
dnl "Export" these variables
|
||||
|
||||
AC_SUBST(BUILD_EXEEXT)
|
||||
AC_SUBST(BUILD_OBJEXT)
|
||||
AC_SUBST(CC_FOR_BUILD)
|
||||
AC_SUBST(CFLAGS_FOR_BUILD)
|
||||
AC_SUBST(EBCDIC)
|
||||
AC_SUBST(HAVE_MEMMOVE)
|
||||
AC_SUBST(HAVE_STRERROR)
|
||||
AC_SUBST(LINK_SIZE)
|
||||
AC_SUBST(MATCH_LIMIT)
|
||||
AC_SUBST(NEWLINE)
|
||||
AC_SUBST(NO_RECURSE)
|
||||
AC_SUBST(PCRE_MAJOR)
|
||||
AC_SUBST(PCRE_MINOR)
|
||||
AC_SUBST(PCRE_DATE)
|
||||
AC_SUBST(PCRE_VERSION)
|
||||
AC_SUBST(PCRE_LIB_VERSION)
|
||||
AC_SUBST(PCRE_POSIXLIB_VERSION)
|
||||
AC_SUBST(POSIX_MALLOC_THRESHOLD)
|
||||
AC_SUBST(UCP)
|
||||
AC_SUBST(UTF8)
|
||||
|
||||
dnl Stuff to make MinGW work better. Special treatment is no longer
|
||||
dnl needed for Cygwin.
|
||||
|
||||
case $host_os in
|
||||
mingw* )
|
||||
POSIX_OBJ=pcreposix.o
|
||||
POSIX_LOBJ=pcreposix.lo
|
||||
POSIX_LIB=
|
||||
ON_WINDOWS=
|
||||
NOT_ON_WINDOWS="#"
|
||||
WIN_PREFIX=
|
||||
;;
|
||||
* )
|
||||
ON_WINDOWS="#"
|
||||
NOT_ON_WINDOWS=
|
||||
POSIX_OBJ=
|
||||
POSIX_LOBJ=
|
||||
POSIX_LIB=libpcreposix.la
|
||||
WIN_PREFIX=
|
||||
;;
|
||||
esac
|
||||
AC_SUBST(WIN_PREFIX)
|
||||
AC_SUBST(ON_WINDOWS)
|
||||
AC_SUBST(NOT_ON_WINDOWS)
|
||||
AC_SUBST(POSIX_OBJ)
|
||||
AC_SUBST(POSIX_LOBJ)
|
||||
AC_SUBST(POSIX_LIB)
|
||||
|
||||
if test "x$enable_shared" = "xno" ; then
|
||||
AC_DEFINE([PCRE_STATIC],[1],[to link statically])
|
||||
fi
|
||||
|
||||
dnl This must be last; it determines what files are written as well as config.h
|
||||
AC_OUTPUT(Makefile pcre.h:pcre.in pcre-config:pcre-config.in libpcre.pc:libpcre.pc.in RunTest:RunTest.in,[chmod a+x RunTest pcre-config])
|
||||
Vendored
+173
@@ -0,0 +1,173 @@
|
||||
/*************************************************
|
||||
* Perl-Compatible Regular Expressions *
|
||||
*************************************************/
|
||||
|
||||
/*
|
||||
PCRE is a library of functions to support regular expressions whose syntax
|
||||
and semantics are as close as possible to those of the Perl 5 language.
|
||||
|
||||
Written by: Philip Hazel <ph10@cam.ac.uk>
|
||||
|
||||
Copyright (c) 1997-2004 University of Cambridge
|
||||
|
||||
-----------------------------------------------------------------------------
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
* Neither the name of the University of Cambridge nor the names of its
|
||||
contributors may be used to endorse or promote products derived from
|
||||
this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGE.
|
||||
-----------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
|
||||
/* This is a support program to generate the file chartables.c, containing
|
||||
character tables of various kinds. They are built according to the default C
|
||||
locale and used as the default tables by PCRE. Now that pcre_maketables is
|
||||
a function visible to the outside world, we make use of its code from here in
|
||||
order to be consistent. */
|
||||
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "internal.h"
|
||||
|
||||
#define DFTABLES /* maketables.c notices this */
|
||||
#include "maketables.c"
|
||||
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int i;
|
||||
FILE *f;
|
||||
const unsigned char *tables = pcre_maketables();
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
/* 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 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;
|
||||
}
|
||||
|
||||
/* End of dftables.c */
|
||||
Vendored
+315
@@ -0,0 +1,315 @@
|
||||
Technical Notes about PCRE
|
||||
--------------------------
|
||||
|
||||
Historical note 1
|
||||
-----------------
|
||||
|
||||
Many years ago I implemented some regular expression functions to an algorithm
|
||||
suggested by Martin Richards. These were not Unix-like in form, and were quite
|
||||
restricted in what they could do by comparison with Perl. The interesting part
|
||||
about the algorithm was that the amount of space required to hold the compiled
|
||||
form of an expression was known in advance. The code to apply an expression did
|
||||
not operate by backtracking, as the original Henry Spencer code and current
|
||||
Perl code does, but instead checked all possibilities simultaneously by keeping
|
||||
a list of current states and checking all of them as it advanced through the
|
||||
subject string. In the terminology of Jeffrey Friedl's book, it was a "DFA
|
||||
algorithm". When the pattern was all used up, all remaining states were
|
||||
possible matches, and the one matching the longest subset of the subject string
|
||||
was chosen. This did not necessarily maximize the individual wild portions of
|
||||
the pattern, as is expected in Unix and Perl-style regular expressions.
|
||||
|
||||
Historical note 2
|
||||
-----------------
|
||||
|
||||
By contrast, the code originally written by Henry Spencer and subsequently
|
||||
heavily modified for Perl actually compiles the expression twice: once in a
|
||||
dummy mode in order to find out how much store will be needed, and then for
|
||||
real. The execution function operates by backtracking and maximizing (or,
|
||||
optionally, minimizing in Perl) the amount of the subject that matches
|
||||
individual wild portions of the pattern. This is an "NFA algorithm" in Friedl's
|
||||
terminology.
|
||||
|
||||
OK, here's the real stuff
|
||||
-------------------------
|
||||
|
||||
For the set of functions that forms PCRE (which are unrelated to those
|
||||
mentioned above), I tried at first to invent an algorithm that used an amount
|
||||
of store bounded by a multiple of the number of characters in the pattern, to
|
||||
save on compiling time. However, because of the greater complexity in Perl
|
||||
regular expressions, I couldn't do this. In any case, a first pass through the
|
||||
pattern is needed, for a number of reasons. PCRE works by running a very
|
||||
degenerate first pass to calculate a maximum store size, and then a second pass
|
||||
to do the real compile - which may use a bit less than the predicted amount of
|
||||
store. The idea is that this is going to turn out faster because the first pass
|
||||
is degenerate and the second pass can just store stuff straight into the
|
||||
vector. It does make the compiling functions bigger, of course, but they have
|
||||
got quite big anyway to handle all the Perl stuff.
|
||||
|
||||
The compiled form of a pattern is a vector of bytes, containing items of
|
||||
variable length. The first byte in an item is an opcode, and the length of the
|
||||
item is either implicit in the opcode or contained in the data bytes that
|
||||
follow it.
|
||||
|
||||
In many cases below "two-byte" data values are specified. This is in fact just
|
||||
a default. PCRE can be compiled to use 3-byte or 4-byte values (impairing the
|
||||
performance). This is necessary only when patterns whose compiled length is
|
||||
greater than 64K are going to be processed. In this description, we assume the
|
||||
"normal" compilation options.
|
||||
|
||||
A list of all the opcodes follows:
|
||||
|
||||
Opcodes with no following data
|
||||
------------------------------
|
||||
|
||||
These items are all just one byte long
|
||||
|
||||
OP_END end of pattern
|
||||
OP_ANY match any character
|
||||
OP_ANYBYTE match any single byte, even in UTF-8 mode
|
||||
OP_SOD match start of data: \A
|
||||
OP_SOM, start of match (subject + offset): \G
|
||||
OP_CIRC ^ (start of data, or after \n in multiline)
|
||||
OP_NOT_WORD_BOUNDARY \W
|
||||
OP_WORD_BOUNDARY \w
|
||||
OP_NOT_DIGIT \D
|
||||
OP_DIGIT \d
|
||||
OP_NOT_WHITESPACE \S
|
||||
OP_WHITESPACE \s
|
||||
OP_NOT_WORDCHAR \W
|
||||
OP_WORDCHAR \w
|
||||
OP_EODN match end of data or \n at end: \Z
|
||||
OP_EOD match end of data: \z
|
||||
OP_DOLL $ (end of data, or before \n in multiline)
|
||||
OP_EXTUNI match an extended Unicode character
|
||||
|
||||
|
||||
Repeating single characters
|
||||
---------------------------
|
||||
|
||||
The common repeats (*, +, ?) when applied to a single character use the
|
||||
following opcodes:
|
||||
|
||||
OP_STAR
|
||||
OP_MINSTAR
|
||||
OP_PLUS
|
||||
OP_MINPLUS
|
||||
OP_QUERY
|
||||
OP_MINQUERY
|
||||
|
||||
In ASCII mode, these are two-byte items; in UTF-8 mode, the length is variable.
|
||||
Those with "MIN" in their name are the minimizing versions. Each is followed by
|
||||
the character that is to be repeated. Other repeats make use of
|
||||
|
||||
OP_UPTO
|
||||
OP_MINUPTO
|
||||
OP_EXACT
|
||||
|
||||
which are followed by a two-byte count (most significant first) and the
|
||||
repeated character. OP_UPTO matches from 0 to the given number. A repeat with a
|
||||
non-zero minimum and a fixed maximum is coded as an OP_EXACT followed by an
|
||||
OP_UPTO (or OP_MINUPTO).
|
||||
|
||||
|
||||
Repeating character types
|
||||
-------------------------
|
||||
|
||||
Repeats of things like \d are done exactly as for single characters, except
|
||||
that instead of a character, the opcode for the type is stored in the data
|
||||
byte. The opcodes are:
|
||||
|
||||
OP_TYPESTAR
|
||||
OP_TYPEMINSTAR
|
||||
OP_TYPEPLUS
|
||||
OP_TYPEMINPLUS
|
||||
OP_TYPEQUERY
|
||||
OP_TYPEMINQUERY
|
||||
OP_TYPEUPTO
|
||||
OP_TYPEMINUPTO
|
||||
OP_TYPEEXACT
|
||||
|
||||
|
||||
Match by Unicode property
|
||||
-------------------------
|
||||
|
||||
OP_PROP and OP_NOTPROP are used for positive and negative matches of a
|
||||
character by testing its Unicode property (the \p and \P escape sequences).
|
||||
Each is followed by a single byte that encodes the desired property value.
|
||||
|
||||
Repeats of these items use the OP_TYPESTAR etc. set of opcodes, followed by two
|
||||
bytes: OP_PROP or OP_NOTPROP and then the desired property value.
|
||||
|
||||
|
||||
Matching literal characters
|
||||
---------------------------
|
||||
|
||||
The OP_CHAR opcode is followed by a single character that is to be matched
|
||||
casefully. For caseless matching, OP_CHARNC is used. In UTF-8 mode, the
|
||||
character may be more than one byte long. (Earlier versions of PCRE used
|
||||
multi-character strings, but this was changed to allow some new features to be
|
||||
added.)
|
||||
|
||||
|
||||
Character classes
|
||||
-----------------
|
||||
|
||||
If there is only one character, OP_CHAR or OP_CHARNC is used for a positive
|
||||
class, and OP_NOT for a negative one (that is, for something like [^a]).
|
||||
However, in UTF-8 mode, the use of OP_NOT applies only to characters with
|
||||
values < 128, because OP_NOT is confined to single bytes.
|
||||
|
||||
Another set of repeating opcodes (OP_NOTSTAR etc.) are used for a repeated,
|
||||
negated, single-character class. The normal ones (OP_STAR etc.) are used for a
|
||||
repeated positive single-character class.
|
||||
|
||||
When there's more than one character in a class and all the characters are less
|
||||
than 256, OP_CLASS is used for a positive class, and OP_NCLASS for a negative
|
||||
one. In either case, the opcode is followed by a 32-byte bit map containing a 1
|
||||
bit for every character that is acceptable. The bits are counted from the least
|
||||
significant end of each byte.
|
||||
|
||||
The reason for having both OP_CLASS and OP_NCLASS is so that, in UTF-8 mode,
|
||||
subject characters with values greater than 256 can be handled correctly. For
|
||||
OP_CLASS they don't match, whereas for OP_NCLASS they do.
|
||||
|
||||
For classes containing characters with values > 255, OP_XCLASS is used. It
|
||||
optionally uses a bit map (if any characters lie within it), followed by a list
|
||||
of pairs and single characters. There is a flag character than indicates
|
||||
whether it's a positive or a negative class.
|
||||
|
||||
|
||||
Back references
|
||||
---------------
|
||||
|
||||
OP_REF is followed by two bytes containing the reference number.
|
||||
|
||||
|
||||
Repeating character classes and back references
|
||||
-----------------------------------------------
|
||||
|
||||
Single-character classes are handled specially (see above). This applies to
|
||||
OP_CLASS and OP_REF. In both cases, the repeat information follows the base
|
||||
item. The matching code looks at the following opcode to see if it is one of
|
||||
|
||||
OP_CRSTAR
|
||||
OP_CRMINSTAR
|
||||
OP_CRPLUS
|
||||
OP_CRMINPLUS
|
||||
OP_CRQUERY
|
||||
OP_CRMINQUERY
|
||||
OP_CRRANGE
|
||||
OP_CRMINRANGE
|
||||
|
||||
All but the last two are just single-byte items. The others are followed by
|
||||
four bytes of data, comprising the minimum and maximum repeat counts.
|
||||
|
||||
|
||||
Brackets and alternation
|
||||
------------------------
|
||||
|
||||
A pair of non-capturing (round) brackets is wrapped round each expression at
|
||||
compile time, so alternation always happens in the context of brackets.
|
||||
|
||||
Non-capturing brackets use the opcode OP_BRA, while capturing brackets use
|
||||
OP_BRA+1, OP_BRA+2, etc. [Note for North Americans: "bracket" to some English
|
||||
speakers, including myself, can be round, square, curly, or pointy. Hence this
|
||||
usage.]
|
||||
|
||||
Originally PCRE was limited to 99 capturing brackets (so as not to use up all
|
||||
the opcodes). From release 3.5, there is no limit. What happens is that the
|
||||
first ones, up to EXTRACT_BASIC_MAX are handled with separate opcodes, as
|
||||
above. If there are more, the opcode is set to EXTRACT_BASIC_MAX+1, and the
|
||||
first operation in the bracket is OP_BRANUMBER, followed by a 2-byte bracket
|
||||
number. This opcode is ignored while matching, but is fished out when handling
|
||||
the bracket itself. (They could have all been done like this, but I was making
|
||||
minimal changes.)
|
||||
|
||||
A bracket opcode is followed by two bytes which give the offset to the next
|
||||
alternative OP_ALT or, if there aren't any branches, to the matching OP_KET
|
||||
opcode. Each OP_ALT is followed by two bytes giving the offset to the next one,
|
||||
or to the OP_KET opcode.
|
||||
|
||||
OP_KET is used for subpatterns that do not repeat indefinitely, while
|
||||
OP_KETRMIN and OP_KETRMAX are used for indefinite repetitions, minimally or
|
||||
maximally respectively. All three are followed by two bytes giving (as a
|
||||
positive number) the offset back to the matching OP_BRA opcode.
|
||||
|
||||
If a subpattern is quantified such that it is permitted to match zero times, it
|
||||
is preceded by one of OP_BRAZERO or OP_BRAMINZERO. These are single-byte
|
||||
opcodes which tell the matcher that skipping this subpattern entirely is a
|
||||
valid branch.
|
||||
|
||||
A subpattern with an indefinite maximum repetition is replicated in the
|
||||
compiled data its minimum number of times (or once with OP_BRAZERO if the
|
||||
minimum is zero), with the final copy terminating with OP_KETRMIN or OP_KETRMAX
|
||||
as appropriate.
|
||||
|
||||
A subpattern with a bounded maximum repetition is replicated in a nested
|
||||
fashion up to the maximum number of times, with OP_BRAZERO or OP_BRAMINZERO
|
||||
before each replication after the minimum, so that, for example, (abc){2,5} is
|
||||
compiled as (abc)(abc)((abc)((abc)(abc)?)?)?.
|
||||
|
||||
|
||||
Assertions
|
||||
----------
|
||||
|
||||
Forward assertions are just like other subpatterns, but starting with one of
|
||||
the opcodes OP_ASSERT or OP_ASSERT_NOT. Backward assertions use the opcodes
|
||||
OP_ASSERTBACK and OP_ASSERTBACK_NOT, and the first opcode inside the assertion
|
||||
is OP_REVERSE, followed by a two byte count of the number of characters to move
|
||||
back the pointer in the subject string. When operating in UTF-8 mode, the count
|
||||
is a character count rather than a byte count. A separate count is present in
|
||||
each alternative of a lookbehind assertion, allowing them to have different
|
||||
fixed lengths.
|
||||
|
||||
|
||||
Once-only subpatterns
|
||||
---------------------
|
||||
|
||||
These are also just like other subpatterns, but they start with the opcode
|
||||
OP_ONCE.
|
||||
|
||||
|
||||
Conditional subpatterns
|
||||
-----------------------
|
||||
|
||||
These are like other subpatterns, but they start with the opcode OP_COND. If
|
||||
the condition is a back reference, this is stored at the start of the
|
||||
subpattern using the opcode OP_CREF followed by two bytes containing the
|
||||
reference number. If the condition is "in recursion" (coded as "(?(R)"), the
|
||||
same scheme is used, with a "reference number" of 0xffff. Otherwise, a
|
||||
conditional subpattern always starts with one of the assertions.
|
||||
|
||||
|
||||
Recursion
|
||||
---------
|
||||
|
||||
Recursion either matches the current regex, or some subexpression. The opcode
|
||||
OP_RECURSE is followed by an value which is the offset to the starting bracket
|
||||
from the start of the whole pattern.
|
||||
|
||||
|
||||
Callout
|
||||
-------
|
||||
|
||||
OP_CALLOUT is followed by one byte of data that holds a callout number in the
|
||||
range 0 to 254 for manual callouts, or 255 for an automatic callout. In both
|
||||
cases there follows a two-byte value giving the offset in the pattern to the
|
||||
start of the following item, and another two-byte item giving the length of the
|
||||
next item.
|
||||
|
||||
|
||||
Changing options
|
||||
----------------
|
||||
|
||||
If any of the /i, /m, or /s options are changed within a pattern, an OP_OPT
|
||||
opcode is compiled, followed by one byte containing the new settings of these
|
||||
flags. If there are several alternatives, there is an occurrence of OP_OPT at
|
||||
the start of all those following the first options change, to set appropriate
|
||||
options for the start of the alternative. Immediately after the end of the
|
||||
group there is another such item to reset the flags to their previous values. A
|
||||
change of flag right at the very start of the pattern can be handled entirely
|
||||
at compile time, and so does not cause anything to be put into the compiled
|
||||
data.
|
||||
|
||||
Philip Hazel
|
||||
September 2004
|
||||
Vendored
+108
@@ -0,0 +1,108 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>PCRE specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>Perl-compatible Regular Expressions (PCRE)</h1>
|
||||
<p>
|
||||
The HTML documentation for PCRE comprises the following pages:
|
||||
</p>
|
||||
|
||||
<table>
|
||||
<tr><td><a href="pcre.html">pcre</a></td>
|
||||
<td> Introductory page</td></tr>
|
||||
|
||||
<tr><td><a href="pcreapi.html">pcreapi</a></td>
|
||||
<td> PCRE's native API</td></tr>
|
||||
|
||||
<tr><td><a href="pcrebuild.html">pcrebuild</a></td>
|
||||
<td> Options for building PCRE</td></tr>
|
||||
|
||||
<tr><td><a href="pcrecallout.html">pcrecallout</a></td>
|
||||
<td> The <i>callout</i> facility</td></tr>
|
||||
|
||||
<tr><td><a href="pcrecompat.html">pcrecompat</a></td>
|
||||
<td> Compability with Perl</td></tr>
|
||||
|
||||
<tr><td><a href="pcregrep.html">pcregrep</a></td>
|
||||
<td> The <b>pcregrep</b> command</td></tr>
|
||||
|
||||
<tr><td><a href="pcrepartial.html">pcrepartial</a></td>
|
||||
<td> Using PCRE for partial matching</td></tr>
|
||||
|
||||
<tr><td><a href="pcrepattern.html">pcrepattern</a></td>
|
||||
<td> Specification of the regular expressions supported by PCRE</td></tr>
|
||||
|
||||
<tr><td><a href="pcreperform.html">pcreperform</a></td>
|
||||
<td> Some comments on performance</td></tr>
|
||||
|
||||
<tr><td><a href="pcreposix.html">pcreposix</a></td>
|
||||
<td> The POSIX API to the PCRE library</td></tr>
|
||||
|
||||
<tr><td><a href="pcreprecompile.html">pcreprecompile</a></td>
|
||||
<td> How to save and re-use compiled patterns</td></tr>
|
||||
|
||||
<tr><td><a href="pcresample.html">pcresample</a></td>
|
||||
<td> Description of the sample program</td></tr>
|
||||
|
||||
<tr><td><a href="pcretest.html">pcretest</a></td>
|
||||
<td> The <b>pcretest</b> command for testing PCRE</td></tr>
|
||||
</table>
|
||||
|
||||
<p>
|
||||
There are also individual pages that summarize the interface for each function
|
||||
in the library:
|
||||
</p>
|
||||
|
||||
<table>
|
||||
|
||||
<tr><td><a href="pcre_compile.html">pcre_compile</a></td>
|
||||
<td> Compile a regular expression</td></tr>
|
||||
|
||||
<tr><td><a href="pcre_config.html">pcre_config</a></td>
|
||||
<td> Show build-time configuration options</td></tr>
|
||||
|
||||
<tr><td><a href="pcre_copy_named_substring.html">pcre_copy_named_substring</a></td>
|
||||
<td> Extract named substring into given buffer</td></tr>
|
||||
|
||||
<tr><td><a href="pcre_copy_substring.html">pcre_copy_substring</a></td>
|
||||
<td> Extract numbered substring into given buffer</td></tr>
|
||||
|
||||
<tr><td><a href="pcre_exec.html">pcre_exec</a></td>
|
||||
<td> Match a compiled pattern to a subject string</td></tr>
|
||||
|
||||
<tr><td><a href="pcre_free_substring.html">pcre_free_substring</a></td>
|
||||
<td> Free extracted substring</td></tr>
|
||||
|
||||
<tr><td><a href="pcre_free_substring_list.html">pcre_free_substring_list</a></td>
|
||||
<td> Free list of extracted substrings</td></tr>
|
||||
|
||||
<tr><td><a href="pcre_fullinfo.html">pcre_fullinfo</a></td>
|
||||
<td> Extract information about a pattern</td></tr>
|
||||
|
||||
<tr><td><a href="pcre_get_named_substring.html">pcre_get_named_substring</a></td>
|
||||
<td> Extract named substring into new memory</td></tr>
|
||||
|
||||
<tr><td><a href="pcre_get_stringnumber.html">pcre_get_stringnumber</a></td>
|
||||
<td> Convert captured string name to number</td></tr>
|
||||
|
||||
<tr><td><a href="pcre_get_substring.html">pcre_get_substring</a></td>
|
||||
<td> Extract numbered substring into new memory</td></tr>
|
||||
|
||||
<tr><td><a href="pcre_get_substring_list.html">pcre_get_substring_list</a></td>
|
||||
<td> Extract all substrings into new memory</td></tr>
|
||||
|
||||
<tr><td><a href="pcre_info.html">pcre_info</a></td>
|
||||
<td> Obsolete information extraction function</td></tr>
|
||||
|
||||
<tr><td><a href="pcre_maketables.html">pcre_maketables</a></td>
|
||||
<td> Build character tables in current locale</td></tr>
|
||||
|
||||
<tr><td><a href="pcre_study.html">pcre_study</a></td>
|
||||
<td> Study a compiled pattern</td></tr>
|
||||
|
||||
<tr><td><a href="pcre_version.html">pcre_version</a></td>
|
||||
<td> Return PCRE version and release date</td></tr>
|
||||
</table>
|
||||
|
||||
</html>
|
||||
Vendored
+214
@@ -0,0 +1,214 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<ul>
|
||||
<li><a name="TOC1" href="#SEC1">INTRODUCTION</a>
|
||||
<li><a name="TOC2" href="#SEC2">USER DOCUMENTATION</a>
|
||||
<li><a name="TOC3" href="#SEC3">LIMITATIONS</a>
|
||||
<li><a name="TOC4" href="#SEC4">UTF-8 AND UNICODE PROPERTY SUPPORT</a>
|
||||
<li><a name="TOC5" href="#SEC5">AUTHOR</a>
|
||||
</ul>
|
||||
<br><a name="SEC1" href="#TOC1">INTRODUCTION</a><br>
|
||||
<P>
|
||||
The PCRE library is a set of functions that implement regular expression
|
||||
pattern matching using the same syntax and semantics as Perl, with just a few
|
||||
differences. The current implementation of PCRE (release 5.x) corresponds
|
||||
approximately with Perl 5.8, including support for UTF-8 encoded strings and
|
||||
Unicode general category properties. However, this support has to be explicitly
|
||||
enabled; it is not the default.
|
||||
</P>
|
||||
<P>
|
||||
PCRE is written in C and released as a C library. A number of people have
|
||||
written wrappers and interfaces of various kinds. A C++ class is included in
|
||||
these contributions, which can be found in the <i>Contrib</i> directory at the
|
||||
primary FTP site, which is:
|
||||
<a href="ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre">ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre</a>
|
||||
</P>
|
||||
<P>
|
||||
Details of exactly which Perl regular expression features are and are not
|
||||
supported by PCRE are given in separate documents. See the
|
||||
<a href="pcrepattern.html"><b>pcrepattern</b></a>
|
||||
and
|
||||
<a href="pcrecompat.html"><b>pcrecompat</b></a>
|
||||
pages.
|
||||
</P>
|
||||
<P>
|
||||
Some features of PCRE can be included, excluded, or changed when the library is
|
||||
built. The
|
||||
<a href="pcre_config.html"><b>pcre_config()</b></a>
|
||||
function makes it possible for a client to discover which features are
|
||||
available. The features themselves are described in the
|
||||
<a href="pcrebuild.html"><b>pcrebuild</b></a>
|
||||
page. Documentation about building PCRE for various operating systems can be
|
||||
found in the <b>README</b> file in the source distribution.
|
||||
</P>
|
||||
<br><a name="SEC2" href="#TOC1">USER DOCUMENTATION</a><br>
|
||||
<P>
|
||||
The user documentation for PCRE comprises a number of different sections. In
|
||||
the "man" format, each of these is a separate "man page". In the HTML format,
|
||||
each is a separate page, linked from the index page. In the plain text format,
|
||||
all the sections are concatenated, for ease of searching. The sections are as
|
||||
follows:
|
||||
<pre>
|
||||
pcre this document
|
||||
pcreapi details of PCRE's native API
|
||||
pcrebuild options for building PCRE
|
||||
pcrecallout details of the callout feature
|
||||
pcrecompat discussion of Perl compatibility
|
||||
pcregrep description of the <b>pcregrep</b> command
|
||||
pcrepartial details of the partial matching facility
|
||||
pcrepattern syntax and semantics of supported regular expressions
|
||||
pcreperform discussion of performance issues
|
||||
pcreposix the POSIX-compatible API
|
||||
pcreprecompile details of saving and re-using precompiled patterns
|
||||
pcresample discussion of the sample program
|
||||
pcretest description of the <b>pcretest</b> testing command
|
||||
</pre>
|
||||
In addition, in the "man" and HTML formats, there is a short page for each
|
||||
library function, listing its arguments and results.
|
||||
</P>
|
||||
<br><a name="SEC3" href="#TOC1">LIMITATIONS</a><br>
|
||||
<P>
|
||||
There are some size limitations in PCRE but it is hoped that they will never in
|
||||
practice be relevant.
|
||||
</P>
|
||||
<P>
|
||||
The maximum length of a compiled pattern is 65539 (sic) bytes if PCRE is
|
||||
compiled with the default internal linkage size of 2. If you want to process
|
||||
regular expressions that are truly enormous, you can compile PCRE with an
|
||||
internal linkage size of 3 or 4 (see the <b>README</b> file in the source
|
||||
distribution and the
|
||||
<a href="pcrebuild.html"><b>pcrebuild</b></a>
|
||||
documentation for details). In these cases the limit is substantially larger.
|
||||
However, the speed of execution will be slower.
|
||||
</P>
|
||||
<P>
|
||||
All values in repeating quantifiers must be less than 65536.
|
||||
The maximum number of capturing subpatterns is 65535.
|
||||
</P>
|
||||
<P>
|
||||
There is no limit to the number of non-capturing subpatterns, but the maximum
|
||||
depth of nesting of all kinds of parenthesized subpattern, including capturing
|
||||
subpatterns, assertions, and other types of subpattern, is 200.
|
||||
</P>
|
||||
<P>
|
||||
The maximum length of a subject string is the largest positive number that an
|
||||
integer variable can hold. However, PCRE uses recursion to handle subpatterns
|
||||
and indefinite repetition. This means that the available stack space may limit
|
||||
the size of a subject string that can be processed by certain patterns.
|
||||
<a name="utf8support"></a></P>
|
||||
<br><a name="SEC4" href="#TOC1">UTF-8 AND UNICODE PROPERTY SUPPORT</a><br>
|
||||
<P>
|
||||
From release 3.3, PCRE has had some support for character strings encoded in
|
||||
the UTF-8 format. For release 4.0 this was greatly extended to cover most
|
||||
common requirements, and in release 5.0 additional support for Unicode general
|
||||
category properties was added.
|
||||
</P>
|
||||
<P>
|
||||
In order process UTF-8 strings, you must build PCRE to include UTF-8 support in
|
||||
the code, and, in addition, you must call
|
||||
<a href="pcre_compile.html"><b>pcre_compile()</b></a>
|
||||
with the PCRE_UTF8 option flag. When you do this, both the pattern and any
|
||||
subject strings that are matched against it are treated as UTF-8 strings
|
||||
instead of just strings of bytes.
|
||||
</P>
|
||||
<P>
|
||||
If you compile PCRE with UTF-8 support, but do not use it at run time, the
|
||||
library will be a bit bigger, but the additional run time overhead is limited
|
||||
to testing the PCRE_UTF8 flag in several places, so should not be very large.
|
||||
</P>
|
||||
<P>
|
||||
If PCRE is built with Unicode character property support (which implies UTF-8
|
||||
support), the escape sequences \p{..}, \P{..}, and \X are supported.
|
||||
The available properties that can be tested are limited to the general
|
||||
category properties such as Lu for an upper case letter or Nd for a decimal
|
||||
number. A full list is given in the
|
||||
<a href="pcrepattern.html"><b>pcrepattern</b></a>
|
||||
documentation. The PCRE library is increased in size by about 90K when Unicode
|
||||
property support is included.
|
||||
</P>
|
||||
<P>
|
||||
The following comments apply when PCRE is running in UTF-8 mode:
|
||||
</P>
|
||||
<P>
|
||||
1. When you set the PCRE_UTF8 flag, the strings passed as patterns and subjects
|
||||
are checked for validity on entry to the relevant functions. If an invalid
|
||||
UTF-8 string is passed, an error return is given. In some situations, you may
|
||||
already know that your strings are valid, and therefore want to skip these
|
||||
checks in order to improve performance. If you set the PCRE_NO_UTF8_CHECK flag
|
||||
at compile time or at run time, PCRE assumes that the pattern or subject it
|
||||
is given (respectively) contains only valid UTF-8 codes. In this case, it does
|
||||
not diagnose an invalid UTF-8 string. If you pass an invalid UTF-8 string to
|
||||
PCRE when PCRE_NO_UTF8_CHECK is set, the results are undefined. Your program
|
||||
may crash.
|
||||
</P>
|
||||
<P>
|
||||
2. In a pattern, the escape sequence \x{...}, where the contents of the braces
|
||||
is a string of hexadecimal digits, is interpreted as a UTF-8 character whose
|
||||
code number is the given hexadecimal number, for example: \x{1234}. If a
|
||||
non-hexadecimal digit appears between the braces, the item is not recognized.
|
||||
This escape sequence can be used either as a literal, or within a character
|
||||
class.
|
||||
</P>
|
||||
<P>
|
||||
3. The original hexadecimal escape sequence, \xhh, matches a two-byte UTF-8
|
||||
character if the value is greater than 127.
|
||||
</P>
|
||||
<P>
|
||||
4. Repeat quantifiers apply to complete UTF-8 characters, not to individual
|
||||
bytes, for example: \x{100}{3}.
|
||||
</P>
|
||||
<P>
|
||||
5. The dot metacharacter matches one UTF-8 character instead of a single byte.
|
||||
</P>
|
||||
<P>
|
||||
6. The escape sequence \C can be used to match a single byte in UTF-8 mode,
|
||||
but its use can lead to some strange effects.
|
||||
</P>
|
||||
<P>
|
||||
7. The character escapes \b, \B, \d, \D, \s, \S, \w, and \W correctly
|
||||
test characters of any code value, but the characters that PCRE recognizes as
|
||||
digits, spaces, or word characters remain the same set as before, all with
|
||||
values less than 256. This remains true even when PCRE includes Unicode
|
||||
property support, because to do otherwise would slow down PCRE in many common
|
||||
cases. If you really want to test for a wider sense of, say, "digit", you
|
||||
must use Unicode property tests such as \p{Nd}.
|
||||
</P>
|
||||
<P>
|
||||
8. Similarly, characters that match the POSIX named character classes are all
|
||||
low-valued characters.
|
||||
</P>
|
||||
<P>
|
||||
9. Case-insensitive matching applies only to characters whose values are less
|
||||
than 128, unless PCRE is built with Unicode property support. Even when Unicode
|
||||
property support is available, PCRE still uses its own character tables when
|
||||
checking the case of low-valued characters, so as not to degrade performance.
|
||||
The Unicode property information is used only for characters with higher
|
||||
values.
|
||||
</P>
|
||||
<br><a name="SEC5" href="#TOC1">AUTHOR</a><br>
|
||||
<P>
|
||||
Philip Hazel <[email protected]>
|
||||
<br>
|
||||
University Computing Service,
|
||||
<br>
|
||||
Cambridge CB2 3QG, England.
|
||||
<br>
|
||||
Phone: +44 1223 334714
|
||||
Last updated: 09 September 2004
|
||||
<br>
|
||||
Copyright © 1997-2004 University of Cambridge.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+75
@@ -0,0 +1,75 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre_compile specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre_compile man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
SYNOPSIS
|
||||
</b><br>
|
||||
<P>
|
||||
<b>#include <pcre.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>pcre *pcre_compile(const char *<i>pattern</i>, int <i>options</i>,</b>
|
||||
<b>const char **<i>errptr</i>, int *<i>erroffset</i>,</b>
|
||||
<b>const unsigned char *<i>tableptr</i>);</b>
|
||||
</P>
|
||||
<br><b>
|
||||
DESCRIPTION
|
||||
</b><br>
|
||||
<P>
|
||||
This function compiles a regular expression into an internal form. Its
|
||||
arguments are:
|
||||
<pre>
|
||||
<i>pattern</i> A zero-terminated string containing the
|
||||
regular expression to be compiled
|
||||
<i>options</i> Zero or more option bits
|
||||
<i>errptr</i> Where to put an error message
|
||||
<i>erroffset</i> Offset in pattern where error was found
|
||||
<i>tableptr</i> Pointer to character tables, or NULL to
|
||||
use the built-in default
|
||||
</pre>
|
||||
The option bits are:
|
||||
<pre>
|
||||
PCRE_ANCHORED Force pattern anchoring
|
||||
PCRE_AUTO_CALLOUT Compile automatic callouts
|
||||
PCRE_CASELESS Do caseless matching
|
||||
PCRE_DOLLAR_ENDONLY $ not to match newline at end
|
||||
PCRE_DOTALL . matches anything including NL
|
||||
PCRE_EXTENDED Ignore whitespace and # comments
|
||||
PCRE_EXTRA PCRE extra features
|
||||
(not much use currently)
|
||||
PCRE_MULTILINE ^ and $ match newlines within data
|
||||
PCRE_NO_AUTO_CAPTURE Disable numbered capturing paren-
|
||||
theses (named ones available)
|
||||
PCRE_UNGREEDY Invert greediness of quantifiers
|
||||
PCRE_UTF8 Run in UTF-8 mode
|
||||
PCRE_NO_UTF8_CHECK Do not check the pattern for UTF-8
|
||||
validity (only relevant if
|
||||
PCRE_UTF8 is set)
|
||||
</pre>
|
||||
PCRE must be built with UTF-8 support in order to use PCRE_UTF8 and
|
||||
PCRE_NO_UTF8_CHECK.
|
||||
</P>
|
||||
<P>
|
||||
The yield of the function is a pointer to a private data structure that
|
||||
contains the compiled pattern, or NULL if an error was detected.
|
||||
</P>
|
||||
<P>
|
||||
There is a complete description of the PCRE native API in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
page and a description of the POSIX API in the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
page.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+60
@@ -0,0 +1,60 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre_config specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre_config man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
SYNOPSIS
|
||||
</b><br>
|
||||
<P>
|
||||
<b>#include <pcre.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>int pcre_config(int <i>what</i>, void *<i>where</i>);</b>
|
||||
</P>
|
||||
<br><b>
|
||||
DESCRIPTION
|
||||
</b><br>
|
||||
<P>
|
||||
This function makes it possible for a client program to find out which optional
|
||||
features are available in the version of the PCRE library it is using. Its
|
||||
arguments are as follows:
|
||||
<pre>
|
||||
<i>what</i> A code specifying what information is required
|
||||
<i>where</i> Points to where to put the data
|
||||
</pre>
|
||||
The available codes are:
|
||||
<pre>
|
||||
PCRE_CONFIG_LINK_SIZE Internal link size: 2, 3, or 4
|
||||
PCRE_CONFIG_MATCH_LIMIT Internal resource limit
|
||||
PCRE_CONFIG_NEWLINE Value of the newline character
|
||||
PCRE_CONFIG_POSIX_MALLOC_THRESHOLD
|
||||
Threshold of return slots, above
|
||||
which <b>malloc()</b> is used by
|
||||
the POSIX API
|
||||
PCRE_CONFIG_STACKRECURSE Recursion implementation (1=stack 0=heap)
|
||||
PCRE_CONFIG_UTF8 Availability of UTF-8 support (1=yes 0=no)
|
||||
PCRE_CONFIG_UNICODE_PROPERTIES
|
||||
Availability of Unicode property support
|
||||
(1=yes 0=no)
|
||||
</pre>
|
||||
The function yields 0 on success or PCRE_ERROR_BADOPTION otherwise.
|
||||
</P>
|
||||
<P>
|
||||
There is a complete description of the PCRE native API in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
page and a description of the POSIX API in the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
page.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
@@ -0,0 +1,53 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre_copy_named_substring specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre_copy_named_substring man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
SYNOPSIS
|
||||
</b><br>
|
||||
<P>
|
||||
<b>#include <pcre.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>int pcre_copy_named_substring(const pcre *<i>code</i>,</b>
|
||||
<b>const char *<i>subject</i>, int *<i>ovector</i>,</b>
|
||||
<b>int <i>stringcount</i>, const char *<i>stringname</i>,</b>
|
||||
<b>char *<i>buffer</i>, int <i>buffersize</i>);</b>
|
||||
</P>
|
||||
<br><b>
|
||||
DESCRIPTION
|
||||
</b><br>
|
||||
<P>
|
||||
This is a convenience function for extracting a captured substring, identified
|
||||
by name, into a given buffer. The arguments are:
|
||||
<pre>
|
||||
<i>code</i> Pattern that was successfully matched
|
||||
<i>subject</i> Subject that has been successfully matched
|
||||
<i>ovector</i> Offset vector that <b>pcre_exec()</b> used
|
||||
<i>stringcount</i> Value returned by <b>pcre_exec()</b>
|
||||
<i>stringname</i> Name of the required substring
|
||||
<i>buffer</i> Buffer to receive the string
|
||||
<i>buffersize</i> Size of buffer
|
||||
</pre>
|
||||
The yield is the length of the substring, PCRE_ERROR_NOMEMORY if the buffer was
|
||||
too small, or PCRE_ERROR_NOSUBSTRING if the string name is invalid.
|
||||
</P>
|
||||
<P>
|
||||
There is a complete description of the PCRE native API in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
page and a description of the POSIX API in the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
page.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
@@ -0,0 +1,51 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre_copy_substring specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre_copy_substring man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
SYNOPSIS
|
||||
</b><br>
|
||||
<P>
|
||||
<b>#include <pcre.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>int pcre_copy_substring(const char *<i>subject</i>, int *<i>ovector</i>,</b>
|
||||
<b>int <i>stringcount</i>, int <i>stringnumber</i>, char *<i>buffer</i>,</b>
|
||||
<b>int <i>buffersize</i>);</b>
|
||||
</P>
|
||||
<br><b>
|
||||
DESCRIPTION
|
||||
</b><br>
|
||||
<P>
|
||||
This is a convenience function for extracting a captured substring into a given
|
||||
buffer. The arguments are:
|
||||
<pre>
|
||||
<i>subject</i> Subject that has been successfully matched
|
||||
<i>ovector</i> Offset vector that <b>pcre_exec()</b> used
|
||||
<i>stringcount</i> Value returned by <b>pcre_exec()</b>
|
||||
<i>stringnumber</i> Number of the required substring
|
||||
<i>buffer</i> Buffer to receive the string
|
||||
<i>buffersize</i> Size of buffer
|
||||
</pre>
|
||||
The yield is the legnth of the string, PCRE_ERROR_NOMEMORY if the buffer was
|
||||
too small, or PCRE_ERROR_NOSUBSTRING if the string number is invalid.
|
||||
</P>
|
||||
<P>
|
||||
There is a complete description of the PCRE native API in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
page and a description of the POSIX API in the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
page.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+78
@@ -0,0 +1,78 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre_exec specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre_exec man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
SYNOPSIS
|
||||
</b><br>
|
||||
<P>
|
||||
<b>#include <pcre.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>int pcre_exec(const pcre *<i>code</i>, const pcre_extra *<i>extra</i>,</b>
|
||||
<b>const char *<i>subject</i>, int <i>length</i>, int <i>startoffset</i>,</b>
|
||||
<b>int <i>options</i>, int *<i>ovector</i>, int <i>ovecsize</i>);</b>
|
||||
</P>
|
||||
<br><b>
|
||||
DESCRIPTION
|
||||
</b><br>
|
||||
<P>
|
||||
This function matches a compiled regular expression against a given subject
|
||||
string, and returns offsets to capturing subexpressions. Its arguments are:
|
||||
<pre>
|
||||
<i>code</i> Points to the compiled pattern
|
||||
<i>extra</i> Points to an associated <b>pcre_extra</b> structure,
|
||||
or is NULL
|
||||
<i>subject</i> Points to the subject string
|
||||
<i>length</i> Length of the subject string, in bytes
|
||||
<i>startoffset</i> Offset in bytes in the subject at which to
|
||||
start matching
|
||||
<i>options</i> Option bits
|
||||
<i>ovector</i> Points to a vector of ints for result offsets
|
||||
<i>ovecsize</i> Number of elements in the vector (a multiple of 3)
|
||||
</pre>
|
||||
The options are:
|
||||
<pre>
|
||||
PCRE_ANCHORED Match only at the first position
|
||||
PCRE_NOTBOL Subject is not the beginning of a line
|
||||
PCRE_NOTEOL Subject is not the end of a line
|
||||
PCRE_NOTEMPTY An empty string is not a valid match
|
||||
PCRE_NO_UTF8_CHECK Do not check the subject for UTF-8
|
||||
validity (only relevant if PCRE_UTF8
|
||||
was set at compile time)
|
||||
PCRE_PARTIAL Return PCRE_ERROR_PARTIAL for a partial match
|
||||
</pre>
|
||||
There are restrictions on what may appear in a pattern when partial matching is
|
||||
requested.
|
||||
</P>
|
||||
<P>
|
||||
A <b>pcre_extra</b> structure contains the following fields:
|
||||
<pre>
|
||||
<i>flags</i> Bits indicating which fields are set
|
||||
<i>study_data</i> Opaque data from <b>pcre_study()</b>
|
||||
<i>match_limit</i> Limit on internal recursion
|
||||
<i>callout_data</i> Opaque data passed back to callouts
|
||||
<i>tables</i> Points to character tables or is NULL
|
||||
</pre>
|
||||
The flag bits are PCRE_EXTRA_STUDY_DATA, PCRE_EXTRA_MATCH_LIMIT,
|
||||
PCRE_EXTRA_CALLOUT_DATA, and PCRE_EXTRA_TABLES.
|
||||
</P>
|
||||
<P>
|
||||
There is a complete description of the PCRE native API in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
page and a description of the POSIX API in the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
page.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
@@ -0,0 +1,40 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre_free_substring specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre_free_substring man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
SYNOPSIS
|
||||
</b><br>
|
||||
<P>
|
||||
<b>#include <pcre.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>void pcre_free_substring(const char *<i>stringptr</i>);</b>
|
||||
</P>
|
||||
<br><b>
|
||||
DESCRIPTION
|
||||
</b><br>
|
||||
<P>
|
||||
This is a convenience function for freeing the store obtained by a previous
|
||||
call to <b>pcre_get_substring()</b> or <b>pcre_get_named_substring()</b>. Its
|
||||
only argument is a pointer to the string.
|
||||
</P>
|
||||
<P>
|
||||
There is a complete description of the PCRE native API in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
page and a description of the POSIX API in the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
page.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
@@ -0,0 +1,40 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre_free_substring_list specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre_free_substring_list man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
SYNOPSIS
|
||||
</b><br>
|
||||
<P>
|
||||
<b>#include <pcre.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>void pcre_free_substring_list(const char **<i>stringptr</i>);</b>
|
||||
</P>
|
||||
<br><b>
|
||||
DESCRIPTION
|
||||
</b><br>
|
||||
<P>
|
||||
This is a convenience function for freeing the store obtained by a previous
|
||||
call to <b>pcre_get_substring_list()</b>. Its only argument is a pointer to the
|
||||
list of string pointers.
|
||||
</P>
|
||||
<P>
|
||||
There is a complete description of the PCRE native API in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
page and a description of the POSIX API in the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
page.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+71
@@ -0,0 +1,71 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre_fullinfo specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre_fullinfo man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
SYNOPSIS
|
||||
</b><br>
|
||||
<P>
|
||||
<b>#include <pcre.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>int pcre_fullinfo(const pcre *<i>code</i>, const pcre_extra *<i>extra</i>,</b>
|
||||
<b>int <i>what</i>, void *<i>where</i>);</b>
|
||||
</P>
|
||||
<br><b>
|
||||
DESCRIPTION
|
||||
</b><br>
|
||||
<P>
|
||||
This function returns information about a compiled pattern. Its arguments are:
|
||||
<pre>
|
||||
<i>code</i> Compiled regular expression
|
||||
<i>extra</i> Result of <b>pcre_study()</b> or NULL
|
||||
<i>what</i> What information is required
|
||||
<i>where</i> Where to put the information
|
||||
</pre>
|
||||
The following information is available:
|
||||
<pre>
|
||||
PCRE_INFO_BACKREFMAX Number of highest back reference
|
||||
PCRE_INFO_CAPTURECOUNT Number of capturing subpatterns
|
||||
PCRE_INFO_DEFAULT_TABLES Pointer to default tables
|
||||
PCRE_INFO_FIRSTBYTE Fixed first byte for a match, or
|
||||
-1 for start of string
|
||||
or after newline, or
|
||||
-2 otherwise
|
||||
PCRE_INFO_FIRSTTABLE Table of first bytes
|
||||
(after studying)
|
||||
PCRE_INFO_LASTLITERAL Literal last byte required
|
||||
PCRE_INFO_NAMECOUNT Number of named subpatterns
|
||||
PCRE_INFO_NAMEENTRYSIZE Size of name table entry
|
||||
PCRE_INFO_NAMETABLE Pointer to name table
|
||||
PCRE_INFO_OPTIONS Options used for compilation
|
||||
PCRE_INFO_SIZE Size of compiled pattern
|
||||
PCRE_INFO_STUDYSIZE Size of study data
|
||||
</pre>
|
||||
The yield of the function is zero on success or:
|
||||
<pre>
|
||||
PCRE_ERROR_NULL the argument <i>code</i> was NULL
|
||||
the argument <i>where</i> was NULL
|
||||
PCRE_ERROR_BADMAGIC the "magic number" was not found
|
||||
PCRE_ERROR_BADOPTION the value of <i>what</i> was invalid
|
||||
</PRE>
|
||||
</P>
|
||||
<P>
|
||||
There is a complete description of the PCRE native API in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
page and a description of the POSIX API in the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
page.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
@@ -0,0 +1,54 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre_get_named_substring specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre_get_named_substring man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
SYNOPSIS
|
||||
</b><br>
|
||||
<P>
|
||||
<b>#include <pcre.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>int pcre_get_named_substring(const pcre *<i>code</i>,</b>
|
||||
<b>const char *<i>subject</i>, int *<i>ovector</i>,</b>
|
||||
<b>int <i>stringcount</i>, const char *<i>stringname</i>,</b>
|
||||
<b>const char **<i>stringptr</i>);</b>
|
||||
</P>
|
||||
<br><b>
|
||||
DESCRIPTION
|
||||
</b><br>
|
||||
<P>
|
||||
This is a convenience function for extracting a captured substring by name. The
|
||||
arguments are:
|
||||
<pre>
|
||||
<i>code</i> Compiled pattern
|
||||
<i>subject</i> Subject that has been successfully matched
|
||||
<i>ovector</i> Offset vector that <b>pcre_exec()</b> used
|
||||
<i>stringcount</i> Value returned by <b>pcre_exec()</b>
|
||||
<i>stringname</i> Name of the required substring
|
||||
<i>stringptr</i> Where to put the string pointer
|
||||
</pre>
|
||||
The memory in which the substring is placed is obtained by calling
|
||||
<b>pcre_malloc()</b>. The yield of the function is the length of the extracted
|
||||
substring, PCRE_ERROR_NOMEMORY if sufficient memory could not be obtained, or
|
||||
PCRE_ERROR_NOSUBSTRING if the string name is invalid.
|
||||
</P>
|
||||
<P>
|
||||
There is a complete description of the PCRE native API in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
page and a description of the POSIX API in the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
page.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
@@ -0,0 +1,46 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre_get_stringnumber specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre_get_stringnumber man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
SYNOPSIS
|
||||
</b><br>
|
||||
<P>
|
||||
<b>#include <pcre.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>int pcre_get_stringnumber(const pcre *<i>code</i>,</b>
|
||||
<b>const char *<i>name</i>);</b>
|
||||
</P>
|
||||
<br><b>
|
||||
DESCRIPTION
|
||||
</b><br>
|
||||
<P>
|
||||
This convenience function finds the number of a named substring capturing
|
||||
parenthesis in a compiled pattern. Its arguments are:
|
||||
<pre>
|
||||
<i>code</i> Compiled regular expression
|
||||
<i>name</i> Name whose number is required
|
||||
</pre>
|
||||
The yield of the function is the number of the parenthesis if the name is
|
||||
found, or PCRE_ERROR_NOSUBSTRING otherwise.
|
||||
</P>
|
||||
<P>
|
||||
There is a complete description of the PCRE native API in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
page and a description of the POSIX API in the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
page.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
@@ -0,0 +1,52 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre_get_substring specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre_get_substring man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
SYNOPSIS
|
||||
</b><br>
|
||||
<P>
|
||||
<b>#include <pcre.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>int pcre_get_substring(const char *<i>subject</i>, int *<i>ovector</i>,</b>
|
||||
<b>int <i>stringcount</i>, int <i>stringnumber</i>,</b>
|
||||
<b>const char **<i>stringptr</i>);</b>
|
||||
</P>
|
||||
<br><b>
|
||||
DESCRIPTION
|
||||
</b><br>
|
||||
<P>
|
||||
This is a convenience function for extracting a captured substring. The
|
||||
arguments are:
|
||||
<pre>
|
||||
<i>subject</i> Subject that has been successfully matched
|
||||
<i>ovector</i> Offset vector that <b>pcre_exec()</b> used
|
||||
<i>stringcount</i> Value returned by <b>pcre_exec()</b>
|
||||
<i>stringnumber</i> Number of the required substring
|
||||
<i>stringptr</i> Where to put the string pointer
|
||||
</pre>
|
||||
The memory in which the substring is placed is obtained by calling
|
||||
<b>pcre_malloc()</b>. The yield of the function is the length of the substring,
|
||||
PCRE_ERROR_NOMEMORY if sufficient memory could not be obtained, or
|
||||
PCRE_ERROR_NOSUBSTRING if the string number is invalid.
|
||||
</P>
|
||||
<P>
|
||||
There is a complete description of the PCRE native API in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
page and a description of the POSIX API in the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
page.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
@@ -0,0 +1,51 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre_get_substring_list specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre_get_substring_list man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
SYNOPSIS
|
||||
</b><br>
|
||||
<P>
|
||||
<b>#include <pcre.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>int pcre_get_substring_list(const char *<i>subject</i>,</b>
|
||||
<b>int *<i>ovector</i>, int <i>stringcount</i>, const char ***<i>listptr</i>);</b>
|
||||
</P>
|
||||
<br><b>
|
||||
DESCRIPTION
|
||||
</b><br>
|
||||
<P>
|
||||
This is a convenience function for extracting a list of all the captured
|
||||
substrings. The arguments are:
|
||||
<pre>
|
||||
<i>subject</i> Subject that has been successfully matched
|
||||
<i>ovector</i> Offset vector that <b>pcre_exec</b> used
|
||||
<i>stringcount</i> Value returned by <b>pcre_exec</b>
|
||||
<i>listptr</i> Where to put a pointer to the list
|
||||
</pre>
|
||||
The memory in which the substrings and the list are placed is obtained by
|
||||
calling <b>pcre_malloc()</b>. A pointer to a list of pointers is put in
|
||||
the variable whose address is in <i>listptr</i>. The list is terminated by a
|
||||
NULL pointer. The yield of the function is zero on success or
|
||||
PCRE_ERROR_NOMEMORY if sufficient memory could not be obtained.
|
||||
</P>
|
||||
<P>
|
||||
There is a complete description of the PCRE native API in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
page and a description of the POSIX API in the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
page.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+39
@@ -0,0 +1,39 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre_info specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre_info man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
SYNOPSIS
|
||||
</b><br>
|
||||
<P>
|
||||
<b>#include <pcre.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>int pcre_info(const pcre *<i>code</i>, int *<i>optptr</i>, int</b>
|
||||
<b>*<i>firstcharptr</i>);</b>
|
||||
</P>
|
||||
<br><b>
|
||||
DESCRIPTION
|
||||
</b><br>
|
||||
<P>
|
||||
This function is obsolete. You should be using <b>pcre_fullinfo()</b> instead.
|
||||
</P>
|
||||
<P>
|
||||
There is a complete description of the PCRE native API in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
page and a description of the POSIX API in the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
page.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+42
@@ -0,0 +1,42 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre_maketables specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre_maketables man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
SYNOPSIS
|
||||
</b><br>
|
||||
<P>
|
||||
<b>#include <pcre.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>const unsigned char *pcre_maketables(void);</b>
|
||||
</P>
|
||||
<br><b>
|
||||
DESCRIPTION
|
||||
</b><br>
|
||||
<P>
|
||||
This function builds a set of character tables for character values less than
|
||||
256. These can be passed to <b>pcre_compile()</b> to override PCRE's internal,
|
||||
built-in tables (which were made by <b>pcre_maketables()</b> when PCRE was
|
||||
compiled). You might want to do this if you are using a non-standard locale.
|
||||
The function yields a pointer to the tables.
|
||||
</P>
|
||||
<P>
|
||||
There is a complete description of the PCRE native API in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
page and a description of the POSIX API in the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
page.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+56
@@ -0,0 +1,56 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre_study specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre_study man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
SYNOPSIS
|
||||
</b><br>
|
||||
<P>
|
||||
<b>#include <pcre.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>pcre_extra *pcre_study(const pcre *<i>code</i>, int <i>options</i>,</b>
|
||||
<b>const char **<i>errptr</i>);</b>
|
||||
</P>
|
||||
<br><b>
|
||||
DESCRIPTION
|
||||
</b><br>
|
||||
<P>
|
||||
This function studies a compiled pattern, to see if additional information can
|
||||
be extracted that might speed up matching. Its arguments are:
|
||||
<pre>
|
||||
<i>code</i> A compiled regular expression
|
||||
<i>options</i> Options for <b>pcre_study()</b>
|
||||
<i>errptr</i> Where to put an error message
|
||||
</pre>
|
||||
If the function succeeds, it returns a value that can be passed to
|
||||
<b>pcre_exec()</b> via its <i>extra</i> argument.
|
||||
</P>
|
||||
<P>
|
||||
If the function returns NULL, either it could not find any additional
|
||||
information, or there was an error. You can tell the difference by looking at
|
||||
the error value. It is NULL in first case.
|
||||
</P>
|
||||
<P>
|
||||
There are currently no options defined; the value of the second argument should
|
||||
always be zero.
|
||||
</P>
|
||||
<P>
|
||||
There is a complete description of the PCRE native API in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
page and a description of the POSIX API in the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
page.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+39
@@ -0,0 +1,39 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcre_version specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcre_version man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
SYNOPSIS
|
||||
</b><br>
|
||||
<P>
|
||||
<b>#include <pcre.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>char *pcre_version(void);</b>
|
||||
</P>
|
||||
<br><b>
|
||||
DESCRIPTION
|
||||
</b><br>
|
||||
<P>
|
||||
This function returns a character string that gives the version number of the
|
||||
PCRE library and the date of its release.
|
||||
</P>
|
||||
<P>
|
||||
There is a complete description of the PCRE native API in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
page and a description of the POSIX API in the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
page.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+1287
File diff suppressed because it is too large
Load Diff
+186
@@ -0,0 +1,186 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcrebuild specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcrebuild man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<ul>
|
||||
<li><a name="TOC1" href="#SEC1">PCRE BUILD-TIME OPTIONS</a>
|
||||
<li><a name="TOC2" href="#SEC2">UTF-8 SUPPORT</a>
|
||||
<li><a name="TOC3" href="#SEC3">UNICODE CHARACTER PROPERTY SUPPORT</a>
|
||||
<li><a name="TOC4" href="#SEC4">CODE VALUE OF NEWLINE</a>
|
||||
<li><a name="TOC5" href="#SEC5">BUILDING SHARED AND STATIC LIBRARIES</a>
|
||||
<li><a name="TOC6" href="#SEC6">POSIX MALLOC USAGE</a>
|
||||
<li><a name="TOC7" href="#SEC7">LIMITING PCRE RESOURCE USAGE</a>
|
||||
<li><a name="TOC8" href="#SEC8">HANDLING VERY LARGE PATTERNS</a>
|
||||
<li><a name="TOC9" href="#SEC9">AVOIDING EXCESSIVE STACK USAGE</a>
|
||||
<li><a name="TOC10" href="#SEC10">USING EBCDIC CODE</a>
|
||||
</ul>
|
||||
<br><a name="SEC1" href="#TOC1">PCRE BUILD-TIME OPTIONS</a><br>
|
||||
<P>
|
||||
This document describes the optional features of PCRE that can be selected when
|
||||
the library is compiled. They are all selected, or deselected, by providing
|
||||
options to the <b>configure</b> script that is run before the <b>make</b>
|
||||
command. The complete list of options for <b>configure</b> (which includes the
|
||||
standard ones such as the selection of the installation directory) can be
|
||||
obtained by running
|
||||
<pre>
|
||||
./configure --help
|
||||
</pre>
|
||||
The following sections describe certain options whose names begin with --enable
|
||||
or --disable. These settings specify changes to the defaults for the
|
||||
<b>configure</b> command. Because of the way that <b>configure</b> works,
|
||||
--enable and --disable always come in pairs, so the complementary option always
|
||||
exists as well, but as it specifies the default, it is not described.
|
||||
</P>
|
||||
<br><a name="SEC2" href="#TOC1">UTF-8 SUPPORT</a><br>
|
||||
<P>
|
||||
To build PCRE with support for UTF-8 character strings, add
|
||||
<pre>
|
||||
--enable-utf8
|
||||
</pre>
|
||||
to the <b>configure</b> command. Of itself, this does not make PCRE treat
|
||||
strings as UTF-8. As well as compiling PCRE with this option, you also have
|
||||
have to set the PCRE_UTF8 option when you call the <b>pcre_compile()</b>
|
||||
function.
|
||||
</P>
|
||||
<br><a name="SEC3" href="#TOC1">UNICODE CHARACTER PROPERTY SUPPORT</a><br>
|
||||
<P>
|
||||
UTF-8 support allows PCRE to process character values greater than 255 in the
|
||||
strings that it handles. On its own, however, it does not provide any
|
||||
facilities for accessing the properties of such characters. If you want to be
|
||||
able to use the pattern escapes \P, \p, and \X, which refer to Unicode
|
||||
character properties, you must add
|
||||
<pre>
|
||||
--enable-unicode-properties
|
||||
</pre>
|
||||
to the <b>configure</b> command. This implies UTF-8 support, even if you have
|
||||
not explicitly requested it.
|
||||
</P>
|
||||
<P>
|
||||
Including Unicode property support adds around 90K of tables to the PCRE
|
||||
library, approximately doubling its size. Only the general category properties
|
||||
such as <i>Lu</i> and <i>Nd</i> are supported. Details are given in the
|
||||
<a href="pcrepattern.html"><b>pcrepattern</b></a>
|
||||
documentation.
|
||||
</P>
|
||||
<br><a name="SEC4" href="#TOC1">CODE VALUE OF NEWLINE</a><br>
|
||||
<P>
|
||||
By default, PCRE treats character 10 (linefeed) as the newline character. This
|
||||
is the normal newline character on Unix-like systems. You can compile PCRE to
|
||||
use character 13 (carriage return) instead by adding
|
||||
<pre>
|
||||
--enable-newline-is-cr
|
||||
</pre>
|
||||
to the <b>configure</b> command. For completeness there is also a
|
||||
--enable-newline-is-lf option, which explicitly specifies linefeed as the
|
||||
newline character.
|
||||
</P>
|
||||
<br><a name="SEC5" href="#TOC1">BUILDING SHARED AND STATIC LIBRARIES</a><br>
|
||||
<P>
|
||||
The PCRE building process uses <b>libtool</b> to build both shared and static
|
||||
Unix libraries by default. You can suppress one of these by adding one of
|
||||
<pre>
|
||||
--disable-shared
|
||||
--disable-static
|
||||
</pre>
|
||||
to the <b>configure</b> command, as required.
|
||||
</P>
|
||||
<br><a name="SEC6" href="#TOC1">POSIX MALLOC USAGE</a><br>
|
||||
<P>
|
||||
When PCRE is called through the POSIX interface (see the
|
||||
<a href="pcreposix.html"><b>pcreposix</b></a>
|
||||
documentation), additional working storage is required for holding the pointers
|
||||
to capturing substrings, because PCRE requires three integers per substring,
|
||||
whereas the POSIX interface provides only two. If the number of expected
|
||||
substrings is small, the wrapper function uses space on the stack, because this
|
||||
is faster than using <b>malloc()</b> for each call. The default threshold above
|
||||
which the stack is no longer used is 10; it can be changed by adding a setting
|
||||
such as
|
||||
<pre>
|
||||
--with-posix-malloc-threshold=20
|
||||
</pre>
|
||||
to the <b>configure</b> command.
|
||||
</P>
|
||||
<br><a name="SEC7" href="#TOC1">LIMITING PCRE RESOURCE USAGE</a><br>
|
||||
<P>
|
||||
Internally, PCRE has a function called <b>match()</b>, which it calls repeatedly
|
||||
(possibly recursively) when matching a pattern. By controlling the maximum
|
||||
number of times this function may be called during a single matching operation,
|
||||
a limit can be placed on the resources used by a single call to
|
||||
<b>pcre_exec()</b>. The limit can be changed at run time, as described in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
documentation. The default is 10 million, but this can be changed by adding a
|
||||
setting such as
|
||||
<pre>
|
||||
--with-match-limit=500000
|
||||
</pre>
|
||||
to the <b>configure</b> command.
|
||||
</P>
|
||||
<br><a name="SEC8" href="#TOC1">HANDLING VERY LARGE PATTERNS</a><br>
|
||||
<P>
|
||||
Within a compiled pattern, offset values are used to point from one part to
|
||||
another (for example, from an opening parenthesis to an alternation
|
||||
metacharacter). By default, two-byte values are used for these offsets, leading
|
||||
to a maximum size for a compiled pattern of around 64K. This is sufficient to
|
||||
handle all but the most gigantic patterns. Nevertheless, some people do want to
|
||||
process enormous patterns, so it is possible to compile PCRE to use three-byte
|
||||
or four-byte offsets by adding a setting such as
|
||||
<pre>
|
||||
--with-link-size=3
|
||||
</pre>
|
||||
to the <b>configure</b> command. The value given must be 2, 3, or 4. Using
|
||||
longer offsets slows down the operation of PCRE because it has to load
|
||||
additional bytes when handling them.
|
||||
</P>
|
||||
<P>
|
||||
If you build PCRE with an increased link size, test 2 (and test 5 if you are
|
||||
using UTF-8) will fail. Part of the output of these tests is a representation
|
||||
of the compiled pattern, and this changes with the link size.
|
||||
</P>
|
||||
<br><a name="SEC9" href="#TOC1">AVOIDING EXCESSIVE STACK USAGE</a><br>
|
||||
<P>
|
||||
PCRE implements backtracking while matching by making recursive calls to an
|
||||
internal function called <b>match()</b>. In environments where the size of the
|
||||
stack is limited, this can severely limit PCRE's operation. (The Unix
|
||||
environment does not usually suffer from this problem.) An alternative approach
|
||||
that uses memory from the heap to remember data, instead of using recursive
|
||||
function calls, has been implemented to work round this problem. If you want to
|
||||
build a version of PCRE that works this way, add
|
||||
<pre>
|
||||
--disable-stack-for-recursion
|
||||
</pre>
|
||||
to the <b>configure</b> command. With this configuration, PCRE will use the
|
||||
<b>pcre_stack_malloc</b> and <b>pcre_stack_free</b> variables to call memory
|
||||
management functions. Separate functions are provided because the usage is very
|
||||
predictable: the block sizes requested are always the same, and the blocks are
|
||||
always freed in reverse order. A calling program might be able to implement
|
||||
optimized functions that perform better than the standard <b>malloc()</b> and
|
||||
<b>free()</b> functions. PCRE runs noticeably more slowly when built in this
|
||||
way.
|
||||
</P>
|
||||
<br><a name="SEC10" href="#TOC1">USING EBCDIC CODE</a><br>
|
||||
<P>
|
||||
PCRE assumes by default that it will run in an environment where the character
|
||||
code is ASCII (or Unicode, which is a superset of ASCII). PCRE can, however, be
|
||||
compiled to run in an EBCDIC environment by adding
|
||||
<pre>
|
||||
--enable-ebcdic
|
||||
</pre>
|
||||
to the <b>configure</b> command.
|
||||
</P>
|
||||
<P>
|
||||
Last updated: 09 September 2004
|
||||
<br>
|
||||
Copyright © 1997-2004 University of Cambridge.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+180
@@ -0,0 +1,180 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcrecallout specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcrecallout man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<ul>
|
||||
<li><a name="TOC1" href="#SEC1">PCRE CALLOUTS</a>
|
||||
<li><a name="TOC2" href="#SEC2">MISSING CALLOUTS</a>
|
||||
<li><a name="TOC3" href="#SEC3">THE CALLOUT INTERFACE</a>
|
||||
<li><a name="TOC4" href="#SEC4">RETURN VALUES</a>
|
||||
</ul>
|
||||
<br><a name="SEC1" href="#TOC1">PCRE CALLOUTS</a><br>
|
||||
<P>
|
||||
<b>int (*pcre_callout)(pcre_callout_block *);</b>
|
||||
</P>
|
||||
<P>
|
||||
PCRE provides a feature called "callout", which is a means of temporarily
|
||||
passing control to the caller of PCRE in the middle of pattern matching. The
|
||||
caller of PCRE provides an external function by putting its entry point in the
|
||||
global variable <i>pcre_callout</i>. By default, this variable contains NULL,
|
||||
which disables all calling out.
|
||||
</P>
|
||||
<P>
|
||||
Within a regular expression, (?C) indicates the points at which the external
|
||||
function is to be called. Different callout points can be identified by putting
|
||||
a number less than 256 after the letter C. The default value is zero.
|
||||
For example, this pattern has two callout points:
|
||||
<pre>
|
||||
(?C1)\deabc(?C2)def
|
||||
</pre>
|
||||
If the PCRE_AUTO_CALLOUT option bit is set when <b>pcre_compile()</b> is called,
|
||||
PCRE automatically inserts callouts, all with number 255, before each item in
|
||||
the pattern. For example, if PCRE_AUTO_CALLOUT is used with the pattern
|
||||
<pre>
|
||||
A(\d{2}|--)
|
||||
</pre>
|
||||
it is processed as if it were
|
||||
<br>
|
||||
<br>
|
||||
(?C255)A(?C255)((?C255)\d{2}(?C255)|(?C255)-(?C255)-(?C255))(?C255)
|
||||
<br>
|
||||
<br>
|
||||
Notice that there is a callout before and after each parenthesis and
|
||||
alternation bar. Automatic callouts can be used for tracking the progress of
|
||||
pattern matching. The
|
||||
<a href="pcretest.html"><b>pcretest</b></a>
|
||||
command has an option that sets automatic callouts; when it is used, the output
|
||||
indicates how the pattern is matched. This is useful information when you are
|
||||
trying to optimize the performance of a particular pattern.
|
||||
</P>
|
||||
<br><a name="SEC2" href="#TOC1">MISSING CALLOUTS</a><br>
|
||||
<P>
|
||||
You should be aware that, because of optimizations in the way PCRE matches
|
||||
patterns, callouts sometimes do not happen. For example, if the pattern is
|
||||
<pre>
|
||||
ab(?C4)cd
|
||||
</pre>
|
||||
PCRE knows that any matching string must contain the letter "d". If the subject
|
||||
string is "abyz", the lack of "d" means that matching doesn't ever start, and
|
||||
the callout is never reached. However, with "abyd", though the result is still
|
||||
no match, the callout is obeyed.
|
||||
</P>
|
||||
<br><a name="SEC3" href="#TOC1">THE CALLOUT INTERFACE</a><br>
|
||||
<P>
|
||||
During matching, when PCRE reaches a callout point, the external function
|
||||
defined by <i>pcre_callout</i> is called (if it is set). The only argument is a
|
||||
pointer to a <b>pcre_callout</b> block. This structure contains the following
|
||||
fields:
|
||||
<pre>
|
||||
int <i>version</i>;
|
||||
int <i>callout_number</i>;
|
||||
int *<i>offset_vector</i>;
|
||||
const char *<i>subject</i>;
|
||||
int <i>subject_length</i>;
|
||||
int <i>start_match</i>;
|
||||
int <i>current_position</i>;
|
||||
int <i>capture_top</i>;
|
||||
int <i>capture_last</i>;
|
||||
void *<i>callout_data</i>;
|
||||
int <i>pattern_position</i>;
|
||||
int <i>next_item_length</i>;
|
||||
</pre>
|
||||
The <i>version</i> field is an integer containing the version number of the
|
||||
block format. The initial version was 0; the current version is 1. The version
|
||||
number will change again in future if additional fields are added, but the
|
||||
intention is never to remove any of the existing fields.
|
||||
</P>
|
||||
<P>
|
||||
The <i>callout_number</i> field contains the number of the callout, as compiled
|
||||
into the pattern (that is, the number after ?C for manual callouts, and 255 for
|
||||
automatically generated callouts).
|
||||
</P>
|
||||
<P>
|
||||
The <i>offset_vector</i> field is a pointer to the vector of offsets that was
|
||||
passed by the caller to <b>pcre_exec()</b>. The contents can be inspected in
|
||||
order to extract substrings that have been matched so far, in the same way as
|
||||
for extracting substrings after a match has completed.
|
||||
</P>
|
||||
<P>
|
||||
The <i>subject</i> and <i>subject_length</i> fields contain copies of the values
|
||||
that were passed to <b>pcre_exec()</b>.
|
||||
</P>
|
||||
<P>
|
||||
The <i>start_match</i> field contains the offset within the subject at which the
|
||||
current match attempt started. If the pattern is not anchored, the callout
|
||||
function may be called several times from the same point in the pattern for
|
||||
different starting points in the subject.
|
||||
</P>
|
||||
<P>
|
||||
The <i>current_position</i> field contains the offset within the subject of the
|
||||
current match pointer.
|
||||
</P>
|
||||
<P>
|
||||
The <i>capture_top</i> field contains one more than the number of the highest
|
||||
numbered captured substring so far. If no substrings have been captured,
|
||||
the value of <i>capture_top</i> is one.
|
||||
</P>
|
||||
<P>
|
||||
The <i>capture_last</i> field contains the number of the most recently captured
|
||||
substring. If no substrings have been captured, its value is -1.
|
||||
</P>
|
||||
<P>
|
||||
The <i>callout_data</i> field contains a value that is passed to
|
||||
<b>pcre_exec()</b> by the caller specifically so that it can be passed back in
|
||||
callouts. It is passed in the <i>pcre_callout</i> field of the <b>pcre_extra</b>
|
||||
data structure. If no such data was passed, the value of <i>callout_data</i> in
|
||||
a <b>pcre_callout</b> block is NULL. There is a description of the
|
||||
<b>pcre_extra</b> structure in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
documentation.
|
||||
</P>
|
||||
<P>
|
||||
The <i>pattern_position</i> field is present from version 1 of the
|
||||
<i>pcre_callout</i> structure. It contains the offset to the next item to be
|
||||
matched in the pattern string.
|
||||
</P>
|
||||
<P>
|
||||
The <i>next_item_length</i> field is present from version 1 of the
|
||||
<i>pcre_callout</i> structure. It contains the length of the next item to be
|
||||
matched in the pattern string. When the callout immediately precedes an
|
||||
alternation bar, a closing parenthesis, or the end of the pattern, the length
|
||||
is zero. When the callout precedes an opening parenthesis, the length is that
|
||||
of the entire subpattern.
|
||||
</P>
|
||||
<P>
|
||||
The <i>pattern_position</i> and <i>next_item_length</i> fields are intended to
|
||||
help in distinguishing between different automatic callouts, which all have the
|
||||
same callout number. However, they are set for all callouts.
|
||||
</P>
|
||||
<br><a name="SEC4" href="#TOC1">RETURN VALUES</a><br>
|
||||
<P>
|
||||
The external callout function returns an integer to PCRE. If the value is zero,
|
||||
matching proceeds as normal. If the value is greater than zero, matching fails
|
||||
at the current point, but backtracking to test other matching possibilities
|
||||
goes ahead, just as if a lookahead assertion had failed. If the value is less
|
||||
than zero, the match is abandoned, and <b>pcre_exec()</b> returns the negative
|
||||
value.
|
||||
</P>
|
||||
<P>
|
||||
Negative values should normally be chosen from the set of PCRE_ERROR_xxx
|
||||
values. In particular, PCRE_ERROR_NOMATCH forces a standard "no match" failure.
|
||||
The error number PCRE_ERROR_CALLOUT is reserved for use by callout functions;
|
||||
it will never be used by PCRE itself.
|
||||
</P>
|
||||
<P>
|
||||
Last updated: 09 September 2004
|
||||
<br>
|
||||
Copyright © 1997-2004 University of Cambridge.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+150
@@ -0,0 +1,150 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcrecompat specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcrecompat man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
DIFFERENCES BETWEEN PCRE AND PERL
|
||||
</b><br>
|
||||
<P>
|
||||
This document describes the differences in the ways that PCRE and Perl handle
|
||||
regular expressions. The differences described here are with respect to Perl
|
||||
5.8.
|
||||
</P>
|
||||
<P>
|
||||
1. PCRE does not have full UTF-8 support. Details of what it does have are
|
||||
given in the
|
||||
<a href="pcre.html#utf8support">section on UTF-8 support</a>
|
||||
in the main
|
||||
<a href="pcre.html"><b>pcre</b></a>
|
||||
page.
|
||||
</P>
|
||||
<P>
|
||||
2. PCRE does not allow repeat quantifiers on lookahead assertions. Perl permits
|
||||
them, but they do not mean what you might think. For example, (?!a){3} does
|
||||
not assert that the next three characters are not "a". It just asserts that the
|
||||
next character is not "a" three times.
|
||||
</P>
|
||||
<P>
|
||||
3. Capturing subpatterns that occur inside negative lookahead assertions are
|
||||
counted, but their entries in the offsets vector are never set. Perl sets its
|
||||
numerical variables from any such patterns that are matched before the
|
||||
assertion fails to match something (thereby succeeding), but only if the
|
||||
negative lookahead assertion contains just one branch.
|
||||
</P>
|
||||
<P>
|
||||
4. Though binary zero characters are supported in the subject string, they are
|
||||
not allowed in a pattern string because it is passed as a normal C string,
|
||||
terminated by zero. The escape sequence \0 can be used in the pattern to
|
||||
represent a binary zero.
|
||||
</P>
|
||||
<P>
|
||||
5. The following Perl escape sequences are not supported: \l, \u, \L,
|
||||
\U, and \N. In fact these are implemented by Perl's general string-handling
|
||||
and are not part of its pattern matching engine. If any of these are
|
||||
encountered by PCRE, an error is generated.
|
||||
</P>
|
||||
<P>
|
||||
6. The Perl escape sequences \p, \P, and \X are supported only if PCRE is
|
||||
built with Unicode character property support. The properties that can be
|
||||
tested with \p and \P are limited to the general category properties such as
|
||||
Lu and Nd.
|
||||
</P>
|
||||
<P>
|
||||
7. PCRE does support the \Q...\E escape for quoting substrings. Characters in
|
||||
between are treated as literals. This is slightly different from Perl in that $
|
||||
and @ are also handled as literals inside the quotes. In Perl, they cause
|
||||
variable interpolation (but of course PCRE does not have variables). Note the
|
||||
following examples:
|
||||
<pre>
|
||||
Pattern PCRE matches Perl matches
|
||||
|
||||
\Qabc$xyz\E abc$xyz abc followed by the contents of $xyz
|
||||
\Qabc\$xyz\E abc\$xyz abc\$xyz
|
||||
\Qabc\E\$\Qxyz\E abc$xyz abc$xyz
|
||||
</pre>
|
||||
The \Q...\E sequence is recognized both inside and outside character classes.
|
||||
</P>
|
||||
<P>
|
||||
8. Fairly obviously, PCRE does not support the (?{code}) and (?p{code})
|
||||
constructions. However, there is support for recursive patterns using the
|
||||
non-Perl items (?R), (?number), and (?P>name). Also, the PCRE "callout" feature
|
||||
allows an external function to be called during pattern matching. See the
|
||||
<a href="pcrecallout.html"><b>pcrecallout</b></a>
|
||||
documentation for details.
|
||||
</P>
|
||||
<P>
|
||||
9. There are some differences that are concerned with the settings of captured
|
||||
strings when part of a pattern is repeated. For example, matching "aba" against
|
||||
the pattern /^(a(b)?)+$/ in Perl leaves $2 unset, but in PCRE it is set to "b".
|
||||
</P>
|
||||
<P>
|
||||
10. PCRE provides some extensions to the Perl regular expression facilities:
|
||||
<br>
|
||||
<br>
|
||||
(a) Although lookbehind assertions must match fixed length strings, each
|
||||
alternative branch of a lookbehind assertion can match a different length of
|
||||
string. Perl requires them all to have the same length.
|
||||
<br>
|
||||
<br>
|
||||
(b) If PCRE_DOLLAR_ENDONLY is set and PCRE_MULTILINE is not set, the $
|
||||
meta-character matches only at the very end of the string.
|
||||
<br>
|
||||
<br>
|
||||
(c) If PCRE_EXTRA is set, a backslash followed by a letter with no special
|
||||
meaning is faulted.
|
||||
<br>
|
||||
<br>
|
||||
(d) If PCRE_UNGREEDY is set, the greediness of the repetition quantifiers is
|
||||
inverted, that is, by default they are not greedy, but if followed by a
|
||||
question mark they are.
|
||||
<br>
|
||||
<br>
|
||||
(e) PCRE_ANCHORED can be used at matching time to force a pattern to be tried
|
||||
only at the first matching position in the subject string.
|
||||
<br>
|
||||
<br>
|
||||
(f) The PCRE_NOTBOL, PCRE_NOTEOL, PCRE_NOTEMPTY, and PCRE_NO_AUTO_CAPTURE
|
||||
options for <b>pcre_exec()</b> have no Perl equivalents.
|
||||
<br>
|
||||
<br>
|
||||
(g) The (?R), (?number), and (?P>name) constructs allows for recursive pattern
|
||||
matching (Perl can do this using the (?p{code}) construct, which PCRE cannot
|
||||
support.)
|
||||
<br>
|
||||
<br>
|
||||
(h) PCRE supports named capturing substrings, using the Python syntax.
|
||||
<br>
|
||||
<br>
|
||||
(i) PCRE supports the possessive quantifier "++" syntax, taken from Sun's Java
|
||||
package.
|
||||
<br>
|
||||
<br>
|
||||
(j) The (R) condition, for testing recursion, is a PCRE extension.
|
||||
<br>
|
||||
<br>
|
||||
(k) The callout facility is PCRE-specific.
|
||||
<br>
|
||||
<br>
|
||||
(l) The partial matching facility is PCRE-specific.
|
||||
<br>
|
||||
<br>
|
||||
(m) Patterns compiled by PCRE can be saved and re-used at a later time, even on
|
||||
different hosts that have the other endianness.
|
||||
</P>
|
||||
<P>
|
||||
Last updated: 09 September 2004
|
||||
<br>
|
||||
Copyright © 1997-2004 University of Cambridge.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+158
@@ -0,0 +1,158 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcregrep specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcregrep man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<ul>
|
||||
<li><a name="TOC1" href="#SEC1">SYNOPSIS</a>
|
||||
<li><a name="TOC2" href="#SEC2">DESCRIPTION</a>
|
||||
<li><a name="TOC3" href="#SEC3">OPTIONS</a>
|
||||
<li><a name="TOC4" href="#SEC4">LONG OPTIONS</a>
|
||||
<li><a name="TOC5" href="#SEC5">DIAGNOSTICS</a>
|
||||
<li><a name="TOC6" href="#SEC6">AUTHOR</a>
|
||||
</ul>
|
||||
<br><a name="SEC1" href="#TOC1">SYNOPSIS</a><br>
|
||||
<P>
|
||||
<b>pcregrep [-Vcfhilnrsuvx] [long options] [pattern] [file1 file2 ...]</b>
|
||||
</P>
|
||||
<br><a name="SEC2" href="#TOC1">DESCRIPTION</a><br>
|
||||
<P>
|
||||
<b>pcregrep</b> searches files for character patterns, in the same way as other
|
||||
grep commands do, but it uses the PCRE regular expression library to support
|
||||
patterns that are compatible with the regular expressions of Perl 5. See
|
||||
<a href="pcrepattern.html"><b>pcrepattern</b></a>
|
||||
for a full description of syntax and semantics of the regular expressions that
|
||||
PCRE supports.
|
||||
</P>
|
||||
<P>
|
||||
A pattern must be specified on the command line unless the <b>-f</b> option is
|
||||
used (see below).
|
||||
</P>
|
||||
<P>
|
||||
If no files are specified, <b>pcregrep</b> reads the standard input. By default,
|
||||
each line that matches the pattern is copied to the standard output, and if
|
||||
there is more than one file, the file name is printed before each line of
|
||||
output. However, there are options that can change how <b>pcregrep</b> behaves.
|
||||
</P>
|
||||
<P>
|
||||
Lines are limited to BUFSIZ characters. BUFSIZ is defined in <b><stdio.h></b>.
|
||||
The newline character is removed from the end of each line before it is matched
|
||||
against the pattern.
|
||||
</P>
|
||||
<br><a name="SEC3" href="#TOC1">OPTIONS</a><br>
|
||||
<P>
|
||||
<b>-V</b>
|
||||
Write the version number of the PCRE library being used to the standard error
|
||||
stream.
|
||||
</P>
|
||||
<P>
|
||||
<b>-c</b>
|
||||
Do not print individual lines; instead just print a count of the number of
|
||||
lines that would otherwise have been printed. If several files are given, a
|
||||
count is printed for each of them.
|
||||
</P>
|
||||
<P>
|
||||
<b>-f</b><i>filename</i>
|
||||
Read a number of patterns from the file, one per line, and match all of them
|
||||
against each line of input. A line is output if any of the patterns match it.
|
||||
When <b>-f</b> is used, no pattern is taken from the command line; all arguments
|
||||
are treated as file names. There is a maximum of 100 patterns. Trailing white
|
||||
space is removed, and blank lines are ignored. An empty file contains no
|
||||
patterns and therefore matches nothing.
|
||||
</P>
|
||||
<P>
|
||||
<b>-h</b>
|
||||
Suppress printing of filenames when searching multiple files.
|
||||
</P>
|
||||
<P>
|
||||
<b>-i</b>
|
||||
Ignore upper/lower case distinctions during comparisons.
|
||||
</P>
|
||||
<P>
|
||||
<b>-l</b>
|
||||
Instead of printing lines from the files, just print the names of the files
|
||||
containing lines that would have been printed. Each file name is printed
|
||||
once, on a separate line.
|
||||
</P>
|
||||
<P>
|
||||
<b>-n</b>
|
||||
Precede each line by its line number in the file.
|
||||
</P>
|
||||
<P>
|
||||
<b>-r</b>
|
||||
If any file is a directory, recursively scan the files it contains. Without
|
||||
<b>-r</b> a directory is scanned as a normal file.
|
||||
</P>
|
||||
<P>
|
||||
<b>-s</b>
|
||||
Work silently, that is, display nothing except error messages.
|
||||
The exit status indicates whether any matches were found.
|
||||
</P>
|
||||
<P>
|
||||
<b>-u</b>
|
||||
Operate in UTF-8 mode. This option is available only if PCRE has been compiled
|
||||
with UTF-8 support. Both the pattern and each subject line must be valid
|
||||
strings of UTF-8 characters.
|
||||
</P>
|
||||
<P>
|
||||
<b>-v</b>
|
||||
Invert the sense of the match, so that lines which do <i>not</i> match the
|
||||
pattern are now the ones that are found.
|
||||
</P>
|
||||
<P>
|
||||
<b>-x</b>
|
||||
Force the pattern to be anchored (it must start matching at the beginning of
|
||||
the line) and in addition, require it to match the entire line. This is
|
||||
equivalent to having ^ and $ characters at the start and end of each
|
||||
alternative branch in the regular expression.
|
||||
</P>
|
||||
<br><a name="SEC4" href="#TOC1">LONG OPTIONS</a><br>
|
||||
<P>
|
||||
Long forms of all the options are available, as in GNU grep. They are shown in
|
||||
the following table:
|
||||
<pre>
|
||||
-c --count
|
||||
-h --no-filename
|
||||
-i --ignore-case
|
||||
-l --files-with-matches
|
||||
-n --line-number
|
||||
-r --recursive
|
||||
-s --no-messages
|
||||
-u --utf-8
|
||||
-V --version
|
||||
-v --invert-match
|
||||
-x --line-regex
|
||||
-x --line-regexp
|
||||
</pre>
|
||||
In addition, --file=<i>filename</i> is equivalent to -f<i>filename</i>, and
|
||||
--help shows the list of options and then exits.
|
||||
</P>
|
||||
<br><a name="SEC5" href="#TOC1">DIAGNOSTICS</a><br>
|
||||
<P>
|
||||
Exit status is 0 if any matches were found, 1 if no matches were found, and 2
|
||||
for syntax errors or inacessible files (even if matches were found).
|
||||
</P>
|
||||
<br><a name="SEC6" href="#TOC1">AUTHOR</a><br>
|
||||
<P>
|
||||
Philip Hazel <[email protected]>
|
||||
<br>
|
||||
University Computing Service
|
||||
<br>
|
||||
Cambridge CB2 3QG, England.
|
||||
</P>
|
||||
<P>
|
||||
Last updated: 09 September 2004
|
||||
<br>
|
||||
Copyright © 1997-2004 University of Cambridge.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+111
@@ -0,0 +1,111 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcrepartial specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcrepartial man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<ul>
|
||||
<li><a name="TOC1" href="#SEC1">PARTIAL MATCHING IN PCRE</a>
|
||||
<li><a name="TOC2" href="#SEC2">RESTRICTED PATTERNS FOR PCRE_PARTIAL</a>
|
||||
<li><a name="TOC3" href="#SEC3">EXAMPLE OF PARTIAL MATCHING USING PCRETEST</a>
|
||||
</ul>
|
||||
<br><a name="SEC1" href="#TOC1">PARTIAL MATCHING IN PCRE</a><br>
|
||||
<P>
|
||||
In normal use of PCRE, if the subject string that is passed to
|
||||
<b>pcre_exec()</b> matches as far as it goes, but is too short to match the
|
||||
entire pattern, PCRE_ERROR_NOMATCH is returned. There are circumstances where
|
||||
it might be helpful to distinguish this case from other cases in which there is
|
||||
no match.
|
||||
</P>
|
||||
<P>
|
||||
Consider, for example, an application where a human is required to type in data
|
||||
for a field with specific formatting requirements. An example might be a date
|
||||
in the form <i>ddmmmyy</i>, defined by this pattern:
|
||||
<pre>
|
||||
^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$
|
||||
</pre>
|
||||
If the application sees the user's keystrokes one by one, and can check that
|
||||
what has been typed so far is potentially valid, it is able to raise an error
|
||||
as soon as a mistake is made, possibly beeping and not reflecting the
|
||||
character that has been typed. This immediate feedback is likely to be a better
|
||||
user interface than a check that is delayed until the entire string has been
|
||||
entered.
|
||||
</P>
|
||||
<P>
|
||||
PCRE supports the concept of partial matching by means of the PCRE_PARTIAL
|
||||
option, which can be set when calling <b>pcre_exec()</b>. When this is done, the
|
||||
return code PCRE_ERROR_NOMATCH is converted into PCRE_ERROR_PARTIAL if at any
|
||||
time during the matching process the entire subject string matched part of the
|
||||
pattern. No captured data is set when this occurs.
|
||||
</P>
|
||||
<P>
|
||||
Using PCRE_PARTIAL disables one of PCRE's optimizations. PCRE remembers the
|
||||
last literal byte in a pattern, and abandons matching immediately if such a
|
||||
byte is not present in the subject string. This optimization cannot be used
|
||||
for a subject string that might match only partially.
|
||||
</P>
|
||||
<br><a name="SEC2" href="#TOC1">RESTRICTED PATTERNS FOR PCRE_PARTIAL</a><br>
|
||||
<P>
|
||||
Because of the way certain internal optimizations are implemented in PCRE, the
|
||||
PCRE_PARTIAL option cannot be used with all patterns. Repeated single
|
||||
characters such as
|
||||
<pre>
|
||||
a{2,4}
|
||||
</pre>
|
||||
and repeated single metasequences such as
|
||||
<pre>
|
||||
\d+
|
||||
</pre>
|
||||
are not permitted if the maximum number of occurrences is greater than one.
|
||||
Optional items such as \d? (where the maximum is one) are permitted.
|
||||
Quantifiers with any values are permitted after parentheses, so the invalid
|
||||
examples above can be coded thus:
|
||||
<pre>
|
||||
(a){2,4}
|
||||
(\d)+
|
||||
</pre>
|
||||
These constructions run more slowly, but for the kinds of application that are
|
||||
envisaged for this facility, this is not felt to be a major restriction.
|
||||
</P>
|
||||
<P>
|
||||
If PCRE_PARTIAL is set for a pattern that does not conform to the restrictions,
|
||||
<b>pcre_exec()</b> returns the error code PCRE_ERROR_BADPARTIAL (-13).
|
||||
</P>
|
||||
<br><a name="SEC3" href="#TOC1">EXAMPLE OF PARTIAL MATCHING USING PCRETEST</a><br>
|
||||
<P>
|
||||
If the escape sequence \P is present in a <b>pcretest</b> data line, the
|
||||
PCRE_PARTIAL flag is used for the match. Here is a run of <b>pcretest</b> that
|
||||
uses the date example quoted above:
|
||||
<pre>
|
||||
re> /^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$/
|
||||
data> 25jun04\P
|
||||
0: 25jun04
|
||||
1: jun
|
||||
data> 25dec3\P
|
||||
Partial match
|
||||
data> 3ju\P
|
||||
Partial match
|
||||
data> 3juj\P
|
||||
No match
|
||||
data> j\P
|
||||
No match
|
||||
</pre>
|
||||
The first data string is matched completely, so <b>pcretest</b> shows the
|
||||
matched substrings. The remaining four strings do not match the complete
|
||||
pattern, but the first two are partial matches.
|
||||
</P>
|
||||
<P>
|
||||
Last updated: 08 September 2004
|
||||
<br>
|
||||
Copyright © 1997-2004 University of Cambridge.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+1470
File diff suppressed because it is too large
Load Diff
+97
@@ -0,0 +1,97 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcreperform specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcreperform man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
PCRE PERFORMANCE
|
||||
</b><br>
|
||||
<P>
|
||||
Certain items that may appear in regular expression patterns are more efficient
|
||||
than others. It is more efficient to use a character class like [aeiou] than a
|
||||
set of alternatives such as (a|e|i|o|u). In general, the simplest construction
|
||||
that provides the required behaviour is usually the most efficient. Jeffrey
|
||||
Friedl's book contains a lot of useful general discussion about optimizing
|
||||
regular expressions for efficient performance. This document contains a few
|
||||
observations about PCRE.
|
||||
</P>
|
||||
<P>
|
||||
Using Unicode character properties (the \p, \P, and \X escapes) is slow,
|
||||
because PCRE has to scan a structure that contains data for over fifteen
|
||||
thousand characters whenever it needs a character's property. If you can find
|
||||
an alternative pattern that does not use character properties, it will probably
|
||||
be faster.
|
||||
</P>
|
||||
<P>
|
||||
When a pattern begins with .* not in parentheses, or in parentheses that are
|
||||
not the subject of a backreference, and the PCRE_DOTALL option is set, the
|
||||
pattern is implicitly anchored by PCRE, since it can match only at the start of
|
||||
a subject string. However, if PCRE_DOTALL is not set, PCRE cannot make this
|
||||
optimization, because the . metacharacter does not then match a newline, and if
|
||||
the subject string contains newlines, the pattern may match from the character
|
||||
immediately following one of them instead of from the very start. For example,
|
||||
the pattern
|
||||
<pre>
|
||||
.*second
|
||||
</pre>
|
||||
matches the subject "first\nand second" (where \n stands for a newline
|
||||
character), with the match starting at the seventh character. In order to do
|
||||
this, PCRE has to retry the match starting after every newline in the subject.
|
||||
</P>
|
||||
<P>
|
||||
If you are using such a pattern with subject strings that do not contain
|
||||
newlines, the best performance is obtained by setting PCRE_DOTALL, or starting
|
||||
the pattern with ^.* to indicate explicit anchoring. That saves PCRE from
|
||||
having to scan along the subject looking for a newline to restart at.
|
||||
</P>
|
||||
<P>
|
||||
Beware of patterns that contain nested indefinite repeats. These can take a
|
||||
long time to run when applied to a string that does not match. Consider the
|
||||
pattern fragment
|
||||
<pre>
|
||||
(a+)*
|
||||
</pre>
|
||||
This can match "aaaa" in 33 different ways, and this number increases very
|
||||
rapidly as the string gets longer. (The * repeat can match 0, 1, 2, 3, or 4
|
||||
times, and for each of those cases other than 0, the + repeats can match
|
||||
different numbers of times.) When the remainder of the pattern is such that the
|
||||
entire match is going to fail, PCRE has in principle to try every possible
|
||||
variation, and this can take an extremely long time.
|
||||
</P>
|
||||
<P>
|
||||
An optimization catches some of the more simple cases such as
|
||||
<pre>
|
||||
(a+)*b
|
||||
</pre>
|
||||
where a literal character follows. Before embarking on the standard matching
|
||||
procedure, PCRE checks that there is a "b" later in the subject string, and if
|
||||
there is not, it fails the match immediately. However, when there is no
|
||||
following literal this optimization cannot be used. You can see the difference
|
||||
by comparing the behaviour of
|
||||
<pre>
|
||||
(a+)*\d
|
||||
</pre>
|
||||
with the pattern above. The former gives a failure almost instantly when
|
||||
applied to a whole line of "a" characters, whereas the latter takes an
|
||||
appreciable time with strings longer than about 20 characters.
|
||||
</P>
|
||||
<P>
|
||||
In many cases, the solution to this kind of performance issue is to use an
|
||||
atomic group or a possessive quantifier.
|
||||
</P>
|
||||
<P>
|
||||
Last updated: 09 September 2004
|
||||
<br>
|
||||
Copyright © 1997-2004 University of Cambridge.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+218
@@ -0,0 +1,218 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcreposix specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcreposix man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<ul>
|
||||
<li><a name="TOC1" href="#SEC1">SYNOPSIS OF POSIX API</a>
|
||||
<li><a name="TOC2" href="#SEC2">DESCRIPTION</a>
|
||||
<li><a name="TOC3" href="#SEC3">COMPILING A PATTERN</a>
|
||||
<li><a name="TOC4" href="#SEC4">MATCHING NEWLINE CHARACTERS</a>
|
||||
<li><a name="TOC5" href="#SEC5">MATCHING A PATTERN</a>
|
||||
<li><a name="TOC6" href="#SEC6">ERROR MESSAGES</a>
|
||||
<li><a name="TOC7" href="#SEC7">MEMORY USAGE</a>
|
||||
<li><a name="TOC8" href="#SEC8">AUTHOR</a>
|
||||
</ul>
|
||||
<br><a name="SEC1" href="#TOC1">SYNOPSIS OF POSIX API</a><br>
|
||||
<P>
|
||||
<b>#include <pcreposix.h></b>
|
||||
</P>
|
||||
<P>
|
||||
<b>int regcomp(regex_t *<i>preg</i>, const char *<i>pattern</i>,</b>
|
||||
<b>int <i>cflags</i>);</b>
|
||||
</P>
|
||||
<P>
|
||||
<b>int regexec(regex_t *<i>preg</i>, const char *<i>string</i>,</b>
|
||||
<b>size_t <i>nmatch</i>, regmatch_t <i>pmatch</i>[], int <i>eflags</i>);</b>
|
||||
</P>
|
||||
<P>
|
||||
<b>size_t regerror(int <i>errcode</i>, const regex_t *<i>preg</i>,</b>
|
||||
<b>char *<i>errbuf</i>, size_t <i>errbuf_size</i>);</b>
|
||||
</P>
|
||||
<P>
|
||||
<b>void regfree(regex_t *<i>preg</i>);</b>
|
||||
</P>
|
||||
<br><a name="SEC2" href="#TOC1">DESCRIPTION</a><br>
|
||||
<P>
|
||||
This set of functions provides a POSIX-style API to the PCRE regular expression
|
||||
package. See the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
documentation for a description of PCRE's native API, which contains additional
|
||||
functionality.
|
||||
</P>
|
||||
<P>
|
||||
The functions described here are just wrapper functions that ultimately call
|
||||
the PCRE native API. Their prototypes are defined in the <b>pcreposix.h</b>
|
||||
header file, and on Unix systems the library itself is called
|
||||
<b>pcreposix.a</b>, so can be accessed by adding <b>-lpcreposix</b> to the
|
||||
command for linking an application that uses them. Because the POSIX functions
|
||||
call the native ones, it is also necessary to add <b>-lpcre</b>.
|
||||
</P>
|
||||
<P>
|
||||
I have implemented only those option bits that can be reasonably mapped to PCRE
|
||||
native options. In addition, the options REG_EXTENDED and REG_NOSUB are defined
|
||||
with the value zero. They have no effect, but since programs that are written
|
||||
to the POSIX interface often use them, this makes it easier to slot in PCRE as
|
||||
a replacement library. Other POSIX options are not even defined.
|
||||
</P>
|
||||
<P>
|
||||
When PCRE is called via these functions, it is only the API that is POSIX-like
|
||||
in style. The syntax and semantics of the regular expressions themselves are
|
||||
still those of Perl, subject to the setting of various PCRE options, as
|
||||
described below. "POSIX-like in style" means that the API approximates to the
|
||||
POSIX definition; it is not fully POSIX-compatible, and in multi-byte encoding
|
||||
domains it is probably even less compatible.
|
||||
</P>
|
||||
<P>
|
||||
The header for these functions is supplied as <b>pcreposix.h</b> to avoid any
|
||||
potential clash with other POSIX libraries. It can, of course, be renamed or
|
||||
aliased as <b>regex.h</b>, which is the "correct" name. It provides two
|
||||
structure types, <i>regex_t</i> for compiled internal forms, and
|
||||
<i>regmatch_t</i> for returning captured substrings. It also defines some
|
||||
constants whose names start with "REG_"; these are used for setting options and
|
||||
identifying error codes.
|
||||
</P>
|
||||
<P>
|
||||
</P>
|
||||
<br><a name="SEC3" href="#TOC1">COMPILING A PATTERN</a><br>
|
||||
<P>
|
||||
The function <b>regcomp()</b> is called to compile a pattern into an
|
||||
internal form. The pattern is a C string terminated by a binary zero, and
|
||||
is passed in the argument <i>pattern</i>. The <i>preg</i> argument is a pointer
|
||||
to a <b>regex_t</b> structure that is used as a base for storing information
|
||||
about the compiled expression.
|
||||
</P>
|
||||
<P>
|
||||
The argument <i>cflags</i> is either zero, or contains one or more of the bits
|
||||
defined by the following macros:
|
||||
<pre>
|
||||
REG_ICASE
|
||||
</pre>
|
||||
The PCRE_CASELESS option is set when the expression is passed for compilation
|
||||
to the native function.
|
||||
<pre>
|
||||
REG_NEWLINE
|
||||
</pre>
|
||||
The PCRE_MULTILINE option is set when the expression is passed for compilation
|
||||
to the native function. Note that this does <i>not</i> mimic the defined POSIX
|
||||
behaviour for REG_NEWLINE (see the following section).
|
||||
</P>
|
||||
<P>
|
||||
In the absence of these flags, no options are passed to the native function.
|
||||
This means the the regex is compiled with PCRE default semantics. In
|
||||
particular, the way it handles newline characters in the subject string is the
|
||||
Perl way, not the POSIX way. Note that setting PCRE_MULTILINE has only
|
||||
<i>some</i> of the effects specified for REG_NEWLINE. It does not affect the way
|
||||
newlines are matched by . (they aren't) or by a negative class such as [^a]
|
||||
(they are).
|
||||
</P>
|
||||
<P>
|
||||
The yield of <b>regcomp()</b> is zero on success, and non-zero otherwise. The
|
||||
<i>preg</i> structure is filled in on success, and one member of the structure
|
||||
is public: <i>re_nsub</i> contains the number of capturing subpatterns in
|
||||
the regular expression. Various error codes are defined in the header file.
|
||||
</P>
|
||||
<br><a name="SEC4" href="#TOC1">MATCHING NEWLINE CHARACTERS</a><br>
|
||||
<P>
|
||||
This area is not simple, because POSIX and Perl take different views of things.
|
||||
It is not possible to get PCRE to obey POSIX semantics, but then PCRE was never
|
||||
intended to be a POSIX engine. The following table lists the different
|
||||
possibilities for matching newline characters in PCRE:
|
||||
<pre>
|
||||
Default Change with
|
||||
|
||||
. matches newline no PCRE_DOTALL
|
||||
newline matches [^a] yes not changeable
|
||||
$ matches \n at end yes PCRE_DOLLARENDONLY
|
||||
$ matches \n in middle no PCRE_MULTILINE
|
||||
^ matches \n in middle no PCRE_MULTILINE
|
||||
</pre>
|
||||
This is the equivalent table for POSIX:
|
||||
<pre>
|
||||
Default Change with
|
||||
|
||||
. matches newline yes REG_NEWLINE
|
||||
newline matches [^a] yes REG_NEWLINE
|
||||
$ matches \n at end no REG_NEWLINE
|
||||
$ matches \n in middle no REG_NEWLINE
|
||||
^ matches \n in middle no REG_NEWLINE
|
||||
</pre>
|
||||
PCRE's behaviour is the same as Perl's, except that there is no equivalent for
|
||||
PCRE_DOLLAR_ENDONLY in Perl. In both PCRE and Perl, there is no way to stop
|
||||
newline from matching [^a].
|
||||
</P>
|
||||
<P>
|
||||
The default POSIX newline handling can be obtained by setting PCRE_DOTALL and
|
||||
PCRE_DOLLAR_ENDONLY, but there is no way to make PCRE behave exactly as for the
|
||||
REG_NEWLINE action.
|
||||
</P>
|
||||
<br><a name="SEC5" href="#TOC1">MATCHING A PATTERN</a><br>
|
||||
<P>
|
||||
The function <b>regexec()</b> is called to match a compiled pattern <i>preg</i>
|
||||
against a given <i>string</i>, which is terminated by a zero byte, subject to
|
||||
the options in <i>eflags</i>. These can be:
|
||||
<pre>
|
||||
REG_NOTBOL
|
||||
</pre>
|
||||
The PCRE_NOTBOL option is set when calling the underlying PCRE matching
|
||||
function.
|
||||
<pre>
|
||||
REG_NOTEOL
|
||||
</pre>
|
||||
The PCRE_NOTEOL option is set when calling the underlying PCRE matching
|
||||
function.
|
||||
</P>
|
||||
<P>
|
||||
The portion of the string that was matched, and also any captured substrings,
|
||||
are returned via the <i>pmatch</i> argument, which points to an array of
|
||||
<i>nmatch</i> structures of type <i>regmatch_t</i>, containing the members
|
||||
<i>rm_so</i> and <i>rm_eo</i>. These contain the offset to the first character of
|
||||
each substring and the offset to the first character after the end of each
|
||||
substring, respectively. The 0th element of the vector relates to the entire
|
||||
portion of <i>string</i> that was matched; subsequent elements relate to the
|
||||
capturing subpatterns of the regular expression. Unused entries in the array
|
||||
have both structure members set to -1.
|
||||
</P>
|
||||
<P>
|
||||
A successful match yields a zero return; various error codes are defined in the
|
||||
header file, of which REG_NOMATCH is the "expected" failure code.
|
||||
</P>
|
||||
<br><a name="SEC6" href="#TOC1">ERROR MESSAGES</a><br>
|
||||
<P>
|
||||
The <b>regerror()</b> function maps a non-zero errorcode from either
|
||||
<b>regcomp()</b> or <b>regexec()</b> to a printable message. If <i>preg</i> is not
|
||||
NULL, the error should have arisen from the use of that structure. A message
|
||||
terminated by a binary zero is placed in <i>errbuf</i>. The length of the
|
||||
message, including the zero, is limited to <i>errbuf_size</i>. The yield of the
|
||||
function is the size of buffer needed to hold the whole message.
|
||||
</P>
|
||||
<br><a name="SEC7" href="#TOC1">MEMORY USAGE</a><br>
|
||||
<P>
|
||||
Compiling a regular expression causes memory to be allocated and associated
|
||||
with the <i>preg</i> structure. The function <b>regfree()</b> frees all such
|
||||
memory, after which <i>preg</i> may no longer be used as a compiled expression.
|
||||
</P>
|
||||
<br><a name="SEC8" href="#TOC1">AUTHOR</a><br>
|
||||
<P>
|
||||
Philip Hazel <[email protected]>
|
||||
<br>
|
||||
University Computing Service,
|
||||
<br>
|
||||
Cambridge CB2 3QG, England.
|
||||
</P>
|
||||
<P>
|
||||
Last updated: 07 September 2004
|
||||
<br>
|
||||
Copyright © 1997-2004 University of Cambridge.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+133
@@ -0,0 +1,133 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcreprecompile specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcreprecompile man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<ul>
|
||||
<li><a name="TOC1" href="#SEC1">SAVING AND RE-USING PRECOMPILED PCRE PATTERNS</a>
|
||||
<li><a name="TOC2" href="#SEC2">SAVING A COMPILED PATTERN</a>
|
||||
<li><a name="TOC3" href="#SEC3">RE-USING A PRECOMPILED PATTERN</a>
|
||||
<li><a name="TOC4" href="#SEC4">COMPATIBILITY WITH DIFFERENT PCRE RELEASES</a>
|
||||
</ul>
|
||||
<br><a name="SEC1" href="#TOC1">SAVING AND RE-USING PRECOMPILED PCRE PATTERNS</a><br>
|
||||
<P>
|
||||
If you are running an application that uses a large number of regular
|
||||
expression patterns, it may be useful to store them in a precompiled form
|
||||
instead of having to compile them every time the application is run.
|
||||
If you are not using any private character tables (see the
|
||||
<a href="pcre_maketables.html"><b>pcre_maketables()</b></a>
|
||||
documentation), this is relatively straightforward. If you are using private
|
||||
tables, it is a little bit more complicated.
|
||||
</P>
|
||||
<P>
|
||||
If you save compiled patterns to a file, you can copy them to a different host
|
||||
and run them there. This works even if the new host has the opposite endianness
|
||||
to the one on which the patterns were compiled. There may be a small
|
||||
performance penalty, but it should be insignificant.
|
||||
</P>
|
||||
<br><a name="SEC2" href="#TOC1">SAVING A COMPILED PATTERN</a><br>
|
||||
<P>
|
||||
The value returned by <b>pcre_compile()</b> points to a single block of memory
|
||||
that holds the compiled pattern and associated data. You can find the length of
|
||||
this block in bytes by calling <b>pcre_fullinfo()</b> with an argument of
|
||||
PCRE_INFO_SIZE. You can then save the data in any appropriate manner. Here is
|
||||
sample code that compiles a pattern and writes it to a file. It assumes that
|
||||
the variable <i>fd</i> refers to a file that is open for output:
|
||||
<pre>
|
||||
int erroroffset, rc, size;
|
||||
char *error;
|
||||
pcre *re;
|
||||
|
||||
re = pcre_compile("my pattern", 0, &error, &erroroffset, NULL);
|
||||
if (re == NULL) { ... handle errors ... }
|
||||
rc = pcre_fullinfo(re, NULL, PCRE_INFO_SIZE, &size);
|
||||
if (rc < 0) { ... handle errors ... }
|
||||
rc = fwrite(re, 1, size, fd);
|
||||
if (rc != size) { ... handle errors ... }
|
||||
</pre>
|
||||
In this example, the bytes that comprise the compiled pattern are copied
|
||||
exactly. Note that this is binary data that may contain any of the 256 possible
|
||||
byte values. On systems that make a distinction between binary and non-binary
|
||||
data, be sure that the file is opened for binary output.
|
||||
</P>
|
||||
<P>
|
||||
If you want to write more than one pattern to a file, you will have to devise a
|
||||
way of separating them. For binary data, preceding each pattern with its length
|
||||
is probably the most straightforward approach. Another possibility is to write
|
||||
out the data in hexadecimal instead of binary, one pattern to a line.
|
||||
</P>
|
||||
<P>
|
||||
Saving compiled patterns in a file is only one possible way of storing them for
|
||||
later use. They could equally well be saved in a database, or in the memory of
|
||||
some daemon process that passes them via sockets to the processes that want
|
||||
them.
|
||||
</P>
|
||||
<P>
|
||||
If the pattern has been studied, it is also possible to save the study data in
|
||||
a similar way to the compiled pattern itself. When studying generates
|
||||
additional information, <b>pcre_study()</b> returns a pointer to a
|
||||
<b>pcre_extra</b> data block. Its format is defined in the
|
||||
<a href="pcreapi.html#extradata">section on matching a pattern</a>
|
||||
in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
documentation. The <i>study_data</i> field points to the binary study data, and
|
||||
this is what you must save (not the <b>pcre_extra</b> block itself). The length
|
||||
of the study data can be obtained by calling <b>pcre_fullinfo()</b> with an
|
||||
argument of PCRE_INFO_STUDYSIZE. Remember to check that <b>pcre_study()</b> did
|
||||
return a non-NULL value before trying to save the study data.
|
||||
</P>
|
||||
<br><a name="SEC3" href="#TOC1">RE-USING A PRECOMPILED PATTERN</a><br>
|
||||
<P>
|
||||
Re-using a precompiled pattern is straightforward. Having reloaded it into main
|
||||
memory, you pass its pointer to <b>pcre_exec()</b> in the usual way. This should
|
||||
work even on another host, and even if that host has the opposite endianness to
|
||||
the one where the pattern was compiled.
|
||||
</P>
|
||||
<P>
|
||||
However, if you passed a pointer to custom character tables when the pattern
|
||||
was compiled (the <i>tableptr</i> argument of <b>pcre_compile()</b>), you must
|
||||
now pass a similar pointer to <b>pcre_exec()</b>, because the value saved with
|
||||
the compiled pattern will obviously be nonsense. A field in a
|
||||
<b>pcre_extra()</b> block is used to pass this data, as described in the
|
||||
<a href="pcreapi.html#extradata">section on matching a pattern</a>
|
||||
in the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
documentation.
|
||||
</P>
|
||||
<P>
|
||||
If you did not provide custom character tables when the pattern was compiled,
|
||||
the pointer in the compiled pattern is NULL, which causes <b>pcre_exec()</b> to
|
||||
use PCRE's internal tables. Thus, you do not need to take any special action at
|
||||
run time in this case.
|
||||
</P>
|
||||
<P>
|
||||
If you saved study data with the compiled pattern, you need to create your own
|
||||
<b>pcre_extra</b> data block and set the <i>study_data</i> field to point to the
|
||||
reloaded study data. You must also set the PCRE_EXTRA_STUDY_DATA bit in the
|
||||
<i>flags</i> field to indicate that study data is present. Then pass the
|
||||
<b>pcre_extra</b> block to <b>pcre_exec()</b> in the usual way.
|
||||
</P>
|
||||
<br><a name="SEC4" href="#TOC1">COMPATIBILITY WITH DIFFERENT PCRE RELEASES</a><br>
|
||||
<P>
|
||||
The layout of the control block that is at the start of the data that makes up
|
||||
a compiled pattern was changed for release 5.0. If you have any saved patterns
|
||||
that were compiled with previous releases (not a facility that was previously
|
||||
advertised), you will have to recompile them for release 5.0. However, from now
|
||||
on, it should be possible to make changes in a compabible manner.
|
||||
</P>
|
||||
<P>
|
||||
Last updated: 10 September 2004
|
||||
<br>
|
||||
Copyright © 1997-2004 University of Cambridge.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+81
@@ -0,0 +1,81 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcresample specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcresample man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<br><b>
|
||||
PCRE SAMPLE PROGRAM
|
||||
</b><br>
|
||||
<P>
|
||||
A simple, complete demonstration program, to get you started with using PCRE,
|
||||
is supplied in the file <i>pcredemo.c</i> in the PCRE distribution.
|
||||
</P>
|
||||
<P>
|
||||
The program compiles the regular expression that is its first argument, and
|
||||
matches it against the subject string in its second argument. No PCRE options
|
||||
are set, and default character tables are used. If matching succeeds, the
|
||||
program outputs the portion of the subject that matched, together with the
|
||||
contents of any captured substrings.
|
||||
</P>
|
||||
<P>
|
||||
If the -g option is given on the command line, the program then goes on to
|
||||
check for further matches of the same regular expression in the same subject
|
||||
string. The logic is a little bit tricky because of the possibility of matching
|
||||
an empty string. Comments in the code explain what is going on.
|
||||
</P>
|
||||
<P>
|
||||
If PCRE is installed in the standard include and library directories for your
|
||||
system, you should be able to compile the demonstration program using this
|
||||
command:
|
||||
<pre>
|
||||
gcc -o pcredemo pcredemo.c -lpcre
|
||||
</pre>
|
||||
If PCRE is installed elsewhere, you may need to add additional options to the
|
||||
command line. For example, on a Unix-like system that has PCRE installed in
|
||||
<i>/usr/local</i>, you can compile the demonstration program using a command
|
||||
like this:
|
||||
<pre>
|
||||
gcc -o pcredemo -I/usr/local/include pcredemo.c -L/usr/local/lib -lpcre
|
||||
</pre>
|
||||
Once you have compiled the demonstration program, you can run simple tests like
|
||||
this:
|
||||
<pre>
|
||||
./pcredemo 'cat|dog' 'the cat sat on the mat'
|
||||
./pcredemo -g 'cat|dog' 'the dog sat on the cat'
|
||||
</pre>
|
||||
Note that there is a much more comprehensive test program, called
|
||||
<a href="pcretest.html"><b>pcretest</b>,</a>
|
||||
which supports many more facilities for testing regular expressions and the
|
||||
PCRE library. The <b>pcredemo</b> program is provided as a simple coding
|
||||
example.
|
||||
</P>
|
||||
<P>
|
||||
On some operating systems (e.g. Solaris), when PCRE is not installed in the
|
||||
standard library directory, you may get an error like this when you try to run
|
||||
<b>pcredemo</b>:
|
||||
<pre>
|
||||
ld.so.1: a.out: fatal: libpcre.so.0: open failed: No such file or directory
|
||||
</pre>
|
||||
This is caused by the way shared library support works on those systems. You
|
||||
need to add
|
||||
<pre>
|
||||
-R/usr/local/lib
|
||||
</pre>
|
||||
(for example) to the compile command to get round this problem.
|
||||
</P>
|
||||
<P>
|
||||
Last updated: 09 September 2004
|
||||
<br>
|
||||
Copyright © 1997-2004 University of Cambridge.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
+495
@@ -0,0 +1,495 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>pcretest specification</title>
|
||||
</head>
|
||||
<body bgcolor="#FFFFFF" text="#00005A" link="#0066FF" alink="#3399FF" vlink="#2222BB">
|
||||
<h1>pcretest man page</h1>
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
<p>
|
||||
This page is part of the PCRE HTML documentation. It was generated automatically
|
||||
from the original man page. If there is any nonsense in it, please consult the
|
||||
man page, in case the conversion went wrong.
|
||||
<br>
|
||||
<ul>
|
||||
<li><a name="TOC1" href="#SEC1">SYNOPSIS</a>
|
||||
<li><a name="TOC2" href="#SEC2">OPTIONS</a>
|
||||
<li><a name="TOC3" href="#SEC3">DESCRIPTION</a>
|
||||
<li><a name="TOC4" href="#SEC4">PATTERN MODIFIERS</a>
|
||||
<li><a name="TOC5" href="#SEC5">DATA LINES</a>
|
||||
<li><a name="TOC6" href="#SEC6">OUTPUT FROM PCRETEST</a>
|
||||
<li><a name="TOC7" href="#SEC7">CALLOUTS</a>
|
||||
<li><a name="TOC8" href="#SEC8">SAVING AND RELOADING COMPILED PATTERNS</a>
|
||||
<li><a name="TOC9" href="#SEC9">AUTHOR</a>
|
||||
</ul>
|
||||
<br><a name="SEC1" href="#TOC1">SYNOPSIS</a><br>
|
||||
<P>
|
||||
<b>pcretest [-C] [-d] [-i] [-m] [-o osize] [-p] [-t] [source]</b>
|
||||
<b>[destination]</b>
|
||||
</P>
|
||||
<P>
|
||||
<b>pcretest</b> was written as a test program for the PCRE regular expression
|
||||
library itself, but it can also be used for experimenting with regular
|
||||
expressions. This document describes the features of the test program; for
|
||||
details of the regular expressions themselves, see the
|
||||
<a href="pcrepattern.html"><b>pcrepattern</b></a>
|
||||
documentation. For details of the PCRE library function calls and their
|
||||
options, see the
|
||||
<a href="pcreapi.html"><b>pcreapi</b></a>
|
||||
documentation.
|
||||
</P>
|
||||
<br><a name="SEC2" href="#TOC1">OPTIONS</a><br>
|
||||
<P>
|
||||
<b>-C</b>
|
||||
Output the version number of the PCRE library, and all available information
|
||||
about the optional features that are included, and then exit.
|
||||
</P>
|
||||
<P>
|
||||
<b>-d</b>
|
||||
Behave as if each regex had the <b>/D</b> (debug) modifier; the internal
|
||||
form is output after compilation.
|
||||
</P>
|
||||
<P>
|
||||
<b>-i</b>
|
||||
Behave as if each regex had the <b>/I</b> modifier; information about the
|
||||
compiled pattern is given after compilation.
|
||||
</P>
|
||||
<P>
|
||||
<b>-m</b>
|
||||
Output the size of each compiled pattern after it has been compiled. This is
|
||||
equivalent to adding <b>/M</b> to each regular expression. For compatibility
|
||||
with earlier versions of pcretest, <b>-s</b> is a synonym for <b>-m</b>.
|
||||
</P>
|
||||
<P>
|
||||
<b>-o</b> <i>osize</i>
|
||||
Set the number of elements in the output vector that is used when calling
|
||||
<b>pcre_exec()</b> to be <i>osize</i>. The default value is 45, which is enough
|
||||
for 14 capturing subexpressions. The vector size can be changed for individual
|
||||
matching calls by including \O in the data line (see below).
|
||||
</P>
|
||||
<P>
|
||||
<b>-p</b>
|
||||
Behave as if each regex has <b>/P</b> modifier; the POSIX wrapper API is used
|
||||
to call PCRE. None of the other options has any effect when <b>-p</b> is set.
|
||||
</P>
|
||||
<P>
|
||||
<b>-t</b>
|
||||
Run each compile, study, and match many times with a timer, and output
|
||||
resulting time per compile or match (in milliseconds). Do not set <b>-m</b> with
|
||||
<b>-t</b>, because you will then get the size output a zillion times, and the
|
||||
timing will be distorted.
|
||||
</P>
|
||||
<br><a name="SEC3" href="#TOC1">DESCRIPTION</a><br>
|
||||
<P>
|
||||
If <b>pcretest</b> is given two filename arguments, it reads from the first and
|
||||
writes to the second. If it is given only one filename argument, it reads from
|
||||
that file and writes to stdout. Otherwise, it reads from stdin and writes to
|
||||
stdout, and prompts for each line of input, using "re>" to prompt for regular
|
||||
expressions, and "data>" to prompt for data lines.
|
||||
</P>
|
||||
<P>
|
||||
The program handles any number of sets of input on a single input file. Each
|
||||
set starts with a regular expression, and continues with any number of data
|
||||
lines to be matched against the pattern.
|
||||
</P>
|
||||
<P>
|
||||
Each data line is matched separately and independently. If you want to do
|
||||
multiple-line matches, you have to use the \n escape sequence in a single line
|
||||
of input to encode the newline characters. The maximum length of data line is
|
||||
30,000 characters.
|
||||
</P>
|
||||
<P>
|
||||
An empty line signals the end of the data lines, at which point a new regular
|
||||
expression is read. The regular expressions are given enclosed in any
|
||||
non-alphanumeric delimiters other than backslash, for example
|
||||
<pre>
|
||||
/(a|bc)x+yz/
|
||||
</pre>
|
||||
White space before the initial delimiter is ignored. A regular expression may
|
||||
be continued over several input lines, in which case the newline characters are
|
||||
included within it. It is possible to include the delimiter within the pattern
|
||||
by escaping it, for example
|
||||
<pre>
|
||||
/abc\/def/
|
||||
</pre>
|
||||
If you do so, the escape and the delimiter form part of the pattern, but since
|
||||
delimiters are always non-alphanumeric, this does not affect its interpretation.
|
||||
If the terminating delimiter is immediately followed by a backslash, for
|
||||
example,
|
||||
<pre>
|
||||
/abc/\
|
||||
</pre>
|
||||
then a backslash is added to the end of the pattern. This is done to provide a
|
||||
way of testing the error condition that arises if a pattern finishes with a
|
||||
backslash, because
|
||||
<pre>
|
||||
/abc\/
|
||||
</pre>
|
||||
is interpreted as the first line of a pattern that starts with "abc/", causing
|
||||
pcretest to read the next line as a continuation of the regular expression.
|
||||
</P>
|
||||
<br><a name="SEC4" href="#TOC1">PATTERN MODIFIERS</a><br>
|
||||
<P>
|
||||
A pattern may be followed by any number of modifiers, which are mostly single
|
||||
characters. Following Perl usage, these are referred to below as, for example,
|
||||
"the <b>/i</b> modifier", even though the delimiter of the pattern need not
|
||||
always be a slash, and no slash is used when writing modifiers. Whitespace may
|
||||
appear between the final pattern delimiter and the first modifier, and between
|
||||
the modifiers themselves.
|
||||
</P>
|
||||
<P>
|
||||
The <b>/i</b>, <b>/m</b>, <b>/s</b>, and <b>/x</b> modifiers set the PCRE_CASELESS,
|
||||
PCRE_MULTILINE, PCRE_DOTALL, or PCRE_EXTENDED options, respectively, when
|
||||
<b>pcre_compile()</b> is called. These four modifier letters have the same
|
||||
effect as they do in Perl. For example:
|
||||
<pre>
|
||||
/caseless/i
|
||||
</pre>
|
||||
The following table shows additional modifiers for setting PCRE options that do
|
||||
not correspond to anything in Perl:
|
||||
<pre>
|
||||
<b>/A</b> PCRE_ANCHORED
|
||||
<b>/C</b> PCRE_AUTO_CALLOUT
|
||||
<b>/E</b> PCRE_DOLLAR_ENDONLY
|
||||
<b>/N</b> PCRE_NO_AUTO_CAPTURE
|
||||
<b>/U</b> PCRE_UNGREEDY
|
||||
<b>/X</b> PCRE_EXTRA
|
||||
</pre>
|
||||
Searching for all possible matches within each subject string can be requested
|
||||
by the <b>/g</b> or <b>/G</b> modifier. After finding a match, PCRE is called
|
||||
again to search the remainder of the subject string. The difference between
|
||||
<b>/g</b> and <b>/G</b> is that the former uses the <i>startoffset</i> argument to
|
||||
<b>pcre_exec()</b> to start searching at a new point within the entire string
|
||||
(which is in effect what Perl does), whereas the latter passes over a shortened
|
||||
substring. This makes a difference to the matching process if the pattern
|
||||
begins with a lookbehind assertion (including \b or \B).
|
||||
</P>
|
||||
<P>
|
||||
If any call to <b>pcre_exec()</b> in a <b>/g</b> or <b>/G</b> sequence matches an
|
||||
empty string, the next call is done with the PCRE_NOTEMPTY and PCRE_ANCHORED
|
||||
flags set in order to search for another, non-empty, match at the same point.
|
||||
If this second match fails, the start offset is advanced by one, and the normal
|
||||
match is retried. This imitates the way Perl handles such cases when using the
|
||||
<b>/g</b> modifier or the <b>split()</b> function.
|
||||
</P>
|
||||
<P>
|
||||
There are yet more modifiers for controlling the way <b>pcretest</b>
|
||||
operates.
|
||||
</P>
|
||||
<P>
|
||||
The <b>/+</b> modifier requests that as well as outputting the substring that
|
||||
matched the entire pattern, pcretest should in addition output the remainder of
|
||||
the subject string. This is useful for tests where the subject contains
|
||||
multiple copies of the same substring.
|
||||
</P>
|
||||
<P>
|
||||
The <b>/L</b> modifier must be followed directly by the name of a locale, for
|
||||
example,
|
||||
<pre>
|
||||
/pattern/Lfr_FR
|
||||
</pre>
|
||||
For this reason, it must be the last modifier. The given locale is set,
|
||||
<b>pcre_maketables()</b> is called to build a set of character tables for the
|
||||
locale, and this is then passed to <b>pcre_compile()</b> when compiling the
|
||||
regular expression. Without an <b>/L</b> modifier, NULL is passed as the tables
|
||||
pointer; that is, <b>/L</b> applies only to the expression on which it appears.
|
||||
</P>
|
||||
<P>
|
||||
The <b>/I</b> modifier requests that <b>pcretest</b> output information about the
|
||||
compiled pattern (whether it is anchored, has a fixed first character, and
|
||||
so on). It does this by calling <b>pcre_fullinfo()</b> after compiling a
|
||||
pattern. If the pattern is studied, the results of that are also output.
|
||||
</P>
|
||||
<P>
|
||||
The <b>/D</b> modifier is a PCRE debugging feature, which also assumes <b>/I</b>.
|
||||
It causes the internal form of compiled regular expressions to be output after
|
||||
compilation. If the pattern was studied, the information returned is also
|
||||
output.
|
||||
</P>
|
||||
<P>
|
||||
The <b>/F</b> modifier causes <b>pcretest</b> to flip the byte order of the
|
||||
fields in the compiled pattern that contain 2-byte and 4-byte numbers. This
|
||||
facility is for testing the feature in PCRE that allows it to execute patterns
|
||||
that were compiled on a host with a different endianness. This feature is not
|
||||
available when the POSIX interface to PCRE is being used, that is, when the
|
||||
<b>/P</b> pattern modifier is specified. See also the section about saving and
|
||||
reloading compiled patterns below.
|
||||
</P>
|
||||
<P>
|
||||
The <b>/S</b> modifier causes <b>pcre_study()</b> to be called after the
|
||||
expression has been compiled, and the results used when the expression is
|
||||
matched.
|
||||
</P>
|
||||
<P>
|
||||
The <b>/M</b> modifier causes the size of memory block used to hold the compiled
|
||||
pattern to be output.
|
||||
</P>
|
||||
<P>
|
||||
The <b>/P</b> modifier causes <b>pcretest</b> to call PCRE via the POSIX wrapper
|
||||
API rather than its native API. When this is done, all other modifiers except
|
||||
<b>/i</b>, <b>/m</b>, and <b>/+</b> are ignored. REG_ICASE is set if <b>/i</b> is
|
||||
present, and REG_NEWLINE is set if <b>/m</b> is present. The wrapper functions
|
||||
force PCRE_DOLLAR_ENDONLY always, and PCRE_DOTALL unless REG_NEWLINE is set.
|
||||
</P>
|
||||
<P>
|
||||
The <b>/8</b> modifier causes <b>pcretest</b> to call PCRE with the PCRE_UTF8
|
||||
option set. This turns on support for UTF-8 character handling in PCRE,
|
||||
provided that it was compiled with this support enabled. This modifier also
|
||||
causes any non-printing characters in output strings to be printed using the
|
||||
\x{hh...} notation if they are valid UTF-8 sequences.
|
||||
</P>
|
||||
<P>
|
||||
If the <b>/?</b> modifier is used with <b>/8</b>, it causes <b>pcretest</b> to
|
||||
call <b>pcre_compile()</b> with the PCRE_NO_UTF8_CHECK option, to suppress the
|
||||
checking of the string for UTF-8 validity.
|
||||
</P>
|
||||
<br><a name="SEC5" href="#TOC1">DATA LINES</a><br>
|
||||
<P>
|
||||
Before each data line is passed to <b>pcre_exec()</b>, leading and trailing
|
||||
whitespace is removed, and it is then scanned for \ escapes. Some of these are
|
||||
pretty esoteric features, intended for checking out some of the more
|
||||
complicated features of PCRE. If you are just testing "ordinary" regular
|
||||
expressions, you probably don't need any of these. The following escapes are
|
||||
recognized:
|
||||
<pre>
|
||||
\a alarm (= BEL)
|
||||
\b backspace
|
||||
\e escape
|
||||
\f formfeed
|
||||
\n newline
|
||||
\r carriage return
|
||||
\t tab
|
||||
\v vertical tab
|
||||
\nnn octal character (up to 3 octal digits)
|
||||
\xhh hexadecimal character (up to 2 hex digits)
|
||||
\x{hh...} hexadecimal character, any number of digits in UTF-8 mode
|
||||
\A pass the PCRE_ANCHORED option to <b>pcre_exec()</b>
|
||||
\B pass the PCRE_NOTBOL option to <b>pcre_exec()</b>
|
||||
\Cdd call pcre_copy_substring() for substring dd after a successful match (number less than 32)
|
||||
\Cname call pcre_copy_named_substring() for substring "name" after a successful match (name termin-
|
||||
ated by next non alphanumeric character)
|
||||
\C+ show the current captured substrings at callout time
|
||||
\C- do not supply a callout function
|
||||
\C!n return 1 instead of 0 when callout number n is reached
|
||||
\C!n!m return 1 instead of 0 when callout number n is reached for the nth time
|
||||
\C*n pass the number n (may be negative) as callout data; this is used as the callout return value
|
||||
\Gdd call pcre_get_substring() for substring dd after a successful match (number less than 32)
|
||||
\Gname call pcre_get_named_substring() for substring "name" after a successful match (name termin-
|
||||
ated by next non-alphanumeric character)
|
||||
\L call pcre_get_substringlist() after a successful match
|
||||
\M discover the minimum MATCH_LIMIT setting
|
||||
\N pass the PCRE_NOTEMPTY option to <b>pcre_exec()</b>
|
||||
\Odd set the size of the output vector passed to <b>pcre_exec()</b> to dd (any number of digits)
|
||||
\P pass the PCRE_PARTIAL option to <b>pcre_exec()</b>
|
||||
\S output details of memory get/free calls during matching
|
||||
\Z pass the PCRE_NOTEOL option to <b>pcre_exec()</b>
|
||||
\? pass the PCRE_NO_UTF8_CHECK option to <b>pcre_exec()</b>
|
||||
\>dd start the match at offset dd (any number of digits);
|
||||
this sets the <i>startoffset</i> argument for <b>pcre_exec()</b>
|
||||
</pre>
|
||||
A backslash followed by anything else just escapes the anything else. If the
|
||||
very last character is a backslash, it is ignored. This gives a way of passing
|
||||
an empty line as data, since a real empty line terminates the data input.
|
||||
</P>
|
||||
<P>
|
||||
If \M is present, <b>pcretest</b> calls <b>pcre_exec()</b> several times, with
|
||||
different values in the <i>match_limit</i> field of the <b>pcre_extra</b> data
|
||||
structure, until it finds the minimum number that is needed for
|
||||
<b>pcre_exec()</b> to complete. This number is a measure of the amount of
|
||||
recursion and backtracking that takes place, and checking it out can be
|
||||
instructive. For most simple matches, the number is quite small, but for
|
||||
patterns with very large numbers of matching possibilities, it can become large
|
||||
very quickly with increasing length of subject string.
|
||||
</P>
|
||||
<P>
|
||||
When \O is used, the value specified may be higher or lower than the size set
|
||||
by the <b>-O</b> command line option (or defaulted to 45); \O applies only to
|
||||
the call of <b>pcre_exec()</b> for the line in which it appears.
|
||||
</P>
|
||||
<P>
|
||||
If the <b>/P</b> modifier was present on the pattern, causing the POSIX wrapper
|
||||
API to be used, only \B and \Z have any effect, causing REG_NOTBOL and
|
||||
REG_NOTEOL to be passed to <b>regexec()</b> respectively.
|
||||
</P>
|
||||
<P>
|
||||
The use of \x{hh...} to represent UTF-8 characters is not dependent on the use
|
||||
of the <b>/8</b> modifier on the pattern. It is recognized always. There may be
|
||||
any number of hexadecimal digits inside the braces. The result is from one to
|
||||
six bytes, encoded according to the UTF-8 rules.
|
||||
</P>
|
||||
<br><a name="SEC6" href="#TOC1">OUTPUT FROM PCRETEST</a><br>
|
||||
<P>
|
||||
When a match succeeds, pcretest outputs the list of captured substrings that
|
||||
<b>pcre_exec()</b> returns, starting with number 0 for the string that matched
|
||||
the whole pattern. Otherwise, it outputs "No match" or "Partial match"
|
||||
when <b>pcre_exec()</b> returns PCRE_ERROR_NOMATCH or PCRE_ERROR_PARTIAL,
|
||||
respectively, and otherwise the PCRE negative error number. Here is an example
|
||||
of an interactive pcretest run.
|
||||
<pre>
|
||||
$ pcretest
|
||||
PCRE version 5.00 07-Sep-2004
|
||||
|
||||
re> /^abc(\d+)/
|
||||
data> abc123
|
||||
0: abc123
|
||||
1: 123
|
||||
data> xyz
|
||||
No match
|
||||
</pre>
|
||||
If the strings contain any non-printing characters, they are output as \0x
|
||||
escapes, or as \x{...} escapes if the <b>/8</b> modifier was present on the
|
||||
pattern. If the pattern has the <b>/+</b> modifier, the output for substring 0
|
||||
is followed by the the rest of the subject string, identified by "0+" like
|
||||
this:
|
||||
<pre>
|
||||
re> /cat/+
|
||||
data> cataract
|
||||
0: cat
|
||||
0+ aract
|
||||
</pre>
|
||||
If the pattern has the <b>/g</b> or <b>/G</b> modifier, the results of successive
|
||||
matching attempts are output in sequence, like this:
|
||||
<pre>
|
||||
re> /\Bi(\w\w)/g
|
||||
data> Mississippi
|
||||
0: iss
|
||||
1: ss
|
||||
0: iss
|
||||
1: ss
|
||||
0: ipp
|
||||
1: pp
|
||||
</pre>
|
||||
"No match" is output only if the first match attempt fails.
|
||||
</P>
|
||||
<P>
|
||||
If any of the sequences <b>\C</b>, <b>\G</b>, or <b>\L</b> are present in a
|
||||
data line that is successfully matched, the substrings extracted by the
|
||||
convenience functions are output with C, G, or L after the string number
|
||||
instead of a colon. This is in addition to the normal full list. The string
|
||||
length (that is, the return from the extraction function) is given in
|
||||
parentheses after each string for <b>\C</b> and <b>\G</b>.
|
||||
</P>
|
||||
<P>
|
||||
Note that while patterns can be continued over several lines (a plain ">"
|
||||
prompt is used for continuations), data lines may not. However newlines can be
|
||||
included in data by means of the \n escape.
|
||||
</P>
|
||||
<br><a name="SEC7" href="#TOC1">CALLOUTS</a><br>
|
||||
<P>
|
||||
If the pattern contains any callout requests, <b>pcretest</b>'s callout function
|
||||
is called during matching. By default, it displays the callout number, the
|
||||
start and current positions in the text at the callout time, and the next
|
||||
pattern item to be tested. For example, the output
|
||||
<pre>
|
||||
--->pqrabcdef
|
||||
0 ^ ^ \d
|
||||
</pre>
|
||||
indicates that callout number 0 occurred for a match attempt starting at the
|
||||
fourth character of the subject string, when the pointer was at the seventh
|
||||
character of the data, and when the next pattern item was \d. Just one
|
||||
circumflex is output if the start and current positions are the same.
|
||||
</P>
|
||||
<P>
|
||||
Callouts numbered 255 are assumed to be automatic callouts, inserted as a
|
||||
result of the <b>/C</b> pattern modifier. In this case, instead of showing the
|
||||
callout number, the offset in the pattern, preceded by a plus, is output. For
|
||||
example:
|
||||
<pre>
|
||||
re> /\d?[A-E]\*/C
|
||||
data> E*
|
||||
--->E*
|
||||
+0 ^ \d?
|
||||
+3 ^ [A-E]
|
||||
+8 ^^ \*
|
||||
+10 ^ ^
|
||||
0: E*
|
||||
</pre>
|
||||
The callout function in <b>pcretest</b> returns zero (carry on matching) by
|
||||
default, but you can use an \C item in a data line (as described above) to
|
||||
change this.
|
||||
</P>
|
||||
<P>
|
||||
Inserting callouts can be helpful when using <b>pcretest</b> to check
|
||||
complicated regular expressions. For further information about callouts, see
|
||||
the
|
||||
<a href="pcrecallout.html"><b>pcrecallout</b></a>
|
||||
documentation.
|
||||
</P>
|
||||
<br><a name="SEC8" href="#TOC1">SAVING AND RELOADING COMPILED PATTERNS</a><br>
|
||||
<P>
|
||||
The facilities described in this section are not available when the POSIX
|
||||
inteface to PCRE is being used, that is, when the <b>/P</b> pattern modifier is
|
||||
specified.
|
||||
</P>
|
||||
<P>
|
||||
When the POSIX interface is not in use, you can cause <b>pcretest</b> to write a
|
||||
compiled pattern to a file, by following the modifiers with > and a file name.
|
||||
For example:
|
||||
<pre>
|
||||
/pattern/im >/some/file
|
||||
</pre>
|
||||
See the
|
||||
<a href="pcreprecompile.html"><b>pcreprecompile</b></a>
|
||||
documentation for a discussion about saving and re-using compiled patterns.
|
||||
</P>
|
||||
<P>
|
||||
The data that is written is binary. The first eight bytes are the length of the
|
||||
compiled pattern data followed by the length of the optional study data, each
|
||||
written as four bytes in big-endian order (most significant byte first). If
|
||||
there is no study data (either the pattern was not studied, or studying did not
|
||||
return any data), the second length is zero. The lengths are followed by an
|
||||
exact copy of the compiled pattern. If there is additional study data, this
|
||||
follows immediately after the compiled pattern. After writing the file,
|
||||
<b>pcretest</b> expects to read a new pattern.
|
||||
</P>
|
||||
<P>
|
||||
A saved pattern can be reloaded into <b>pcretest</b> by specifing < and a file
|
||||
name instead of a pattern. The name of the file must not contain a < character,
|
||||
as otherwise <b>pcretest</b> will interpret the line as a pattern delimited by <
|
||||
characters.
|
||||
For example:
|
||||
<pre>
|
||||
re> </some/file
|
||||
Compiled regex loaded from /some/file
|
||||
No study data
|
||||
</pre>
|
||||
When the pattern has been loaded, <b>pcretest</b> proceeds to read data lines in
|
||||
the usual way.
|
||||
</P>
|
||||
<P>
|
||||
You can copy a file written by <b>pcretest</b> to a different host and reload it
|
||||
there, even if the new host has opposite endianness to the one on which the
|
||||
pattern was compiled. For example, you can compile on an i86 machine and run on
|
||||
a SPARC machine.
|
||||
</P>
|
||||
<P>
|
||||
File names for saving and reloading can be absolute or relative, but note that
|
||||
the shell facility of expanding a file name that starts with a tilde (~) is not
|
||||
available.
|
||||
</P>
|
||||
<P>
|
||||
The ability to save and reload files in <b>pcretest</b> is intended for testing
|
||||
and experimentation. It is not intended for production use because only a
|
||||
single pattern can be written to a file. Furthermore, there is no facility for
|
||||
supplying custom character tables for use with a reloaded pattern. If the
|
||||
original pattern was compiled with custom tables, an attempt to match a subject
|
||||
string using a reloaded pattern is likely to cause <b>pcretest</b> to crash.
|
||||
Finally, if you attempt to load a file that is not in the correct format, the
|
||||
result is undefined.
|
||||
</P>
|
||||
<br><a name="SEC9" href="#TOC1">AUTHOR</a><br>
|
||||
<P>
|
||||
Philip Hazel <[email protected]>
|
||||
<br>
|
||||
University Computing Service,
|
||||
<br>
|
||||
Cambridge CB2 3QG, England.
|
||||
</P>
|
||||
<P>
|
||||
Last updated: 10 September 2004
|
||||
<br>
|
||||
Copyright © 1997-2004 University of Cambridge.
|
||||
<p>
|
||||
Return to the <a href="index.html">PCRE index page</a>.
|
||||
</p>
|
||||
Vendored
+204
@@ -0,0 +1,204 @@
|
||||
.TH PCRE 3
|
||||
.SH NAME
|
||||
PCRE - Perl-compatible regular expressions
|
||||
.SH INTRODUCTION
|
||||
.rs
|
||||
.sp
|
||||
The PCRE library is a set of functions that implement regular expression
|
||||
pattern matching using the same syntax and semantics as Perl, with just a few
|
||||
differences. The current implementation of PCRE (release 5.x) corresponds
|
||||
approximately with Perl 5.8, including support for UTF-8 encoded strings and
|
||||
Unicode general category properties. However, this support has to be explicitly
|
||||
enabled; it is not the default.
|
||||
.P
|
||||
PCRE is written in C and released as a C library. A number of people have
|
||||
written wrappers and interfaces of various kinds. A C++ class is included in
|
||||
these contributions, which can be found in the \fIContrib\fR directory at the
|
||||
primary FTP site, which is:
|
||||
.sp
|
||||
.\" HTML <a href="ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre">
|
||||
.\" </a>
|
||||
ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre
|
||||
.P
|
||||
Details of exactly which Perl regular expression features are and are not
|
||||
supported by PCRE are given in separate documents. See the
|
||||
.\" HREF
|
||||
\fBpcrepattern\fR
|
||||
.\"
|
||||
and
|
||||
.\" HREF
|
||||
\fBpcrecompat\fR
|
||||
.\"
|
||||
pages.
|
||||
.P
|
||||
Some features of PCRE can be included, excluded, or changed when the library is
|
||||
built. The
|
||||
.\" HREF
|
||||
\fBpcre_config()\fR
|
||||
.\"
|
||||
function makes it possible for a client to discover which features are
|
||||
available. The features themselves are described in the
|
||||
.\" HREF
|
||||
\fBpcrebuild\fP
|
||||
.\"
|
||||
page. Documentation about building PCRE for various operating systems can be
|
||||
found in the \fBREADME\fP file in the source distribution.
|
||||
.
|
||||
.
|
||||
.SH "USER DOCUMENTATION"
|
||||
.rs
|
||||
.sp
|
||||
The user documentation for PCRE comprises a number of different sections. In
|
||||
the "man" format, each of these is a separate "man page". In the HTML format,
|
||||
each is a separate page, linked from the index page. In the plain text format,
|
||||
all the sections are concatenated, for ease of searching. The sections are as
|
||||
follows:
|
||||
.sp
|
||||
pcre this document
|
||||
pcreapi details of PCRE's native API
|
||||
pcrebuild options for building PCRE
|
||||
pcrecallout details of the callout feature
|
||||
pcrecompat discussion of Perl compatibility
|
||||
pcregrep description of the \fBpcregrep\fP command
|
||||
pcrepartial details of the partial matching facility
|
||||
.\" JOIN
|
||||
pcrepattern syntax and semantics of supported
|
||||
regular expressions
|
||||
pcreperform discussion of performance issues
|
||||
pcreposix the POSIX-compatible API
|
||||
pcreprecompile details of saving and re-using precompiled patterns
|
||||
pcresample discussion of the sample program
|
||||
pcretest description of the \fBpcretest\fP testing command
|
||||
.sp
|
||||
In addition, in the "man" and HTML formats, there is a short page for each
|
||||
library function, listing its arguments and results.
|
||||
.
|
||||
.
|
||||
.SH LIMITATIONS
|
||||
.rs
|
||||
.sp
|
||||
There are some size limitations in PCRE but it is hoped that they will never in
|
||||
practice be relevant.
|
||||
.P
|
||||
The maximum length of a compiled pattern is 65539 (sic) bytes if PCRE is
|
||||
compiled with the default internal linkage size of 2. If you want to process
|
||||
regular expressions that are truly enormous, you can compile PCRE with an
|
||||
internal linkage size of 3 or 4 (see the \fBREADME\fP file in the source
|
||||
distribution and the
|
||||
.\" HREF
|
||||
\fBpcrebuild\fP
|
||||
.\"
|
||||
documentation for details). In these cases the limit is substantially larger.
|
||||
However, the speed of execution will be slower.
|
||||
.P
|
||||
All values in repeating quantifiers must be less than 65536.
|
||||
The maximum number of capturing subpatterns is 65535.
|
||||
.P
|
||||
There is no limit to the number of non-capturing subpatterns, but the maximum
|
||||
depth of nesting of all kinds of parenthesized subpattern, including capturing
|
||||
subpatterns, assertions, and other types of subpattern, is 200.
|
||||
.P
|
||||
The maximum length of a subject string is the largest positive number that an
|
||||
integer variable can hold. However, PCRE uses recursion to handle subpatterns
|
||||
and indefinite repetition. This means that the available stack space may limit
|
||||
the size of a subject string that can be processed by certain patterns.
|
||||
.sp
|
||||
.\" HTML <a name="utf8support"></a>
|
||||
.
|
||||
.
|
||||
.SH "UTF-8 AND UNICODE PROPERTY SUPPORT"
|
||||
.rs
|
||||
.sp
|
||||
From release 3.3, PCRE has had some support for character strings encoded in
|
||||
the UTF-8 format. For release 4.0 this was greatly extended to cover most
|
||||
common requirements, and in release 5.0 additional support for Unicode general
|
||||
category properties was added.
|
||||
.P
|
||||
In order process UTF-8 strings, you must build PCRE to include UTF-8 support in
|
||||
the code, and, in addition, you must call
|
||||
.\" HREF
|
||||
\fBpcre_compile()\fP
|
||||
.\"
|
||||
with the PCRE_UTF8 option flag. When you do this, both the pattern and any
|
||||
subject strings that are matched against it are treated as UTF-8 strings
|
||||
instead of just strings of bytes.
|
||||
.P
|
||||
If you compile PCRE with UTF-8 support, but do not use it at run time, the
|
||||
library will be a bit bigger, but the additional run time overhead is limited
|
||||
to testing the PCRE_UTF8 flag in several places, so should not be very large.
|
||||
.P
|
||||
If PCRE is built with Unicode character property support (which implies UTF-8
|
||||
support), the escape sequences \ep{..}, \eP{..}, and \eX are supported.
|
||||
The available properties that can be tested are limited to the general
|
||||
category properties such as Lu for an upper case letter or Nd for a decimal
|
||||
number. A full list is given in the
|
||||
.\" HREF
|
||||
\fBpcrepattern\fP
|
||||
.\"
|
||||
documentation. The PCRE library is increased in size by about 90K when Unicode
|
||||
property support is included.
|
||||
.P
|
||||
The following comments apply when PCRE is running in UTF-8 mode:
|
||||
.P
|
||||
1. When you set the PCRE_UTF8 flag, the strings passed as patterns and subjects
|
||||
are checked for validity on entry to the relevant functions. If an invalid
|
||||
UTF-8 string is passed, an error return is given. In some situations, you may
|
||||
already know that your strings are valid, and therefore want to skip these
|
||||
checks in order to improve performance. If you set the PCRE_NO_UTF8_CHECK flag
|
||||
at compile time or at run time, PCRE assumes that the pattern or subject it
|
||||
is given (respectively) contains only valid UTF-8 codes. In this case, it does
|
||||
not diagnose an invalid UTF-8 string. If you pass an invalid UTF-8 string to
|
||||
PCRE when PCRE_NO_UTF8_CHECK is set, the results are undefined. Your program
|
||||
may crash.
|
||||
.P
|
||||
2. In a pattern, the escape sequence \ex{...}, where the contents of the braces
|
||||
is a string of hexadecimal digits, is interpreted as a UTF-8 character whose
|
||||
code number is the given hexadecimal number, for example: \ex{1234}. If a
|
||||
non-hexadecimal digit appears between the braces, the item is not recognized.
|
||||
This escape sequence can be used either as a literal, or within a character
|
||||
class.
|
||||
.P
|
||||
3. The original hexadecimal escape sequence, \exhh, matches a two-byte UTF-8
|
||||
character if the value is greater than 127.
|
||||
.P
|
||||
4. Repeat quantifiers apply to complete UTF-8 characters, not to individual
|
||||
bytes, for example: \ex{100}{3}.
|
||||
.P
|
||||
5. The dot metacharacter matches one UTF-8 character instead of a single byte.
|
||||
.P
|
||||
6. The escape sequence \eC can be used to match a single byte in UTF-8 mode,
|
||||
but its use can lead to some strange effects.
|
||||
.P
|
||||
7. The character escapes \eb, \eB, \ed, \eD, \es, \eS, \ew, and \eW correctly
|
||||
test characters of any code value, but the characters that PCRE recognizes as
|
||||
digits, spaces, or word characters remain the same set as before, all with
|
||||
values less than 256. This remains true even when PCRE includes Unicode
|
||||
property support, because to do otherwise would slow down PCRE in many common
|
||||
cases. If you really want to test for a wider sense of, say, "digit", you
|
||||
must use Unicode property tests such as \ep{Nd}.
|
||||
.P
|
||||
8. Similarly, characters that match the POSIX named character classes are all
|
||||
low-valued characters.
|
||||
.P
|
||||
9. Case-insensitive matching applies only to characters whose values are less
|
||||
than 128, unless PCRE is built with Unicode property support. Even when Unicode
|
||||
property support is available, PCRE still uses its own character tables when
|
||||
checking the case of low-valued characters, so as not to degrade performance.
|
||||
The Unicode property information is used only for characters with higher
|
||||
values.
|
||||
.
|
||||
.SH AUTHOR
|
||||
.rs
|
||||
.sp
|
||||
Philip Hazel <[email protected]>
|
||||
.br
|
||||
University Computing Service,
|
||||
.br
|
||||
Cambridge CB2 3QG, England.
|
||||
.br
|
||||
Phone: +44 1223 334714
|
||||
.sp
|
||||
.in 0
|
||||
Last updated: 09 September 2004
|
||||
.br
|
||||
Copyright (c) 1997-2004 University of Cambridge.
|
||||
Vendored
+3769
File diff suppressed because it is too large
Load Diff
Vendored
+64
@@ -0,0 +1,64 @@
|
||||
.TH PCRE 3
|
||||
.SH NAME
|
||||
PCRE - Perl-compatible regular expressions
|
||||
.SH SYNOPSIS
|
||||
.rs
|
||||
.sp
|
||||
.B #include <pcre.h>
|
||||
.PP
|
||||
.SM
|
||||
.br
|
||||
.B pcre *pcre_compile(const char *\fIpattern\fP, int \fIoptions\fP,
|
||||
.ti +5n
|
||||
.B const char **\fIerrptr\fP, int *\fIerroffset\fP,
|
||||
.ti +5n
|
||||
.B const unsigned char *\fItableptr\fP);
|
||||
.
|
||||
.SH DESCRIPTION
|
||||
.rs
|
||||
.sp
|
||||
This function compiles a regular expression into an internal form. Its
|
||||
arguments are:
|
||||
.sp
|
||||
\fIpattern\fR A zero-terminated string containing the
|
||||
regular expression to be compiled
|
||||
\fIoptions\fR Zero or more option bits
|
||||
\fIerrptr\fR Where to put an error message
|
||||
\fIerroffset\fR Offset in pattern where error was found
|
||||
\fItableptr\fR Pointer to character tables, or NULL to
|
||||
use the built-in default
|
||||
.sp
|
||||
The option bits are:
|
||||
.sp
|
||||
PCRE_ANCHORED Force pattern anchoring
|
||||
PCRE_AUTO_CALLOUT Compile automatic callouts
|
||||
PCRE_CASELESS Do caseless matching
|
||||
PCRE_DOLLAR_ENDONLY $ not to match newline at end
|
||||
PCRE_DOTALL . matches anything including NL
|
||||
PCRE_EXTENDED Ignore whitespace and # comments
|
||||
PCRE_EXTRA PCRE extra features
|
||||
(not much use currently)
|
||||
PCRE_MULTILINE ^ and $ match newlines within data
|
||||
PCRE_NO_AUTO_CAPTURE Disable numbered capturing paren-
|
||||
theses (named ones available)
|
||||
PCRE_UNGREEDY Invert greediness of quantifiers
|
||||
PCRE_UTF8 Run in UTF-8 mode
|
||||
PCRE_NO_UTF8_CHECK Do not check the pattern for UTF-8
|
||||
validity (only relevant if
|
||||
PCRE_UTF8 is set)
|
||||
.sp
|
||||
PCRE must be built with UTF-8 support in order to use PCRE_UTF8 and
|
||||
PCRE_NO_UTF8_CHECK.
|
||||
.P
|
||||
The yield of the function is a pointer to a private data structure that
|
||||
contains the compiled pattern, or NULL if an error was detected.
|
||||
.P
|
||||
There is a complete description of the PCRE native API in the
|
||||
.\" HREF
|
||||
\fBpcreapi\fR
|
||||
.\"
|
||||
page and a description of the POSIX API in the
|
||||
.\" HREF
|
||||
\fBpcreposix\fR
|
||||
.\"
|
||||
page.
|
||||
Vendored
+48
@@ -0,0 +1,48 @@
|
||||
.TH PCRE 3
|
||||
.SH NAME
|
||||
PCRE - Perl-compatible regular expressions
|
||||
.SH SYNOPSIS
|
||||
.rs
|
||||
.sp
|
||||
.B #include <pcre.h>
|
||||
.PP
|
||||
.SM
|
||||
.br
|
||||
.B int pcre_config(int \fIwhat\fP, void *\fIwhere\fP);
|
||||
.
|
||||
.SH DESCRIPTION
|
||||
.rs
|
||||
.sp
|
||||
This function makes it possible for a client program to find out which optional
|
||||
features are available in the version of the PCRE library it is using. Its
|
||||
arguments are as follows:
|
||||
.sp
|
||||
\fIwhat\fR A code specifying what information is required
|
||||
\fIwhere\fR Points to where to put the data
|
||||
.sp
|
||||
The available codes are:
|
||||
.sp
|
||||
PCRE_CONFIG_LINK_SIZE Internal link size: 2, 3, or 4
|
||||
PCRE_CONFIG_MATCH_LIMIT Internal resource limit
|
||||
PCRE_CONFIG_NEWLINE Value of the newline character
|
||||
PCRE_CONFIG_POSIX_MALLOC_THRESHOLD
|
||||
Threshold of return slots, above
|
||||
which \fBmalloc()\fR is used by
|
||||
the POSIX API
|
||||
PCRE_CONFIG_STACKRECURSE Recursion implementation (1=stack 0=heap)
|
||||
PCRE_CONFIG_UTF8 Availability of UTF-8 support (1=yes 0=no)
|
||||
PCRE_CONFIG_UNICODE_PROPERTIES
|
||||
Availability of Unicode property support
|
||||
(1=yes 0=no)
|
||||
.sp
|
||||
The function yields 0 on success or PCRE_ERROR_BADOPTION otherwise.
|
||||
.P
|
||||
There is a complete description of the PCRE native API in the
|
||||
.\" HREF
|
||||
\fBpcreapi\fR
|
||||
.\"
|
||||
page and a description of the POSIX API in the
|
||||
.\" HREF
|
||||
\fBpcreposix\fR
|
||||
.\"
|
||||
page.
|
||||
+44
@@ -0,0 +1,44 @@
|
||||
.TH PCRE 3
|
||||
.SH NAME
|
||||
PCRE - Perl-compatible regular expressions
|
||||
.SH SYNOPSIS
|
||||
.rs
|
||||
.sp
|
||||
.B #include <pcre.h>
|
||||
.PP
|
||||
.SM
|
||||
.br
|
||||
.B int pcre_copy_named_substring(const pcre *\fIcode\fP,
|
||||
.ti +5n
|
||||
.B const char *\fIsubject\fP, int *\fIovector\fP,
|
||||
.ti +5n
|
||||
.B int \fIstringcount\fP, const char *\fIstringname\fP,
|
||||
.ti +5n
|
||||
.B char *\fIbuffer\fP, int \fIbuffersize\fP);
|
||||
.
|
||||
.SH DESCRIPTION
|
||||
.rs
|
||||
.sp
|
||||
This is a convenience function for extracting a captured substring, identified
|
||||
by name, into a given buffer. The arguments are:
|
||||
.sp
|
||||
\fIcode\fP Pattern that was successfully matched
|
||||
\fIsubject\fP Subject that has been successfully matched
|
||||
\fIovector\fP Offset vector that \fBpcre_exec()\fP used
|
||||
\fIstringcount\fP Value returned by \fBpcre_exec()\fP
|
||||
\fIstringname\fP Name of the required substring
|
||||
\fIbuffer\fP Buffer to receive the string
|
||||
\fIbuffersize\fP Size of buffer
|
||||
.sp
|
||||
The yield is the length of the substring, PCRE_ERROR_NOMEMORY if the buffer was
|
||||
too small, or PCRE_ERROR_NOSUBSTRING if the string name is invalid.
|
||||
.P
|
||||
There is a complete description of the PCRE native API in the
|
||||
.\" HREF
|
||||
\fBpcreapi\fP
|
||||
.\"
|
||||
page and a description of the POSIX API in the
|
||||
.\" HREF
|
||||
\fBpcreposix\fP
|
||||
.\"
|
||||
page.
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user