Compare commits
1 Commits
master
...
WX_MAIN_AF
| Author | SHA1 | Date | |
|---|---|---|---|
|
7e104fb26e |
@@ -1,15 +0,0 @@
|
||||
|
||||
# Top dir of wxWindows
|
||||
top_builddir = /gtm/bart/wxGTK
|
||||
|
||||
PROGRAM=dbbrowser_gtk
|
||||
|
||||
|
||||
OBJECTS= dbbrowse.o doc.o pgmctrl.o tabpgwin.o\
|
||||
browsedb.o dbtree.o dbgrid.o dlguser.o
|
||||
|
||||
|
||||
|
||||
|
||||
include $(top_builddir)/src/makeprog.env
|
||||
|
||||
@@ -1,173 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: filter.cpp
|
||||
// Purpose: wxHtmlFilter - input filter for translating into HTML format
|
||||
// Author: Vaclav Slavik
|
||||
// Copyright: (c) 1999 Vaclav Slavik
|
||||
// Licence: wxWindows Licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation "htmlfilter.h"
|
||||
#endif
|
||||
|
||||
#include "wx/wxprec.h"
|
||||
|
||||
#if wxUSE_HTML
|
||||
|
||||
#ifdef __BORDLANDC__
|
||||
#pragma hdrstop
|
||||
#endif
|
||||
|
||||
#ifndef WXPRECOMP
|
||||
#include "wx/wx.h"
|
||||
#endif
|
||||
|
||||
#include "wx/html/htmlfilter.h"
|
||||
#include "wx/html/htmlwin.h"
|
||||
|
||||
|
||||
/*
|
||||
|
||||
There is code for several default filters:
|
||||
|
||||
*/
|
||||
|
||||
IMPLEMENT_ABSTRACT_CLASS(wxHtmlFilter, wxObject)
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// wxHtmlFilterPlainText
|
||||
// filter for text/plain or uknown
|
||||
//--------------------------------------------------------------------------------
|
||||
|
||||
IMPLEMENT_DYNAMIC_CLASS(wxHtmlFilterPlainText, wxHtmlFilter)
|
||||
|
||||
bool wxHtmlFilterPlainText::CanRead(const wxFSFile& WXUNUSED(file)) const
|
||||
{
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
|
||||
wxString wxHtmlFilterPlainText::ReadFile(const wxFSFile& file) const
|
||||
{
|
||||
wxInputStream *s = file.GetStream();
|
||||
char *src;
|
||||
wxString doc, doc2;
|
||||
|
||||
if (s == NULL) return wxEmptyString;
|
||||
src = new char[s -> GetSize()+1];
|
||||
src[s -> GetSize()] = 0;
|
||||
s -> Read(src, s -> GetSize());
|
||||
doc = src;
|
||||
delete [] src;
|
||||
|
||||
doc.Replace(_T("<"), _T("<"), TRUE);
|
||||
doc.Replace(_T(">"), _T(">"), TRUE);
|
||||
doc2 = _T("<HTML><BODY><PRE>\n") + doc + _T("\n</PRE></BODY></HTML>");
|
||||
return doc2;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// wxHtmlFilterImage
|
||||
// filter for image/*
|
||||
//--------------------------------------------------------------------------------
|
||||
|
||||
class wxHtmlFilterImage : public wxHtmlFilter
|
||||
{
|
||||
DECLARE_DYNAMIC_CLASS(wxHtmlFilterImage)
|
||||
|
||||
public:
|
||||
virtual bool CanRead(const wxFSFile& file) const;
|
||||
virtual wxString ReadFile(const wxFSFile& file) const;
|
||||
};
|
||||
|
||||
IMPLEMENT_DYNAMIC_CLASS(wxHtmlFilterImage, wxHtmlFilter)
|
||||
|
||||
|
||||
|
||||
bool wxHtmlFilterImage::CanRead(const wxFSFile& file) const
|
||||
{
|
||||
return (file.GetMimeType().Left(6) == "image/");
|
||||
}
|
||||
|
||||
|
||||
|
||||
wxString wxHtmlFilterImage::ReadFile(const wxFSFile& file) const
|
||||
{
|
||||
return ("<HTML><BODY><IMG SRC=\"" + file.GetLocation() + "\"></BODY></HTML>");
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// wxHtmlFilterPlainText
|
||||
// filter for text/plain or uknown
|
||||
//--------------------------------------------------------------------------------
|
||||
|
||||
class wxHtmlFilterHTML : public wxHtmlFilter
|
||||
{
|
||||
DECLARE_DYNAMIC_CLASS(wxHtmlFilterHTML)
|
||||
|
||||
public:
|
||||
virtual bool CanRead(const wxFSFile& file) const;
|
||||
virtual wxString ReadFile(const wxFSFile& file) const;
|
||||
};
|
||||
|
||||
|
||||
IMPLEMENT_DYNAMIC_CLASS(wxHtmlFilterHTML, wxHtmlFilter)
|
||||
|
||||
bool wxHtmlFilterHTML::CanRead(const wxFSFile& file) const
|
||||
{
|
||||
// return (file.GetMimeType() == "text/html");
|
||||
// This is true in most case but some page can return:
|
||||
// "text/html; char-encoding=...."
|
||||
// So we use Find instead
|
||||
return (file.GetMimeType().Find(_T("text/html")) == 0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
wxString wxHtmlFilterHTML::ReadFile(const wxFSFile& file) const
|
||||
{
|
||||
wxInputStream *s = file.GetStream();
|
||||
char *src;
|
||||
wxString doc;
|
||||
|
||||
if (s == NULL) return wxEmptyString;
|
||||
src = new char[s -> GetSize() + 1];
|
||||
src[s -> GetSize()] = 0;
|
||||
s -> Read(src, s -> GetSize());
|
||||
doc = src;
|
||||
delete[] src;
|
||||
|
||||
return doc;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
///// Module:
|
||||
|
||||
class wxHtmlFilterModule : public wxModule
|
||||
{
|
||||
DECLARE_DYNAMIC_CLASS(wxHtmlFilterModule)
|
||||
|
||||
public:
|
||||
virtual bool OnInit()
|
||||
{
|
||||
wxHtmlWindow::AddFilter(new wxHtmlFilterHTML);
|
||||
wxHtmlWindow::AddFilter(new wxHtmlFilterImage);
|
||||
return TRUE;
|
||||
}
|
||||
virtual void OnExit() {}
|
||||
};
|
||||
|
||||
IMPLEMENT_DYNAMIC_CLASS(wxHtmlFilterModule, wxModule)
|
||||
|
||||
#endif
|
||||
@@ -1,835 +0,0 @@
|
||||
// Name: htmlhelp.cpp
|
||||
// Purpose: Help controller
|
||||
// Author: Vaclav Slavik
|
||||
// Copyright: (c) 1999 Vaclav Slavik
|
||||
// Licence: wxWindows Licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#error This file should not be compiled! Update your build system! \
|
||||
(configure users, rerun configure to get a new Makefile) \
|
||||
Instead of htmlhelp[_io], use helpdata, helpfrm and helpctrl. This \
|
||||
file is only left to point out the problem and will be removed r.s.n.
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation "htmlhelp.h"
|
||||
#endif
|
||||
|
||||
#include "wx/wxprec.h"
|
||||
|
||||
#if wxUSE_HTML
|
||||
|
||||
#ifdef __BORDLANDC__
|
||||
#pragma hdrstop
|
||||
#endif
|
||||
|
||||
#ifndef WXPRECOMP
|
||||
#include <wx/wx.h>
|
||||
#endif
|
||||
|
||||
|
||||
#include <wx/notebook.h>
|
||||
#include <wx/imaglist.h>
|
||||
#include <wx/treectrl.h>
|
||||
#include <wx/tokenzr.h>
|
||||
#include <wx/wfstream.h>
|
||||
#include <wx/html/htmlwin.h>
|
||||
#include <wx/html/htmlhelp.h>
|
||||
#include <wx/busyinfo.h>
|
||||
|
||||
#if !((wxVERSION_NUMBER < 2100) || ((wxVERSION_NUMBER == 2100) && (wxBETA_NUMBER < 7)))
|
||||
#include <wx/progdlg.h>
|
||||
#endif
|
||||
|
||||
|
||||
// Bitmaps:
|
||||
|
||||
#ifndef __WXMSW__
|
||||
#include "bitmaps/panel.xpm"
|
||||
#include "bitmaps/back.xpm"
|
||||
#include "bitmaps/forward.xpm"
|
||||
#include "bitmaps/book.xpm"
|
||||
#include "bitmaps/folder.xpm"
|
||||
#include "bitmaps/page.xpm"
|
||||
#endif
|
||||
|
||||
#include "search.h"
|
||||
|
||||
|
||||
|
||||
|
||||
#include <wx/arrimpl.cpp>
|
||||
WX_DEFINE_OBJARRAY(HtmlBookRecArray)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// wxHtmlHelpController
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
IMPLEMENT_DYNAMIC_CLASS(wxHtmlHelpController, wxEvtHandler)
|
||||
|
||||
|
||||
wxHtmlHelpController::wxHtmlHelpController() : wxEvtHandler()
|
||||
{
|
||||
m_Frame = NULL;
|
||||
m_Config = NULL;
|
||||
m_ConfigRoot = wxEmptyString;
|
||||
m_TitleFormat = _("Help : %s");
|
||||
m_TempPath = wxEmptyString;
|
||||
|
||||
m_Cfg.x = m_Cfg.y = 0;
|
||||
m_Cfg.w = 700; m_Cfg.h = 480;
|
||||
m_Cfg.sashpos = 240;
|
||||
m_Cfg.navig_on = TRUE;
|
||||
|
||||
m_ContentsImageList = new wxImageList(12, 12);
|
||||
m_ContentsImageList -> Add(wxICON(book));
|
||||
m_ContentsImageList -> Add(wxICON(folder));
|
||||
m_ContentsImageList -> Add(wxICON(page));
|
||||
|
||||
m_Contents = NULL;
|
||||
m_ContentsCnt = 0;
|
||||
m_Index = NULL;
|
||||
m_IndexCnt = 0;
|
||||
|
||||
m_IndexBox = NULL;
|
||||
m_ContentsBox = NULL;
|
||||
m_SearchList = NULL;
|
||||
m_SearchText = NULL;
|
||||
m_SearchButton = NULL;
|
||||
m_HtmlWin = NULL;
|
||||
m_Splitter = NULL;
|
||||
m_NavigPan = NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
wxHtmlHelpController::~wxHtmlHelpController()
|
||||
{
|
||||
int i;
|
||||
|
||||
m_BookRecords.Empty();
|
||||
delete m_ContentsImageList;
|
||||
if (m_Contents) {
|
||||
for (i = 0; i < m_ContentsCnt; i++) {
|
||||
delete[] m_Contents[i].m_Page;
|
||||
delete[] m_Contents[i].m_Name;
|
||||
}
|
||||
free(m_Contents);
|
||||
}
|
||||
if (m_Index) {
|
||||
for (i = 0; i < m_IndexCnt; i++) {
|
||||
delete[] m_Index[i].m_Page;
|
||||
delete[] m_Index[i].m_Name;
|
||||
}
|
||||
free(m_Index);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void wxHtmlHelpController::SetTempDir(const wxString& path)
|
||||
{
|
||||
if (path == wxEmptyString) m_TempPath = path;
|
||||
else {
|
||||
if (wxIsAbsolutePath(path)) m_TempPath = path;
|
||||
else m_TempPath = wxGetCwd() + "/" + path;
|
||||
|
||||
if (m_TempPath[m_TempPath.Length() - 1] != '/')
|
||||
m_TempPath << "/";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
// Reads one line, stores it into buf and returns pointer to new line or NULL.
|
||||
static char* ReadLine(char *line, char *buf)
|
||||
{
|
||||
char *writeptr = buf, *readptr = line;
|
||||
|
||||
while (*readptr != 0 && *readptr != '\r' && *readptr != '\n') *(writeptr++) = *(readptr++);
|
||||
*writeptr = 0;
|
||||
while (*readptr == '\r' || *readptr == '\n') readptr++;
|
||||
if (*readptr == 0) return NULL;
|
||||
else return readptr;
|
||||
}
|
||||
|
||||
|
||||
static wxString SafeFileName(const wxString& s)
|
||||
{
|
||||
wxString res = s;
|
||||
res.Replace(_T(":"), _T("_"), TRUE);
|
||||
res.Replace(_T(" "), _T("_"), TRUE);
|
||||
res.Replace(_T("/"), _T("_"), TRUE);
|
||||
res.Replace(_T("\\"), _T("_"), TRUE);
|
||||
res.Replace(_T("#"), _T("_"), TRUE);
|
||||
res.Replace(_T("."), _T("_"), TRUE);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
static int IndexCompareFunc(const void *a, const void *b)
|
||||
{
|
||||
return strcmp(((HtmlContentsItem*)a) -> m_Name, ((HtmlContentsItem*)b) -> m_Name);
|
||||
}
|
||||
|
||||
|
||||
|
||||
bool wxHtmlHelpController::AddBook(const wxString& book, bool show_wait_msg)
|
||||
{
|
||||
wxFSFile *fi;
|
||||
wxFileSystem fsys;
|
||||
wxInputStream *s;
|
||||
HtmlBookRecord *bookr;
|
||||
wxString bookFull;
|
||||
|
||||
int sz;
|
||||
char *buff, *lineptr;
|
||||
char linebuf[300];
|
||||
|
||||
wxString title = _("noname"),
|
||||
safetitle,
|
||||
start = wxEmptyString,
|
||||
contents = wxEmptyString, index = wxEmptyString;
|
||||
|
||||
if (wxIsAbsolutePath(book)) bookFull = book;
|
||||
else bookFull = wxGetCwd() + "/" + book;
|
||||
|
||||
fi = fsys.OpenFile(bookFull);
|
||||
if (fi == NULL) return FALSE;
|
||||
fsys.ChangePathTo(bookFull);
|
||||
s = fi -> GetStream();
|
||||
sz = s -> GetSize();
|
||||
buff = new char[sz+1];
|
||||
buff[sz] = 0;
|
||||
s -> Read(buff, sz);
|
||||
lineptr = buff;
|
||||
delete fi;
|
||||
|
||||
while ((lineptr = ReadLine(lineptr, linebuf)) != NULL) {
|
||||
if (strstr(linebuf, "Title=") == linebuf)
|
||||
title = linebuf + strlen("Title=");
|
||||
if (strstr(linebuf, "Default topic=") == linebuf)
|
||||
start = linebuf + strlen("Default topic=");
|
||||
if (strstr(linebuf, "Index file=") == linebuf)
|
||||
index = linebuf + strlen("Index file=");
|
||||
if (strstr(linebuf, "Contents file=") == linebuf)
|
||||
contents = linebuf + strlen("Contents file=");
|
||||
}
|
||||
delete[] buff;
|
||||
|
||||
bookr = new HtmlBookRecord(fsys.GetPath(), title, start);
|
||||
|
||||
if (m_ContentsCnt % HTML_REALLOC_STEP == 0)
|
||||
m_Contents = (HtmlContentsItem*) realloc(m_Contents, (m_ContentsCnt + HTML_REALLOC_STEP) * sizeof(HtmlContentsItem));
|
||||
m_Contents[m_ContentsCnt].m_Level = 0;
|
||||
m_Contents[m_ContentsCnt].m_ID = 0;
|
||||
m_Contents[m_ContentsCnt].m_Page = new char[start.Length() + 1];
|
||||
strcpy(m_Contents[m_ContentsCnt].m_Page, start.c_str());
|
||||
m_Contents[m_ContentsCnt].m_Name = new char [title.Length() + 1];
|
||||
strcpy(m_Contents[m_ContentsCnt].m_Name, title.c_str());
|
||||
m_Contents[m_ContentsCnt].m_Book = bookr;
|
||||
m_ContentsCnt++;
|
||||
|
||||
// Try to find cached binary versions:
|
||||
safetitle = SafeFileName(title);
|
||||
fi = fsys.OpenFile(safetitle + ".cached");
|
||||
if (fi == NULL) fi = fsys.OpenFile(m_TempPath + safetitle + ".cached");
|
||||
if ((fi == NULL) || (m_TempPath == wxEmptyString)) {
|
||||
LoadMSProject(bookr, fsys, index, contents, show_wait_msg);
|
||||
if (m_TempPath != wxEmptyString) {
|
||||
wxFileOutputStream *outs = new wxFileOutputStream(m_TempPath + safetitle + ".cached");
|
||||
SaveCachedBook(bookr, outs);
|
||||
delete outs;
|
||||
}
|
||||
}
|
||||
else {
|
||||
LoadCachedBook(bookr, fi -> GetStream());
|
||||
delete fi;
|
||||
}
|
||||
|
||||
m_BookRecords.Add(bookr);
|
||||
if (m_IndexCnt > 0)
|
||||
qsort(m_Index, m_IndexCnt, sizeof(HtmlContentsItem), IndexCompareFunc);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
void wxHtmlHelpController::Display(const wxString& x)
|
||||
{
|
||||
int cnt;
|
||||
int i;
|
||||
wxFileSystem fsys;
|
||||
wxFSFile *f;
|
||||
|
||||
CreateHelpWindow();
|
||||
|
||||
/* 1. try to open given file: */
|
||||
|
||||
cnt = m_BookRecords.GetCount();
|
||||
for (i = 0; i < cnt; i++) {
|
||||
f = fsys.OpenFile(m_BookRecords[i].GetBasePath() + x);
|
||||
if (f) {
|
||||
m_HtmlWin -> LoadPage(m_BookRecords[i].GetBasePath() + x);
|
||||
delete f;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* 2. try to find a book: */
|
||||
|
||||
for (i = 0; i < cnt; i++) {
|
||||
if (m_BookRecords[i].GetTitle() == x) {
|
||||
m_HtmlWin -> LoadPage(m_BookRecords[i].GetBasePath() + m_BookRecords[i].GetStart());
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/* 3. try to find in contents: */
|
||||
|
||||
cnt = m_ContentsCnt;
|
||||
for (i = 0; i < cnt; i++) {
|
||||
if (strcmp(m_Contents[i].m_Name, x) == 0) {
|
||||
m_HtmlWin -> LoadPage(m_Contents[i].m_Book -> GetBasePath() + m_Contents[i].m_Page);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* 4. try to find in index: */
|
||||
|
||||
cnt = m_IndexCnt;
|
||||
for (i = 0; i < cnt; i++) {
|
||||
if (strcmp(m_Index[i].m_Name, x) == 0) {
|
||||
m_HtmlWin -> LoadPage(m_Index[i].m_Book -> GetBasePath() + m_Index[i].m_Page);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* 5. if everything failed, search the documents: */
|
||||
|
||||
KeywordSearch(x);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void wxHtmlHelpController::Display(const int id)
|
||||
{
|
||||
CreateHelpWindow();
|
||||
|
||||
for (int i = 0; i < m_ContentsCnt; i++) {
|
||||
if (m_Contents[i].m_ID == id) {
|
||||
m_HtmlWin -> LoadPage(m_Contents[i].m_Book -> GetBasePath() + m_Contents[i].m_Page);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void wxHtmlHelpController::DisplayContents()
|
||||
{
|
||||
CreateHelpWindow();
|
||||
m_Frame -> Raise();
|
||||
if (!m_Splitter -> IsSplit()) {
|
||||
m_NavigPan -> Show(TRUE);
|
||||
m_HtmlWin -> Show(TRUE);
|
||||
m_Splitter -> SplitVertically(m_NavigPan, m_HtmlWin, m_Cfg.sashpos);
|
||||
}
|
||||
m_NavigPan -> SetSelection(0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void wxHtmlHelpController::DisplayIndex()
|
||||
{
|
||||
CreateHelpWindow();
|
||||
m_Frame -> Raise();
|
||||
if (!m_Splitter -> IsSplit()) {
|
||||
m_NavigPan -> Show(TRUE);
|
||||
m_HtmlWin -> Show(TRUE);
|
||||
m_Splitter -> SplitVertically(m_NavigPan, m_HtmlWin, m_Cfg.sashpos);
|
||||
}
|
||||
m_NavigPan -> SetSelection(1);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
#if (wxVERSION_NUMBER < 2100) || ((wxVERSION_NUMBER == 2100) && (wxBETA_NUMBER < 7))
|
||||
|
||||
class MyProgressDlg : public wxDialog
|
||||
{
|
||||
public:
|
||||
bool m_Canceled;
|
||||
|
||||
MyProgressDlg(wxWindow *parent) : wxDialog(parent, -1,
|
||||
_("Searching..."),
|
||||
wxPoint(0, 0),
|
||||
#ifdef __WXGTK__
|
||||
wxSize(300, 110))
|
||||
#else
|
||||
wxSize(300, 130))
|
||||
#endif
|
||||
{m_Canceled = FALSE;}
|
||||
void OnCancel(wxCommandEvent& event) {m_Canceled = TRUE;}
|
||||
DECLARE_EVENT_TABLE()
|
||||
};
|
||||
BEGIN_EVENT_TABLE(MyProgressDlg, wxDialog)
|
||||
EVT_BUTTON(wxID_CANCEL, MyProgressDlg::OnCancel)
|
||||
END_EVENT_TABLE()
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
bool wxHtmlHelpController::KeywordSearch(const wxString& keyword)
|
||||
{
|
||||
int foundcnt = 0;
|
||||
CreateHelpWindow();
|
||||
// if these are not set, we can't continue
|
||||
if (! (m_SearchList && m_HtmlWin))
|
||||
return FALSE;
|
||||
m_Frame -> Raise();
|
||||
if (m_Splitter && m_NavigPan && m_SearchButton) {
|
||||
if (!m_Splitter -> IsSplit()) {
|
||||
m_NavigPan -> Show(TRUE);
|
||||
m_HtmlWin -> Show(TRUE);
|
||||
m_Splitter -> SplitVertically(m_NavigPan, m_HtmlWin, m_Cfg.sashpos);
|
||||
}
|
||||
m_NavigPan -> SetSelection(2);
|
||||
m_SearchList -> Clear();
|
||||
m_SearchText -> SetValue(keyword);
|
||||
m_SearchButton -> Enable(FALSE);
|
||||
}
|
||||
{
|
||||
int cnt = m_ContentsCnt;
|
||||
wxSearchEngine engine;
|
||||
wxFileSystem fsys;
|
||||
wxFSFile *file;
|
||||
wxString lastpage = wxEmptyString;
|
||||
wxString foundstr;
|
||||
|
||||
#if (wxVERSION_NUMBER < 2100) || ((wxVERSION_NUMBER == 2100) && (wxBETA_NUMBER < 7))
|
||||
MyProgressDlg progress(m_Frame);
|
||||
|
||||
wxStaticText *prompt = new wxStaticText(&progress, -1, "", wxPoint(20, 50), wxSize(260, 25), wxALIGN_CENTER);
|
||||
wxGauge *gauge = new wxGauge(&progress, -1, cnt, wxPoint(20, 20), wxSize(260, 25));
|
||||
wxButton *btn = new wxButton(&progress, wxID_CANCEL, _("Cancel"), wxPoint(110, 70), wxSize(80, 25));
|
||||
btn = btn; /* fool compiler :-) */
|
||||
prompt -> SetLabel(_("No matching page found yet"));
|
||||
|
||||
progress.Centre(wxBOTH);
|
||||
progress.Show(TRUE);
|
||||
#else
|
||||
wxProgressDialog progress(_("Searching..."), _("No matching page found yet"), cnt, m_Frame, wxPD_APP_MODAL | wxPD_CAN_ABORT | wxPD_AUTO_HIDE);
|
||||
#endif
|
||||
|
||||
engine.LookFor(keyword);
|
||||
|
||||
for (int i = 0; i < cnt; i++) {
|
||||
#if (wxVERSION_NUMBER < 2100) || ((wxVERSION_NUMBER == 2100) && (wxBETA_NUMBER < 7))
|
||||
gauge -> SetValue(i);
|
||||
if (progress.m_Canceled) break;
|
||||
#else
|
||||
if (progress.Update(i) == FALSE) break;
|
||||
#endif
|
||||
wxYield();
|
||||
|
||||
file = fsys.OpenFile(m_Contents[i].m_Book -> GetBasePath() + m_Contents[i].m_Page);
|
||||
if (file) {
|
||||
if (lastpage != file -> GetLocation()) {
|
||||
lastpage = file -> GetLocation();
|
||||
if (engine.Scan(file -> GetStream())) {
|
||||
foundstr.Printf(_("Found %i matches"), ++foundcnt);
|
||||
#if (wxVERSION_NUMBER < 2100) || ((wxVERSION_NUMBER == 2100) && (wxBETA_NUMBER < 7))
|
||||
prompt -> SetLabel(foundstr);
|
||||
#else
|
||||
progress.Update(i, foundstr);
|
||||
#endif
|
||||
wxYield();
|
||||
m_SearchList -> Append(m_Contents[i].m_Name, (char*)(m_Contents + i));
|
||||
}
|
||||
}
|
||||
delete file;
|
||||
}
|
||||
}
|
||||
|
||||
#if (wxVERSION_NUMBER < 2100) || ((wxVERSION_NUMBER == 2100) && (wxBETA_NUMBER < 7))
|
||||
progress.Close(TRUE);
|
||||
#endif
|
||||
}
|
||||
if (m_SearchButton)
|
||||
m_SearchButton -> Enable(TRUE);
|
||||
if (m_SearchText) {
|
||||
m_SearchText -> SetSelection(0, keyword.Length());
|
||||
m_SearchText -> SetFocus();
|
||||
}
|
||||
if (foundcnt) {
|
||||
HtmlContentsItem *it = (HtmlContentsItem*) m_SearchList -> GetClientData(0);
|
||||
if (it) m_HtmlWin -> LoadPage(it -> m_Book -> GetBasePath() + it -> m_Page);
|
||||
}
|
||||
return (foundcnt > 0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void wxHtmlHelpController::CreateHelpWindow()
|
||||
{
|
||||
wxBusyCursor cur;
|
||||
wxString oldpath;
|
||||
wxStatusBar *sbar;
|
||||
|
||||
if (m_Frame) {
|
||||
m_Frame -> Raise();
|
||||
m_Frame -> Show(TRUE);
|
||||
return;
|
||||
}
|
||||
|
||||
#if wxUSE_BUSYINFO
|
||||
wxBusyInfo busyinfo(_("Preparing help window..."));
|
||||
#endif
|
||||
|
||||
if (m_Config) ReadCustomization(m_Config, m_ConfigRoot);
|
||||
|
||||
m_Frame = new wxFrame(NULL, -1, "", wxPoint(m_Cfg.x, m_Cfg.y), wxSize(m_Cfg.w, m_Cfg.h));
|
||||
m_Frame -> PushEventHandler(this);
|
||||
sbar = m_Frame -> CreateStatusBar();
|
||||
|
||||
{
|
||||
wxToolBar *toolBar;
|
||||
toolBar = m_Frame -> CreateToolBar(wxNO_BORDER | wxTB_HORIZONTAL | wxTB_FLAT | wxTB_DOCKABLE);
|
||||
toolBar -> SetMargins(2, 2);
|
||||
wxBitmap* toolBarBitmaps[3];
|
||||
|
||||
#ifdef __WXMSW__
|
||||
toolBarBitmaps[0] = new wxBitmap("panel");
|
||||
toolBarBitmaps[1] = new wxBitmap("back");
|
||||
toolBarBitmaps[2] = new wxBitmap("forward");
|
||||
int width = 24;
|
||||
#else
|
||||
toolBarBitmaps[0] = new wxBitmap(panel_xpm);
|
||||
toolBarBitmaps[1] = new wxBitmap(back_xpm);
|
||||
toolBarBitmaps[2] = new wxBitmap(forward_xpm);
|
||||
int width = 16;
|
||||
#endif
|
||||
|
||||
int currentX = 5;
|
||||
|
||||
toolBar -> AddTool(wxID_HTML_PANEL, *(toolBarBitmaps[0]), wxNullBitmap, FALSE, currentX, -1, (wxObject *) NULL, _("Show/hide navigation panel"));
|
||||
currentX += width + 5;
|
||||
toolBar -> AddSeparator();
|
||||
toolBar -> AddTool(wxID_HTML_BACK, *(toolBarBitmaps[1]), wxNullBitmap, FALSE, currentX, -1, (wxObject *) NULL, _("Go back to the previous HTML page"));
|
||||
currentX += width + 5;
|
||||
toolBar -> AddTool(wxID_HTML_FORWARD, *(toolBarBitmaps[2]), wxNullBitmap, FALSE, currentX, -1, (wxObject *) NULL, _("Go forward to the next HTML page"));
|
||||
currentX += width + 5;
|
||||
|
||||
toolBar -> Realize();
|
||||
|
||||
// Can delete the bitmaps since they're reference counted
|
||||
for (int i = 0; i < 3; i++) delete toolBarBitmaps[i];
|
||||
}
|
||||
|
||||
|
||||
{
|
||||
m_Splitter = new wxSplitterWindow(m_Frame);
|
||||
|
||||
m_HtmlWin = new wxHtmlWindow(m_Splitter);
|
||||
m_HtmlWin -> SetRelatedFrame(m_Frame, m_TitleFormat);
|
||||
m_HtmlWin -> SetRelatedStatusBar(0);
|
||||
if (m_Config) m_HtmlWin -> ReadCustomization(m_Config, m_ConfigRoot);
|
||||
|
||||
m_NavigPan = new wxNotebook(m_Splitter, wxID_HTML_NOTEBOOK, wxDefaultPosition, wxDefaultSize);
|
||||
{
|
||||
m_ContentsBox = new wxTreeCtrl(m_NavigPan, wxID_HTML_TREECTRL, wxDefaultPosition, wxDefaultSize, wxTR_HAS_BUTTONS | wxSUNKEN_BORDER);
|
||||
m_ContentsBox -> SetImageList(m_ContentsImageList);
|
||||
m_NavigPan -> AddPage(m_ContentsBox, _("Contents"));
|
||||
}
|
||||
|
||||
{
|
||||
wxWindow *dummy = new wxPanel(m_NavigPan, wxID_HTML_INDEXPAGE);
|
||||
wxLayoutConstraints *b1 = new wxLayoutConstraints;
|
||||
b1 -> top.SameAs (dummy, wxTop, 0);
|
||||
b1 -> left.SameAs (dummy, wxLeft, 0);
|
||||
b1 -> width.PercentOf (dummy, wxWidth, 100);
|
||||
b1 -> bottom.SameAs (dummy, wxBottom, 0);
|
||||
m_IndexBox = new wxListBox(dummy, wxID_HTML_INDEXLIST, wxDefaultPosition, wxDefaultSize, 0);
|
||||
m_IndexBox -> SetConstraints(b1);
|
||||
dummy -> SetAutoLayout(TRUE);
|
||||
m_NavigPan -> AddPage(dummy, _("Index"));
|
||||
}
|
||||
|
||||
{
|
||||
wxWindow *dummy = new wxPanel(m_NavigPan, wxID_HTML_SEARCHPAGE);
|
||||
|
||||
wxLayoutConstraints *b1 = new wxLayoutConstraints;
|
||||
m_SearchText = new wxTextCtrl(dummy, wxID_HTML_SEARCHTEXT);
|
||||
b1 -> top.SameAs (dummy, wxTop, 0);
|
||||
b1 -> left.SameAs (dummy, wxLeft, 0);
|
||||
b1 -> right.SameAs (dummy, wxRight, 0);
|
||||
b1 -> height.AsIs();
|
||||
m_SearchText -> SetConstraints(b1);
|
||||
|
||||
wxLayoutConstraints *b2 = new wxLayoutConstraints;
|
||||
m_SearchButton = new wxButton(dummy, wxID_HTML_SEARCHBUTTON, _("Search!"));
|
||||
b2 -> top.Below (m_SearchText, 10);
|
||||
b2 -> right.SameAs (dummy, wxRight, 10);
|
||||
b2 -> width.AsIs();
|
||||
b2 -> height.AsIs();
|
||||
m_SearchButton -> SetConstraints(b2);
|
||||
|
||||
wxLayoutConstraints *b3 = new wxLayoutConstraints;
|
||||
m_SearchList = new wxListBox(dummy, wxID_HTML_SEARCHLIST, wxDefaultPosition, wxDefaultSize, 0);
|
||||
b3 -> top.Below (m_SearchButton, 10);
|
||||
b3 -> left.SameAs (dummy, wxLeft, 0);
|
||||
b3 -> right.SameAs (dummy, wxRight, 0);
|
||||
b3 -> bottom.SameAs (dummy, wxBottom, 0);
|
||||
m_SearchList -> SetConstraints(b3);
|
||||
|
||||
dummy -> SetAutoLayout(TRUE);
|
||||
dummy -> Layout();
|
||||
m_NavigPan -> AddPage(dummy, _("Search"));
|
||||
}
|
||||
|
||||
RefreshLists();
|
||||
m_NavigPan -> Show(TRUE);
|
||||
m_HtmlWin -> Show(TRUE);
|
||||
m_Splitter -> SetMinimumPaneSize(20);
|
||||
m_Splitter -> SplitVertically(m_NavigPan, m_HtmlWin, m_Cfg.sashpos);
|
||||
if (!m_Cfg.navig_on) m_Splitter -> Unsplit(m_NavigPan);
|
||||
wxYield();
|
||||
}
|
||||
|
||||
m_Frame -> Show(TRUE);
|
||||
wxYield();
|
||||
}
|
||||
|
||||
|
||||
|
||||
#define MAX_ROOTS 64
|
||||
|
||||
void wxHtmlHelpController::CreateContents()
|
||||
{
|
||||
HtmlContentsItem *it;
|
||||
wxTreeItemId roots[MAX_ROOTS];
|
||||
bool imaged[MAX_ROOTS];
|
||||
int count = m_ContentsCnt;
|
||||
|
||||
m_ContentsBox -> DeleteAllItems();
|
||||
roots[0] = m_ContentsBox -> AddRoot(_("(Help)"));
|
||||
imaged[0] = TRUE;
|
||||
|
||||
for (int i = 0; i < count; i++) {
|
||||
it = m_Contents + i;
|
||||
roots[it -> m_Level + 1] = m_ContentsBox -> AppendItem(roots[it -> m_Level], it -> m_Name, IMG_Page, -1, new wxHtmlHelpTreeItemData(it));
|
||||
if (it -> m_Level == 0) {
|
||||
m_ContentsBox -> SetItemBold(roots[1], TRUE);
|
||||
m_ContentsBox -> SetItemImage(roots[1], IMG_Book);
|
||||
m_ContentsBox -> SetItemSelectedImage(roots[1], IMG_Book);
|
||||
imaged[1] = TRUE;
|
||||
}
|
||||
else imaged[it -> m_Level + 1] = FALSE;
|
||||
|
||||
if (!imaged[it -> m_Level]) {
|
||||
m_ContentsBox -> SetItemImage(roots[it -> m_Level], IMG_Folder);
|
||||
m_ContentsBox -> SetItemSelectedImage(roots[it -> m_Level], IMG_Folder);
|
||||
imaged[it -> m_Level] = TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
m_ContentsBox -> Expand(roots[0]);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
void wxHtmlHelpController::CreateIndex()
|
||||
{
|
||||
m_IndexBox -> Clear();
|
||||
|
||||
for (int i = 0; i < m_IndexCnt; i++)
|
||||
m_IndexBox -> Append(m_Index[i].m_Name, (char*)(m_Index + i));
|
||||
}
|
||||
|
||||
|
||||
|
||||
void wxHtmlHelpController::RefreshLists()
|
||||
{
|
||||
if (m_Frame) {
|
||||
CreateContents();
|
||||
CreateIndex();
|
||||
m_SearchList -> Clear();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void wxHtmlHelpController::ReadCustomization(wxConfigBase *cfg, wxString path)
|
||||
{
|
||||
wxString oldpath;
|
||||
wxString tmp;
|
||||
|
||||
if (path != wxEmptyString) {
|
||||
oldpath = cfg -> GetPath();
|
||||
cfg -> SetPath(path);
|
||||
}
|
||||
|
||||
m_Cfg.navig_on = cfg -> Read("hcNavigPanel", m_Cfg.navig_on) != 0;
|
||||
m_Cfg.sashpos = cfg -> Read("hcSashPos", m_Cfg.sashpos);
|
||||
m_Cfg.x = cfg -> Read("hcX", m_Cfg.x);
|
||||
m_Cfg.y = cfg -> Read("hcY", m_Cfg.y);
|
||||
m_Cfg.w = cfg -> Read("hcW", m_Cfg.w);
|
||||
m_Cfg.h = cfg -> Read("hcH", m_Cfg.h);
|
||||
|
||||
if (path != wxEmptyString)
|
||||
cfg -> SetPath(oldpath);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void wxHtmlHelpController::WriteCustomization(wxConfigBase *cfg, wxString path)
|
||||
{
|
||||
wxString oldpath;
|
||||
wxString tmp;
|
||||
|
||||
if (path != wxEmptyString) {
|
||||
oldpath = cfg -> GetPath();
|
||||
cfg -> SetPath(path);
|
||||
}
|
||||
|
||||
cfg -> Write("hcNavigPanel", m_Cfg.navig_on);
|
||||
cfg -> Write("hcSashPos", (long)m_Cfg.sashpos);
|
||||
cfg -> Write("hcX", (long)m_Cfg.x);
|
||||
cfg -> Write("hcY", (long)m_Cfg.y);
|
||||
cfg -> Write("hcW", (long)m_Cfg.w);
|
||||
cfg -> Write("hcH", (long)m_Cfg.h);
|
||||
|
||||
if (path != wxEmptyString)
|
||||
cfg -> SetPath(oldpath);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*
|
||||
EVENT HANDLING :
|
||||
*/
|
||||
|
||||
|
||||
void wxHtmlHelpController::OnToolbar(wxCommandEvent& event)
|
||||
{
|
||||
switch (event.GetId()) {
|
||||
case wxID_HTML_BACK :
|
||||
m_HtmlWin -> HistoryBack();
|
||||
break;
|
||||
case wxID_HTML_FORWARD :
|
||||
m_HtmlWin -> HistoryForward();
|
||||
break;
|
||||
case wxID_HTML_PANEL :
|
||||
if (m_Splitter -> IsSplit()) {
|
||||
m_Cfg.sashpos = m_Splitter -> GetSashPosition();
|
||||
m_Splitter -> Unsplit(m_NavigPan);
|
||||
}
|
||||
else {
|
||||
m_NavigPan -> Show(TRUE);
|
||||
m_HtmlWin -> Show(TRUE);
|
||||
m_Splitter -> SplitVertically(m_NavigPan, m_HtmlWin, m_Cfg.sashpos);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void wxHtmlHelpController::OnContentsSel(wxTreeEvent& event)
|
||||
{
|
||||
wxHtmlHelpTreeItemData *pg;
|
||||
|
||||
pg = (wxHtmlHelpTreeItemData*) m_ContentsBox -> GetItemData(event.GetItem());
|
||||
if (pg) m_HtmlWin -> LoadPage(pg -> GetPage());
|
||||
}
|
||||
|
||||
|
||||
|
||||
void wxHtmlHelpController::OnIndexSel(wxCommandEvent& event)
|
||||
{
|
||||
HtmlContentsItem *it = (HtmlContentsItem*) m_IndexBox -> GetClientData(m_IndexBox -> GetSelection());
|
||||
if (it) m_HtmlWin -> LoadPage(it -> m_Book -> GetBasePath() + it -> m_Page);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void wxHtmlHelpController::OnSearchSel(wxCommandEvent& event)
|
||||
{
|
||||
HtmlContentsItem *it = (HtmlContentsItem*) m_SearchList -> GetClientData(m_SearchList -> GetSelection());
|
||||
if (it) m_HtmlWin -> LoadPage(it -> m_Book -> GetBasePath() + it -> m_Page);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void wxHtmlHelpController::OnCloseWindow(wxCloseEvent& event)
|
||||
{
|
||||
int a, b;
|
||||
|
||||
m_Cfg.navig_on = m_Splitter -> IsSplit();
|
||||
if (m_Cfg.navig_on)
|
||||
m_Cfg.sashpos = m_Splitter -> GetSashPosition();
|
||||
m_Frame -> GetPosition(&a, &b);
|
||||
m_Cfg.x = a, m_Cfg.y = b;
|
||||
m_Frame -> GetSize(&a, &b);
|
||||
m_Cfg.w = a, m_Cfg.h = b;
|
||||
|
||||
if (m_Config) {
|
||||
WriteCustomization(m_Config, m_ConfigRoot);
|
||||
m_HtmlWin -> WriteCustomization(m_Config, m_ConfigRoot);
|
||||
}
|
||||
m_Frame = NULL;
|
||||
|
||||
event.Skip();
|
||||
}
|
||||
|
||||
|
||||
|
||||
void wxHtmlHelpController::OnSearch(wxCommandEvent& event)
|
||||
{
|
||||
wxString sr = m_SearchText -> GetLineText(0);
|
||||
|
||||
if (sr != wxEmptyString) KeywordSearch(sr);
|
||||
}
|
||||
|
||||
|
||||
|
||||
BEGIN_EVENT_TABLE(wxHtmlHelpController, wxEvtHandler)
|
||||
EVT_TOOL_RANGE(wxID_HTML_PANEL, wxID_HTML_FORWARD, wxHtmlHelpController::OnToolbar)
|
||||
EVT_TREE_SEL_CHANGED(wxID_HTML_TREECTRL, wxHtmlHelpController::OnContentsSel)
|
||||
EVT_LISTBOX(wxID_HTML_INDEXLIST, wxHtmlHelpController::OnIndexSel)
|
||||
EVT_LISTBOX(wxID_HTML_SEARCHLIST, wxHtmlHelpController::OnSearchSel)
|
||||
EVT_CLOSE(wxHtmlHelpController::OnCloseWindow)
|
||||
EVT_BUTTON(wxID_HTML_SEARCHBUTTON, wxHtmlHelpController::OnSearch)
|
||||
EVT_TEXT_ENTER(wxID_HTML_SEARCHTEXT, wxHtmlHelpController::OnSearch)
|
||||
END_EVENT_TABLE()
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,74 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: search.cpp
|
||||
// Purpose: search engine
|
||||
// Author: Vaclav Slavik
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 1999 Vaclav Slavik
|
||||
// Licence: wxWindows Licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation
|
||||
#endif
|
||||
|
||||
#include "wx/wxprec.h"
|
||||
|
||||
#include "wx/defs.h"
|
||||
#if wxUSE_HTML
|
||||
|
||||
#ifdef __BORDLANDC__
|
||||
#pragma hdrstop
|
||||
#endif
|
||||
|
||||
#ifndef WXPRECOMP
|
||||
#include <wx/wx.h>
|
||||
#endif
|
||||
|
||||
#include "wx/html/helpdata.h"
|
||||
|
||||
|
||||
|
||||
//--------------------------------------------------------------------------------
|
||||
// wxSearchEngine
|
||||
//--------------------------------------------------------------------------------
|
||||
|
||||
void wxSearchEngine::LookFor(const wxString& keyword)
|
||||
{
|
||||
if (m_Keyword) delete[] m_Keyword;
|
||||
m_Keyword = new wxChar[keyword.Length() + 1];
|
||||
wxStrcpy(m_Keyword, keyword.c_str());
|
||||
for (int i = wxStrlen(m_Keyword) - 1; i >= 0; i--)
|
||||
if ((m_Keyword[i] >= wxT('A')) && (m_Keyword[i] <= wxT('Z')))
|
||||
m_Keyword[i] += wxT('a') - wxT('A');
|
||||
}
|
||||
|
||||
|
||||
|
||||
bool wxSearchEngine::Scan(wxInputStream *stream)
|
||||
{
|
||||
wxASSERT_MSG(m_Keyword != NULL, _("wxSearchEngine::LookFor must be called before scanning!"));
|
||||
|
||||
int i, j;
|
||||
int lng = stream ->GetSize();
|
||||
int wrd = wxStrlen(m_Keyword);
|
||||
bool found = FALSE;
|
||||
char *buf = new char[lng + 1];
|
||||
stream -> Read(buf, lng);
|
||||
buf[lng] = 0;
|
||||
|
||||
for (i = 0; i < lng; i++)
|
||||
if ((buf[i] >= 'A') && (buf[i] <= 'Z')) buf[i] += 'a' - 'A';
|
||||
|
||||
for (i = 0; i < lng - wrd; i++) {
|
||||
j = 0;
|
||||
while ((j < wrd) && (buf[i + j] == m_Keyword[j])) j++;
|
||||
if (j == wrd) {found = TRUE; break;}
|
||||
}
|
||||
|
||||
delete[] buf;
|
||||
return found;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -1,68 +0,0 @@
|
||||
#
|
||||
# File: makefile.nt
|
||||
# Author: Julian Smart
|
||||
# Created: 1993
|
||||
# Updated:
|
||||
# Copyright: (c) 1993, AIAI, University of Edinburgh
|
||||
#
|
||||
# "%W% %G%"
|
||||
#
|
||||
# Makefile : Builds winpng.lib library for Windows 3.1
|
||||
|
||||
# Change WXDIR or WXWIN to wherever wxWindows is found
|
||||
WXDIR = $(WXWIN)
|
||||
WXLIB = $(WXDIR)\lib\wx.lib
|
||||
WXINC = $(WXDIR)\include
|
||||
|
||||
WINPNGDIR = ..\png
|
||||
WINPNGINC = $(WINPNGDIR)
|
||||
WINPNGLIB = ..\..\lib\winpng.lib
|
||||
|
||||
INC = /I..\zlib
|
||||
|
||||
FINAL=1
|
||||
|
||||
# Set this to nothing if your compiler is MS C++ 7
|
||||
ZOPTION=
|
||||
|
||||
!ifndef FINAL
|
||||
FINAL=0
|
||||
!endif
|
||||
|
||||
PRECOMP=/YuWX.H
|
||||
|
||||
!if "$(FINAL)" == "0"
|
||||
OPT = /Od
|
||||
CPPFLAGS= /W4 /Zi /MD /GX- $(ZOPTION) $(OPT) /Dwx_msw $(INC) # $(PRECOMP) /Fp$(WXDIR)\src\msw\wx.pch
|
||||
CFLAGS= /W4 /Zi /MD /GX- /Od /Dwx_msw $(INC)
|
||||
LINKFLAGS=/NOD /CO /ONERROR:NOEXE
|
||||
!else
|
||||
# /Ox for real FINAL version
|
||||
OPT = /O2
|
||||
CPPFLAGS= /W4 /MD /GX- /Dwx_msw $(INC) # $(PRECOMP) /Fp$(WXDIR)\src\msw\wx.pch
|
||||
CFLAGS= /W4 /MD /GX- /Dwx_msw $(INC)
|
||||
LINKFLAGS=/NOD /ONERROR:NOEXE
|
||||
!endif
|
||||
|
||||
OBJECTS = png.obj pngread.obj pngrtran.obj pngrutil.obj \
|
||||
pngpread.obj pngtrans.obj pngwrite.obj pngwtran.obj pngwutil.obj \
|
||||
pngerror.obj pngmem.obj pngwio.obj pngrio.obj pngget.obj pngset.obj
|
||||
|
||||
all: $(WINPNGLIB)
|
||||
|
||||
$(WINPNGLIB): $(OBJECTS)
|
||||
erase $(WINPNGLIB)
|
||||
lib @<<
|
||||
-out:$(WINPNGLIB)
|
||||
$(OBJECTS)
|
||||
<<
|
||||
|
||||
.c.obj:
|
||||
cl -DWIN32 $(OPT) $(CFLAGS) /c $*.c
|
||||
|
||||
clean:
|
||||
erase *.obj
|
||||
erase *.exe
|
||||
erase *.lib
|
||||
|
||||
cleanall: clean
|
||||
@@ -1,20 +0,0 @@
|
||||
Copyright 1992, 1993, 1994, 1997 Henry Spencer. All rights reserved.
|
||||
This software is not subject to any license of the American Telephone
|
||||
and Telegraph Company or of the Regents of the University of California.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose on
|
||||
any computer system, and to alter it and redistribute it, subject
|
||||
to the following restrictions:
|
||||
|
||||
1. The author is not responsible for the consequences of use of this
|
||||
software, no matter how awful, even if they arise from flaws in it.
|
||||
|
||||
2. The origin of this software must not be misrepresented, either by
|
||||
explicit claim or by omission. Since few users ever read sources,
|
||||
credits must appear in the documentation.
|
||||
|
||||
3. Altered versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software. Since few users
|
||||
ever read sources, credits must appear in the documentation.
|
||||
|
||||
4. This notice may not be removed or altered.
|
||||
@@ -1,130 +0,0 @@
|
||||
# You probably want to take -DREDEBUG out of CFLAGS, and put something like
|
||||
# -O in, *after* testing (-DREDEBUG strengthens testing by enabling a lot of
|
||||
# internal assertion checking and some debugging facilities).
|
||||
# Put -Dconst= in for a pre-ANSI compiler.
|
||||
# Do not take -DPOSIX_MISTAKE out.
|
||||
# REGCFLAGS isn't important to you (it's for my use in some special contexts).
|
||||
CFLAGS=-I. -DPOSIX_MISTAKE -DREDEBUG $(REGCFLAGS)
|
||||
|
||||
# If you have a pre-ANSI compiler, put -o into MKHFLAGS. If you want
|
||||
# the Berkeley __P macro, put -b in.
|
||||
MKHFLAGS=
|
||||
|
||||
# Flags for linking but not compiling, if any.
|
||||
LDFLAGS=
|
||||
|
||||
# Extra libraries for linking, if any.
|
||||
LIBS=
|
||||
|
||||
# Internal stuff, should not need changing.
|
||||
OBJPRODN=regcomp.o regexec.o regerror.o regfree.o
|
||||
OBJS=$(OBJPRODN) split.o debug.o main.o
|
||||
H=cclass.h cname.h regex2.h utils.h
|
||||
REGSRC=regcomp.c regerror.c regexec.c regfree.c
|
||||
ALLSRC=$(REGSRC) engine.c debug.c main.c split.c
|
||||
|
||||
# Stuff that matters only if you're trying to lint the package.
|
||||
LINTFLAGS=-I. -Dstatic= -Dconst= -DREDEBUG
|
||||
LINTC=regcomp.c regexec.c regerror.c regfree.c debug.c main.c
|
||||
JUNKLINT=possible pointer alignment|null effect
|
||||
|
||||
# arrangements to build forward-reference header files
|
||||
.SUFFIXES: .ih .h
|
||||
.c.ih:
|
||||
sh ./mkh $(MKHFLAGS) -p $< >$@
|
||||
|
||||
default: r
|
||||
|
||||
lib: purge $(OBJPRODN)
|
||||
rm -f libregex.a
|
||||
ar crv libregex.a $(OBJPRODN)
|
||||
|
||||
purge:
|
||||
rm -f *.o
|
||||
|
||||
# stuff to build regex.h
|
||||
REGEXH=regex.h
|
||||
REGEXHSRC=regex2.h $(REGSRC)
|
||||
$(REGEXH): $(REGEXHSRC) mkh
|
||||
sh ./mkh $(MKHFLAGS) -i _REGEX_H_ $(REGEXHSRC) >regex.tmp
|
||||
cmp -s regex.tmp regex.h 2>/dev/null || cp regex.tmp regex.h
|
||||
rm -f regex.tmp
|
||||
|
||||
# dependencies
|
||||
$(OBJPRODN) debug.o: utils.h regex.h regex2.h
|
||||
regcomp.o: cclass.h cname.h regcomp.ih
|
||||
regexec.o: engine.c engine.ih
|
||||
regerror.o: regerror.ih
|
||||
debug.o: debug.ih
|
||||
main.o: main.ih
|
||||
|
||||
# tester
|
||||
re: $(OBJS)
|
||||
$(CC) $(CFLAGS) $(LDFLAGS) $(OBJS) $(LIBS) -o $@
|
||||
|
||||
# regression test
|
||||
r: re tests
|
||||
./re <tests
|
||||
./re -el <tests
|
||||
./re -er <tests
|
||||
|
||||
# 57 variants, and other stuff, for development use -- not useful to you
|
||||
ra: ./re tests
|
||||
-./re <tests
|
||||
-./re -el <tests
|
||||
-./re -er <tests
|
||||
|
||||
rx: ./re tests
|
||||
./re -x <tests
|
||||
./re -x -el <tests
|
||||
./re -x -er <tests
|
||||
|
||||
t: ./re tests
|
||||
-time ./re <tests
|
||||
-time ./re -cs <tests
|
||||
-time ./re -el <tests
|
||||
-time ./re -cs -el <tests
|
||||
|
||||
l: $(LINTC)
|
||||
lint $(LINTFLAGS) -h $(LINTC) 2>&1 | egrep -v '$(JUNKLINT)' | tee lint
|
||||
|
||||
fullprint:
|
||||
ti README WHATSNEW notes todo | list
|
||||
ti *.h | list
|
||||
list *.c
|
||||
list regex.3 regex.7
|
||||
|
||||
print:
|
||||
ti README WHATSNEW notes todo | list
|
||||
ti *.h | list
|
||||
list reg*.c engine.c
|
||||
|
||||
|
||||
mf.tmp: Makefile
|
||||
sed '/^REGEXH=/s/=.*/=regex.h/' Makefile | sed '/#DEL$$/d' >$@
|
||||
|
||||
DTRH=cclass.h cname.h regex2.h utils.h
|
||||
PRE=COPYRIGHT README WHATSNEW
|
||||
POST=mkh regex.3 regex.7 tests $(DTRH) $(ALLSRC) fake/*.[ch]
|
||||
FILES=$(PRE) Makefile $(POST)
|
||||
DTR=$(PRE) Makefile=mf.tmp $(POST)
|
||||
dtr: $(FILES) mf.tmp
|
||||
makedtr $(DTR) >$@
|
||||
rm mf.tmp
|
||||
|
||||
cio: $(FILES)
|
||||
cio $(FILES)
|
||||
|
||||
rdf: $(FILES)
|
||||
rcsdiff -c $(FILES) 2>&1 | p
|
||||
|
||||
# various forms of cleanup
|
||||
tidy:
|
||||
rm -f junk* core core.* *.core dtr *.tmp lint
|
||||
|
||||
clean: tidy
|
||||
rm -f *.o *.s *.ih re libregex.a
|
||||
|
||||
# don't do this one unless you know what you're doing
|
||||
spotless: clean
|
||||
rm -f mkh regex.h
|
||||
@@ -1,32 +0,0 @@
|
||||
alpha3.8 release.
|
||||
Tue Aug 10 15:51:48 EDT 1999
|
||||
henry@spsystems.net (formerly henry@zoo.toronto.edu)
|
||||
|
||||
See WHATSNEW for change listing.
|
||||
|
||||
installation notes:
|
||||
--------
|
||||
Read the comments at the beginning of Makefile before running.
|
||||
|
||||
Utils.h contains some things that just might have to be modified on
|
||||
some systems, as well as a nested include (ugh) of <assert.h>.
|
||||
|
||||
The "fake" directory contains quick-and-dirty fakes for some header
|
||||
files and routines that old systems may not have. Note also that
|
||||
-DUSEBCOPY will make utils.h substitute bcopy() for memmove().
|
||||
|
||||
After that, "make r" will build regcomp.o, regexec.o, regfree.o,
|
||||
and regerror.o (the actual routines), bundle them together into a test
|
||||
program, and run regression tests on them. No output is good output.
|
||||
|
||||
"make lib" builds just the .o files for the actual routines (when
|
||||
you're happy with testing and have adjusted CFLAGS for production),
|
||||
and puts them together into libregex.a. You can pick up either the
|
||||
library or *.o ("make lib" makes sure there are no other .o files left
|
||||
around to confuse things).
|
||||
|
||||
Main.c, debug.c, split.c are used for regression testing but are not part
|
||||
of the RE routines themselves.
|
||||
|
||||
Regex.h goes in /usr/include. All other .h files are internal only.
|
||||
--------
|
||||
@@ -1,108 +0,0 @@
|
||||
New in alpha3.8: Bug fix for signed/unsigned mixup, found and fixed
|
||||
by the FreeBSD folks.
|
||||
|
||||
New in alpha3.7: A bit of cleanup aimed at maximizing portability,
|
||||
possibly at slight cost in efficiency. "ul" suffixes and "unsigned long"
|
||||
no longer appear, in particular.
|
||||
|
||||
New in alpha3.6: A couple more portability glitches fixed.
|
||||
|
||||
New in alpha3.5: Active development of this code has been stopped --
|
||||
I'm working on a complete reimplementation -- but folks have found some
|
||||
minor portability glitches and the like, hence this release to fix them.
|
||||
One penalty: slightly reduced compatibility with old compilers, because
|
||||
the ANSI C `unsigned long' type and `ul' constant suffix are used in a
|
||||
few places (I could avoid this but it would be considerably more work).
|
||||
|
||||
New in alpha3.4: The complex bug alluded to below has been fixed (in a
|
||||
slightly kludgey temporary way that may hurt efficiency a bit; this is
|
||||
another "get it out the door for 4.4" release). The tests at the end of
|
||||
the tests file have accordingly been uncommented. The primary sign of
|
||||
the bug was that something like a?b matching ab matched b rather than ab.
|
||||
(The bug was essentially specific to this exact situation, else it would
|
||||
have shown up earlier.)
|
||||
|
||||
New in alpha3.3: The definition of word boundaries has been altered
|
||||
slightly, to more closely match the usual programming notion that "_"
|
||||
is an alphabetic. Stuff used for pre-ANSI systems is now in a subdir,
|
||||
and the makefile no longer alludes to it in mysterious ways. The
|
||||
makefile has generally been cleaned up some. Fixes have been made
|
||||
(again!) so that the regression test will run without -DREDEBUG, at
|
||||
the cost of weaker checking. A workaround for a bug in some folks'
|
||||
<assert.h> has been added. And some more things have been added to
|
||||
tests, including a couple right at the end which are commented out
|
||||
because the code currently flunks them (complex bug; fix coming).
|
||||
Plus the usual minor cleanup.
|
||||
|
||||
New in alpha3.2: Assorted bits of cleanup and portability improvement
|
||||
(the development base is now a BSDI system using GCC instead of an ancient
|
||||
Sun system, and the newer compiler exposed some glitches). Fix for a
|
||||
serious bug that affected REs using many [] (including REG_ICASE REs
|
||||
because of the way they are implemented), *sometimes*, depending on
|
||||
memory-allocation patterns. The header-file prototypes no longer name
|
||||
the parameters, avoiding possible name conflicts. The possibility that
|
||||
some clot has defined CHAR_MIN as (say) `-128' instead of `(-128)' is
|
||||
now handled gracefully. "uchar" is no longer used as an internal type
|
||||
name (too many people have the same idea). Still the same old lousy
|
||||
performance, alas.
|
||||
|
||||
New in alpha3.1: Basically nothing, this release is just a bookkeeping
|
||||
convenience. Stay tuned.
|
||||
|
||||
New in alpha3.0: Performance is no better, alas, but some fixes have been
|
||||
made and some functionality has been added. (This is basically the "get
|
||||
it out the door in time for 4.4" release.) One bug fix: regfree() didn't
|
||||
free the main internal structure (how embarrassing). It is now possible
|
||||
to put NULs in either the RE or the target string, using (resp.) a new
|
||||
REG_PEND flag and the old REG_STARTEND flag. The REG_NOSPEC flag to
|
||||
regcomp() makes all characters ordinary, so you can match a literal
|
||||
string easily (this will become more useful when performance improves!).
|
||||
There are now primitives to match beginnings and ends of words, although
|
||||
the syntax is disgusting and so is the implementation. The REG_ATOI
|
||||
debugging interface has changed a bit. And there has been considerable
|
||||
internal cleanup of various kinds.
|
||||
|
||||
New in alpha2.3: Split change list out of README, and moved flags notes
|
||||
into Makefile. Macro-ized the name of regex(7) in regex(3), since it has
|
||||
to change for 4.4BSD. Cleanup work in engine.c, and some new regression
|
||||
tests to catch tricky cases thereof.
|
||||
|
||||
New in alpha2.2: Out-of-date manpages updated. Regerror() acquires two
|
||||
small extensions -- REG_ITOA and REG_ATOI -- which avoid debugging kludges
|
||||
in my own test program and might be useful to others for similar purposes.
|
||||
The regression test will now compile (and run) without REDEBUG. The
|
||||
BRE \$ bug is fixed. Most uses of "uchar" are gone; it's all chars now.
|
||||
Char/uchar parameters are now written int/unsigned, to avoid possible
|
||||
portability problems with unpromoted parameters. Some unsigned casts have
|
||||
been introduced to minimize portability problems with shifting into sign
|
||||
bits.
|
||||
|
||||
New in alpha2.1: Lots of little stuff, cleanup and fixes. The one big
|
||||
thing is that regex.h is now generated, using mkh, rather than being
|
||||
supplied in the distribution; due to circularities in dependencies,
|
||||
you have to build regex.h explicitly by "make h". The two known bugs
|
||||
have been fixed (and the regression test now checks for them), as has a
|
||||
problem with assertions not being suppressed in the absence of REDEBUG.
|
||||
No performance work yet.
|
||||
|
||||
New in alpha2: Backslash-anything is an ordinary character, not an
|
||||
error (except, of course, for the handful of backslashed metacharacters
|
||||
in BREs), which should reduce script breakage. The regression test
|
||||
checks *where* null strings are supposed to match, and has generally
|
||||
been tightened up somewhat. Small bug fixes in parameter passing (not
|
||||
harmful, but technically errors) and some other areas. Debugging
|
||||
invoked by defining REDEBUG rather than not defining NDEBUG.
|
||||
|
||||
New in alpha+3: full prototyping for internal routines, using a little
|
||||
helper program, mkh, which extracts prototypes given in stylized comments.
|
||||
More minor cleanup. Buglet fix: it's CHAR_BIT, not CHAR_BITS. Simple
|
||||
pre-screening of input when a literal string is known to be part of the
|
||||
RE; this does wonders for performance.
|
||||
|
||||
New in alpha+2: minor bits of cleanup. Notably, the number "32" for the
|
||||
word width isn't hardwired into regexec.c any more, the public header
|
||||
file prototypes the functions if __STDC__ is defined, and some small typos
|
||||
in the manpages have been fixed.
|
||||
|
||||
New in alpha+1: improvements to the manual pages, and an important
|
||||
extension, the REG_STARTEND option to regexec().
|
||||
@@ -1,31 +0,0 @@
|
||||
/* character-class table */
|
||||
static struct cclass {
|
||||
char *name;
|
||||
char *chars;
|
||||
char *multis;
|
||||
} cclasses[] = {
|
||||
"alnum", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
|
||||
0123456789", "",
|
||||
"alpha", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
|
||||
"",
|
||||
"blank", " \t", "",
|
||||
"cntrl", "\007\b\t\n\v\f\r\1\2\3\4\5\6\16\17\20\21\22\23\24\
|
||||
\25\26\27\30\31\32\33\34\35\36\37\177", "",
|
||||
"digit", "0123456789", "",
|
||||
"graph", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
|
||||
0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
|
||||
"",
|
||||
"lower", "abcdefghijklmnopqrstuvwxyz",
|
||||
"",
|
||||
"print", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
|
||||
0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ",
|
||||
"",
|
||||
"punct", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
|
||||
"",
|
||||
"space", "\t\n\v\f\r ", "",
|
||||
"upper", "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
|
||||
"",
|
||||
"xdigit", "0123456789ABCDEFabcdef",
|
||||
"",
|
||||
NULL, 0, ""
|
||||
};
|
||||
@@ -1,102 +0,0 @@
|
||||
/* character-name table */
|
||||
static struct cname {
|
||||
char *name;
|
||||
char code;
|
||||
} cnames[] = {
|
||||
"NUL", '\0',
|
||||
"SOH", '\001',
|
||||
"STX", '\002',
|
||||
"ETX", '\003',
|
||||
"EOT", '\004',
|
||||
"ENQ", '\005',
|
||||
"ACK", '\006',
|
||||
"BEL", '\007',
|
||||
"alert", '\007',
|
||||
"BS", '\010',
|
||||
"backspace", '\b',
|
||||
"HT", '\011',
|
||||
"tab", '\t',
|
||||
"LF", '\012',
|
||||
"newline", '\n',
|
||||
"VT", '\013',
|
||||
"vertical-tab", '\v',
|
||||
"FF", '\014',
|
||||
"form-feed", '\f',
|
||||
"CR", '\015',
|
||||
"carriage-return", '\r',
|
||||
"SO", '\016',
|
||||
"SI", '\017',
|
||||
"DLE", '\020',
|
||||
"DC1", '\021',
|
||||
"DC2", '\022',
|
||||
"DC3", '\023',
|
||||
"DC4", '\024',
|
||||
"NAK", '\025',
|
||||
"SYN", '\026',
|
||||
"ETB", '\027',
|
||||
"CAN", '\030',
|
||||
"EM", '\031',
|
||||
"SUB", '\032',
|
||||
"ESC", '\033',
|
||||
"IS4", '\034',
|
||||
"FS", '\034',
|
||||
"IS3", '\035',
|
||||
"GS", '\035',
|
||||
"IS2", '\036',
|
||||
"RS", '\036',
|
||||
"IS1", '\037',
|
||||
"US", '\037',
|
||||
"space", ' ',
|
||||
"exclamation-mark", '!',
|
||||
"quotation-mark", '"',
|
||||
"number-sign", '#',
|
||||
"dollar-sign", '$',
|
||||
"percent-sign", '%',
|
||||
"ampersand", '&',
|
||||
"apostrophe", '\'',
|
||||
"left-parenthesis", '(',
|
||||
"right-parenthesis", ')',
|
||||
"asterisk", '*',
|
||||
"plus-sign", '+',
|
||||
"comma", ',',
|
||||
"hyphen", '-',
|
||||
"hyphen-minus", '-',
|
||||
"period", '.',
|
||||
"full-stop", '.',
|
||||
"slash", '/',
|
||||
"solidus", '/',
|
||||
"zero", '0',
|
||||
"one", '1',
|
||||
"two", '2',
|
||||
"three", '3',
|
||||
"four", '4',
|
||||
"five", '5',
|
||||
"six", '6',
|
||||
"seven", '7',
|
||||
"eight", '8',
|
||||
"nine", '9',
|
||||
"colon", ':',
|
||||
"semicolon", ';',
|
||||
"less-than-sign", '<',
|
||||
"equals-sign", '=',
|
||||
"greater-than-sign", '>',
|
||||
"question-mark", '?',
|
||||
"commercial-at", '@',
|
||||
"left-square-bracket", '[',
|
||||
"backslash", '\\',
|
||||
"reverse-solidus", '\\',
|
||||
"right-square-bracket", ']',
|
||||
"circumflex", '^',
|
||||
"circumflex-accent", '^',
|
||||
"underscore", '_',
|
||||
"low-line", '_',
|
||||
"grave-accent", '`',
|
||||
"left-brace", '{',
|
||||
"left-curly-bracket", '{',
|
||||
"vertical-line", '|',
|
||||
"right-brace", '}',
|
||||
"right-curly-bracket", '}',
|
||||
"tilde", '~',
|
||||
"DEL", '\177',
|
||||
NULL, 0,
|
||||
};
|
||||
@@ -1,35 +0,0 @@
|
||||
/* ========= begin header generated by ./mkh ========= */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* === engine.c === */
|
||||
static int matcher(register struct re_guts *g, char *string, size_t nmatch, regmatch_t pmatch[], int eflags);
|
||||
static char *dissect(register struct match *m, char *start, char *stop, sopno startst, sopno stopst);
|
||||
static char *backref(register struct match *m, char *start, char *stop, sopno startst, sopno stopst, sopno lev);
|
||||
static char *fast(register struct match *m, char *start, char *stop, sopno startst, sopno stopst);
|
||||
static char *slow(register struct match *m, char *start, char *stop, sopno startst, sopno stopst);
|
||||
static states step(register struct re_guts *g, sopno start, sopno stop, register states bef, int ch, register states aft);
|
||||
#define BOL (OUT+1)
|
||||
#define EOL (BOL+1)
|
||||
#define BOLEOL (BOL+2)
|
||||
#define NOTHING (BOL+3)
|
||||
#define BOW (BOL+4)
|
||||
#define EOW (BOL+5)
|
||||
#define CODEMAX (BOL+5) /* highest code used */
|
||||
#define NONCHAR(c) ((c) > CHAR_MAX)
|
||||
#define NNONCHAR (CODEMAX-CHAR_MAX)
|
||||
#ifdef REDEBUG
|
||||
static void print(struct match *m, char *caption, states st, int ch, FILE *d);
|
||||
#endif
|
||||
#ifdef REDEBUG
|
||||
static void at(struct match *m, char *title, char *start, char *stop, sopno startst, sopno stopst);
|
||||
#endif
|
||||
#ifdef REDEBUG
|
||||
static char *pchar(int ch);
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/* ========= end header generated by ./mkh ========= */
|
||||
@@ -1,76 +0,0 @@
|
||||
#! /bin/sh
|
||||
# mkh - pull headers out of C source
|
||||
PATH=/bin:/usr/bin ; export PATH
|
||||
|
||||
# egrep pattern to pick out marked lines
|
||||
egrep='^ =([ ]|$)'
|
||||
|
||||
# Sed program to process marked lines into lines for the header file.
|
||||
# The markers have already been removed. Two things are done here: removal
|
||||
# of backslashed newlines, and some fudging of comments. The first is done
|
||||
# because -o needs to have prototypes on one line to strip them down.
|
||||
# Getting comments into the output is tricky; we turn C++-style // comments
|
||||
# into /* */ comments, after altering any existing */'s to avoid trouble.
|
||||
peel=' /\\$/N
|
||||
/\\\n[ ]*/s///g
|
||||
/\/\//s;\*/;* /;g
|
||||
/\/\//s;//\(.*\);/*\1 */;'
|
||||
|
||||
for a
|
||||
do
|
||||
case "$a" in
|
||||
-o) # old (pre-function-prototype) compiler
|
||||
# add code to comment out argument lists
|
||||
peel="$peel
|
||||
"'/^\([^#\/][^\/]*[a-zA-Z0-9_)]\)(\(.*\))/s;;\1(/*\2*/);'
|
||||
shift
|
||||
;;
|
||||
-b) # funny Berkeley __P macro
|
||||
peel="$peel
|
||||
"'/^\([^#\/][^\/]*[a-zA-Z0-9_)]\)(\(.*\))/s;;\1 __P((\2));'
|
||||
shift
|
||||
;;
|
||||
-s) # compiler doesn't like `static foo();'
|
||||
# add code to get rid of the `static'
|
||||
peel="$peel
|
||||
"'/^static[ ][^\/]*[a-zA-Z0-9_)](.*)/s;static.;;'
|
||||
shift
|
||||
;;
|
||||
-p) # private declarations
|
||||
egrep='^ ==([ ]|$)'
|
||||
shift
|
||||
;;
|
||||
-i) # wrap in #ifndef, argument is name
|
||||
ifndef="$2"
|
||||
shift ; shift
|
||||
;;
|
||||
*) break
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
if test " $ifndef" != " "
|
||||
then
|
||||
echo "#ifndef $ifndef"
|
||||
echo "#define $ifndef /* never again */"
|
||||
fi
|
||||
echo "/* ========= begin header generated by $0 ========= */"
|
||||
echo '#ifdef __cplusplus'
|
||||
echo 'extern "C" {'
|
||||
echo '#endif'
|
||||
for f
|
||||
do
|
||||
echo
|
||||
echo "/* === $f === */"
|
||||
egrep "$egrep" $f | sed 's/^ ==*[ ]//;s/^ ==*$//' | sed "$peel"
|
||||
echo
|
||||
done
|
||||
echo '#ifdef __cplusplus'
|
||||
echo '}'
|
||||
echo '#endif'
|
||||
echo "/* ========= end header generated by $0 ========= */"
|
||||
if test " $ifndef" != " "
|
||||
then
|
||||
echo "#endif"
|
||||
fi
|
||||
exit 0
|
||||
@@ -1,970 +0,0 @@
|
||||
'\"
|
||||
'\" Copyright (c) 1998 Sun Microsystems, Inc.
|
||||
'\" Copyright (c) 1999 Scriptics Corporation
|
||||
'\"
|
||||
'\" This software is copyrighted by the Regents of the University of
|
||||
'\" California, Sun Microsystems, Inc., Scriptics Corporation, ActiveState
|
||||
'\" Corporation and other parties. The following terms apply to all files
|
||||
'\" associated with the software unless explicitly disclaimed in
|
||||
'\" individual files.
|
||||
'\"
|
||||
'\" The authors hereby grant permission to use, copy, modify, distribute,
|
||||
'\" and license this software and its documentation for any purpose, provided
|
||||
'\" that existing copyright notices are retained in all copies and that this
|
||||
'\" notice is included verbatim in any distributions. No written agreement,
|
||||
'\" license, or royalty fee is required for any of the authorized uses.
|
||||
'\" Modifications to this software may be copyrighted by their authors
|
||||
'\" and need not follow the licensing terms described here, provided that
|
||||
'\" the new terms are clearly indicated on the first page of each file where
|
||||
'\" they apply.
|
||||
'\"
|
||||
'\" IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
|
||||
'\" FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
|
||||
'\" ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
|
||||
'\" DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
|
||||
'\" POSSIBILITY OF SUCH DAMAGE.
|
||||
'\"
|
||||
'\" THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
|
||||
'\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
|
||||
'\" FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE
|
||||
'\" IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
|
||||
'\" NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
|
||||
'\" MODIFICATIONS.
|
||||
'\"
|
||||
'\" GOVERNMENT USE: If you are acquiring this software on behalf of the
|
||||
'\" U.S. government, the Government shall have only "Restricted Rights"
|
||||
'\" in the software and related documentation as defined in the Federal
|
||||
'\" Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2). If you
|
||||
'\" are acquiring the software on behalf of the Department of Defense, the
|
||||
'\" software shall be classified as "Commercial Computer Software" and the
|
||||
'\" Government shall have only "Restricted Rights" as defined in Clause
|
||||
'\" 252.227-7013 (c) (1) of DFARs. Notwithstanding the foregoing, the
|
||||
'\" authors grant the U.S. Government and others acting in its behalf
|
||||
'\" permission to use and distribute the software in accordance with the
|
||||
'\" terms specified in this license.
|
||||
'\"
|
||||
'\" RCS: @(#) Id: re_syntax.n,v 1.3 1999/07/14 19:09:36 jpeek Exp
|
||||
'\"
|
||||
.so man.macros
|
||||
.TH re_syntax n "8.1" Tcl "Tcl Built-In Commands"
|
||||
.BS
|
||||
.SH NAME
|
||||
re_syntax \- Syntax of Tcl regular expressions.
|
||||
.BE
|
||||
|
||||
.SH DESCRIPTION
|
||||
.PP
|
||||
A \fIregular expression\fR describes strings of characters.
|
||||
It's a pattern that matches certain strings and doesn't match others.
|
||||
|
||||
.SH "DIFFERENT FLAVORS OF REs"
|
||||
Regular expressions (``RE''s), as defined by POSIX, come in two
|
||||
flavors: \fIextended\fR REs (``EREs'') and \fIbasic\fR REs (``BREs'').
|
||||
EREs are roughly those of the traditional \fIegrep\fR, while BREs are
|
||||
roughly those of the traditional \fIed\fR. This implementation adds
|
||||
a third flavor, \fIadvanced\fR REs (``AREs''), basically EREs with
|
||||
some significant extensions.
|
||||
.PP
|
||||
This manual page primarily describes AREs. BREs mostly exist for
|
||||
backward compatibility in some old programs; they will be discussed at
|
||||
the end. POSIX EREs are almost an exact subset of AREs. Features of
|
||||
AREs that are not present in EREs will be indicated.
|
||||
|
||||
.SH "REGULAR EXPRESSION SYNTAX"
|
||||
.PP
|
||||
Tcl regular expressions are implemented using the package written by
|
||||
Henry Spencer, based on the 1003.2 spec and some (not quite all) of
|
||||
the Perl5 extensions (thanks, Henry!). Much of the description of
|
||||
regular expressions below is copied verbatim from his manual entry.
|
||||
.PP
|
||||
An ARE is one or more \fIbranches\fR,
|
||||
separated by `\fB|\fR',
|
||||
matching anything that matches any of the branches.
|
||||
.PP
|
||||
A branch is zero or more \fIconstraints\fR or \fIquantified atoms\fR,
|
||||
concatenated.
|
||||
It matches a match for the first, followed by a match for the second, etc;
|
||||
an empty branch matches the empty string.
|
||||
.PP
|
||||
A quantified atom is an \fIatom\fR possibly followed
|
||||
by a single \fIquantifier\fR.
|
||||
Without a quantifier, it matches a match for the atom.
|
||||
The quantifiers,
|
||||
and what a so-quantified atom matches, are:
|
||||
.RS 2
|
||||
.TP 6
|
||||
\fB*\fR
|
||||
a sequence of 0 or more matches of the atom
|
||||
.TP
|
||||
\fB+\fR
|
||||
a sequence of 1 or more matches of the atom
|
||||
.TP
|
||||
\fB?\fR
|
||||
a sequence of 0 or 1 matches of the atom
|
||||
.TP
|
||||
\fB{\fIm\fB}\fR
|
||||
a sequence of exactly \fIm\fR matches of the atom
|
||||
.TP
|
||||
\fB{\fIm\fB,}\fR
|
||||
a sequence of \fIm\fR or more matches of the atom
|
||||
.TP
|
||||
\fB{\fIm\fB,\fIn\fB}\fR
|
||||
a sequence of \fIm\fR through \fIn\fR (inclusive) matches of the atom;
|
||||
\fIm\fR may not exceed \fIn\fR
|
||||
.TP
|
||||
\fB*? +? ?? {\fIm\fB}? {\fIm\fB,}? {\fIm\fB,\fIn\fB}?\fR
|
||||
\fInon-greedy\fR quantifiers,
|
||||
which match the same possibilities,
|
||||
but prefer the smallest number rather than the largest number
|
||||
of matches (see MATCHING)
|
||||
.RE
|
||||
.PP
|
||||
The forms using
|
||||
\fB{\fR and \fB}\fR
|
||||
are known as \fIbound\fRs.
|
||||
The numbers
|
||||
\fIm\fR and \fIn\fR are unsigned decimal integers
|
||||
with permissible values from 0 to 255 inclusive.
|
||||
.PP
|
||||
An atom is one of:
|
||||
.RS 2
|
||||
.TP 6
|
||||
\fB(\fIre\fB)\fR
|
||||
(where \fIre\fR is any regular expression)
|
||||
matches a match for
|
||||
\fIre\fR, with the match noted for possible reporting
|
||||
.TP
|
||||
\fB(?:\fIre\fB)\fR
|
||||
as previous,
|
||||
but does no reporting
|
||||
(a ``non-capturing'' set of parentheses)
|
||||
.TP
|
||||
\fB()\fR
|
||||
matches an empty string,
|
||||
noted for possible reporting
|
||||
.TP
|
||||
\fB(?:)\fR
|
||||
matches an empty string,
|
||||
without reporting
|
||||
.TP
|
||||
\fB[\fIchars\fB]\fR
|
||||
a \fIbracket expression\fR,
|
||||
matching any one of the \fIchars\fR (see BRACKET EXPRESSIONS for more detail)
|
||||
.TP
|
||||
\fB.\fR
|
||||
matches any single character
|
||||
.TP
|
||||
\fB\e\fIk\fR
|
||||
(where \fIk\fR is a non-alphanumeric character)
|
||||
matches that character taken as an ordinary character,
|
||||
e.g. \e\e matches a backslash character
|
||||
.TP
|
||||
\fB\e\fIc\fR
|
||||
where \fIc\fR is alphanumeric
|
||||
(possibly followed by other characters),
|
||||
an \fIescape\fR (AREs only),
|
||||
see ESCAPES below
|
||||
.TP
|
||||
\fB{\fR
|
||||
when followed by a character other than a digit,
|
||||
matches the left-brace character `\fB{\fR';
|
||||
when followed by a digit, it is the beginning of a
|
||||
\fIbound\fR (see above)
|
||||
.TP
|
||||
\fIx\fR
|
||||
where \fIx\fR is
|
||||
a single character with no other significance, matches that character.
|
||||
.RE
|
||||
.PP
|
||||
A \fIconstraint\fR matches an empty string when specific conditions
|
||||
are met.
|
||||
A constraint may not be followed by a quantifier.
|
||||
The simple constraints are as follows; some more constraints are
|
||||
described later, under ESCAPES.
|
||||
.RS 2
|
||||
.TP 8
|
||||
\fB^\fR
|
||||
matches at the beginning of a line
|
||||
.TP
|
||||
\fB$\fR
|
||||
matches at the end of a line
|
||||
.TP
|
||||
\fB(?=\fIre\fB)\fR
|
||||
\fIpositive lookahead\fR (AREs only), matches at any point
|
||||
where a substring matching \fIre\fR begins
|
||||
.TP
|
||||
\fB(?!\fIre\fB)\fR
|
||||
\fInegative lookahead\fR (AREs only), matches at any point
|
||||
where no substring matching \fIre\fR begins
|
||||
.RE
|
||||
.PP
|
||||
The lookahead constraints may not contain back references (see later),
|
||||
and all parentheses within them are considered non-capturing.
|
||||
.PP
|
||||
An RE may not end with `\fB\e\fR'.
|
||||
|
||||
.SH "BRACKET EXPRESSIONS"
|
||||
A \fIbracket expression\fR is a list of characters enclosed in `\fB[\|]\fR'.
|
||||
It normally matches any single character from the list (but see below).
|
||||
If the list begins with `\fB^\fR',
|
||||
it matches any single character
|
||||
(but see below) \fInot\fR from the rest of the list.
|
||||
.PP
|
||||
If two characters in the list are separated by `\fB\-\fR',
|
||||
this is shorthand
|
||||
for the full \fIrange\fR of characters between those two (inclusive) in the
|
||||
collating sequence,
|
||||
e.g.
|
||||
\fB[0\-9]\fR
|
||||
in ASCII matches any decimal digit.
|
||||
Two ranges may not share an
|
||||
endpoint, so e.g.
|
||||
\fBa\-c\-e\fR
|
||||
is illegal.
|
||||
Ranges are very collating-sequence-dependent,
|
||||
and portable programs should avoid relying on them.
|
||||
.PP
|
||||
To include a literal
|
||||
\fB]\fR
|
||||
or
|
||||
\fB\-\fR
|
||||
in the list,
|
||||
the simplest method is to
|
||||
enclose it in
|
||||
\fB[.\fR and \fB.]\fR
|
||||
to make it a collating element (see below).
|
||||
Alternatively,
|
||||
make it the first character
|
||||
(following a possible `\fB^\fR'),
|
||||
or (AREs only) precede it with `\fB\e\fR'.
|
||||
Alternatively, for `\fB\-\fR',
|
||||
make it the last character,
|
||||
or the second endpoint of a range.
|
||||
To use a literal
|
||||
\fB\-\fR
|
||||
as the first endpoint of a range,
|
||||
make it a collating element
|
||||
or (AREs only) precede it with `\fB\e\fR'.
|
||||
With the exception of these, some combinations using
|
||||
\fB[\fR
|
||||
(see next
|
||||
paragraphs), and escapes,
|
||||
all other special characters lose their
|
||||
special significance within a bracket expression.
|
||||
.PP
|
||||
Within a bracket expression, a collating element (a character,
|
||||
a multi-character sequence that collates as if it were a single character,
|
||||
or a collating-sequence name for either)
|
||||
enclosed in
|
||||
\fB[.\fR and \fB.]\fR
|
||||
stands for the
|
||||
sequence of characters of that collating element.
|
||||
The sequence is a single element of the bracket expression's list.
|
||||
A bracket expression in a locale that has
|
||||
multi-character collating elements
|
||||
can thus match more than one character.
|
||||
.VS 8.2
|
||||
So (insidiously), a bracket expression that starts with \fB^\fR
|
||||
can match multi-character collating elements even if none of them
|
||||
appear in the bracket expression!
|
||||
(\fINote:\fR Tcl currently has no multi-character collating elements.
|
||||
This information is only for illustration.)
|
||||
.PP
|
||||
For example, assume the collating sequence includes a \fBch\fR
|
||||
multi-character collating element.
|
||||
Then the RE \fB[[.ch.]]*c\fR (zero or more \fBch\fP's followed by \fBc\fP)
|
||||
matches the first five characters of `\fBchchcc\fR'.
|
||||
Also, the RE \fB[^c]b\fR matches all of `\fBchb\fR'
|
||||
(because \fB[^c]\fR matches the multi-character \fBch\fR).
|
||||
.VE 8.2
|
||||
.PP
|
||||
Within a bracket expression, a collating element enclosed in
|
||||
\fB[=\fR
|
||||
and
|
||||
\fB=]\fR
|
||||
is an equivalence class, standing for the sequences of characters
|
||||
of all collating elements equivalent to that one, including itself.
|
||||
(If there are no other equivalent collating elements,
|
||||
the treatment is as if the enclosing delimiters were `\fB[.\fR'\&
|
||||
and `\fB.]\fR'.)
|
||||
For example, if
|
||||
\fBo\fR
|
||||
and
|
||||
\fB\o'o^'\fR
|
||||
are the members of an equivalence class,
|
||||
then `\fB[[=o=]]\fR', `\fB[[=\o'o^'=]]\fR',
|
||||
and `\fB[o\o'o^']\fR'\&
|
||||
are all synonymous.
|
||||
An equivalence class may not be an endpoint
|
||||
of a range.
|
||||
.VS 8.2
|
||||
(\fINote:\fR
|
||||
Tcl currently implements only the Unicode locale.
|
||||
It doesn't define any equivalence classes.
|
||||
The examples above are just illustrations.)
|
||||
.VE 8.2
|
||||
.PP
|
||||
Within a bracket expression, the name of a \fIcharacter class\fR enclosed
|
||||
in
|
||||
\fB[:\fR
|
||||
and
|
||||
\fB:]\fR
|
||||
stands for the list of all characters
|
||||
(not all collating elements!)
|
||||
belonging to that
|
||||
class.
|
||||
Standard character classes are:
|
||||
.PP
|
||||
.RS
|
||||
.ne 5
|
||||
.nf
|
||||
.ta 3c
|
||||
\fBalpha\fR A letter.
|
||||
\fBupper\fR An upper-case letter.
|
||||
\fBlower\fR A lower-case letter.
|
||||
\fBdigit\fR A decimal digit.
|
||||
\fBxdigit\fR A hexadecimal digit.
|
||||
\fBalnum\fR An alphanumeric (letter or digit).
|
||||
\fBprint\fR An alphanumeric (same as alnum).
|
||||
\fBblank\fR A space or tab character.
|
||||
\fBspace\fR A character producing white space in displayed text.
|
||||
\fBpunct\fR A punctuation character.
|
||||
\fBgraph\fR A character with a visible representation.
|
||||
\fBcntrl\fR A control character.
|
||||
.fi
|
||||
.RE
|
||||
.PP
|
||||
A locale may provide others.
|
||||
.VS 8.2
|
||||
(Note that the current Tcl implementation has only one locale:
|
||||
the Unicode locale.)
|
||||
.VE 8.2
|
||||
A character class may not be used as an endpoint of a range.
|
||||
.PP
|
||||
There are two special cases of bracket expressions:
|
||||
the bracket expressions
|
||||
\fB[[:<:]]\fR
|
||||
and
|
||||
\fB[[:>:]]\fR
|
||||
are constraints, matching empty strings at
|
||||
the beginning and end of a word respectively.
|
||||
'\" note, discussion of escapes below references this definition of word
|
||||
A word is defined as a sequence of
|
||||
word characters
|
||||
that is neither preceded nor followed by
|
||||
word characters.
|
||||
A word character is an
|
||||
\fIalnum\fR
|
||||
character
|
||||
or an underscore
|
||||
(\fB_\fR).
|
||||
These special bracket expressions are deprecated;
|
||||
users of AREs should use constraint escapes instead (see below).
|
||||
.SH ESCAPES
|
||||
Escapes (AREs only), which begin with a
|
||||
\fB\e\fR
|
||||
followed by an alphanumeric character,
|
||||
come in several varieties:
|
||||
character entry, class shorthands, constraint escapes, and back references.
|
||||
A
|
||||
\fB\e\fR
|
||||
followed by an alphanumeric character but not constituting
|
||||
a valid escape is illegal in AREs.
|
||||
In EREs, there are no escapes:
|
||||
outside a bracket expression,
|
||||
a
|
||||
\fB\e\fR
|
||||
followed by an alphanumeric character merely stands for that
|
||||
character as an ordinary character,
|
||||
and inside a bracket expression,
|
||||
\fB\e\fR
|
||||
is an ordinary character.
|
||||
(The latter is the one actual incompatibility between EREs and AREs.)
|
||||
.PP
|
||||
Character-entry escapes (AREs only) exist to make it easier to specify
|
||||
non-printing and otherwise inconvenient characters in REs:
|
||||
.RS 2
|
||||
.TP 5
|
||||
\fB\ea\fR
|
||||
alert (bell) character, as in C
|
||||
.TP
|
||||
\fB\eb\fR
|
||||
backspace, as in C
|
||||
.TP
|
||||
\fB\eB\fR
|
||||
synonym for
|
||||
\fB\e\fR
|
||||
to help reduce backslash doubling in some
|
||||
applications where there are multiple levels of backslash processing
|
||||
.TP
|
||||
\fB\ec\fIX\fR
|
||||
(where X is any character) the character whose
|
||||
low-order 5 bits are the same as those of
|
||||
\fIX\fR,
|
||||
and whose other bits are all zero
|
||||
.TP
|
||||
\fB\ee\fR
|
||||
the character whose collating-sequence name
|
||||
is `\fBESC\fR',
|
||||
or failing that, the character with octal value 033
|
||||
.TP
|
||||
\fB\ef\fR
|
||||
formfeed, as in C
|
||||
.TP
|
||||
\fB\en\fR
|
||||
newline, as in C
|
||||
.TP
|
||||
\fB\er\fR
|
||||
carriage return, as in C
|
||||
.TP
|
||||
\fB\et\fR
|
||||
horizontal tab, as in C
|
||||
.TP
|
||||
\fB\eu\fIwxyz\fR
|
||||
(where
|
||||
\fIwxyz\fR
|
||||
is exactly four hexadecimal digits)
|
||||
the Unicode character
|
||||
\fBU+\fIwxyz\fR
|
||||
in the local byte ordering
|
||||
.TP
|
||||
\fB\eU\fIstuvwxyz\fR
|
||||
(where
|
||||
\fIstuvwxyz\fR
|
||||
is exactly eight hexadecimal digits)
|
||||
reserved for a somewhat-hypothetical Unicode extension to 32 bits
|
||||
.TP
|
||||
\fB\ev\fR
|
||||
vertical tab, as in C
|
||||
are all available.
|
||||
.TP
|
||||
\fB\ex\fIhhh\fR
|
||||
(where
|
||||
\fIhhh\fR
|
||||
is any sequence of hexadecimal digits)
|
||||
the character whose hexadecimal value is
|
||||
\fB0x\fIhhh\fR
|
||||
(a single character no matter how many hexadecimal digits are used).
|
||||
.TP
|
||||
\fB\e0\fR
|
||||
the character whose value is
|
||||
\fB0\fR
|
||||
.TP
|
||||
\fB\e\fIxy\fR
|
||||
(where
|
||||
\fIxy\fR
|
||||
is exactly two octal digits,
|
||||
and is not a
|
||||
\fIback reference\fR (see below))
|
||||
the character whose octal value is
|
||||
\fB0\fIxy\fR
|
||||
.TP
|
||||
\fB\e\fIxyz\fR
|
||||
(where
|
||||
\fIxyz\fR
|
||||
is exactly three octal digits,
|
||||
and is not a
|
||||
back reference (see below))
|
||||
the character whose octal value is
|
||||
\fB0\fIxyz\fR
|
||||
.RE
|
||||
.PP
|
||||
Hexadecimal digits are `\fB0\fR'-`\fB9\fR', `\fBa\fR'-`\fBf\fR',
|
||||
and `\fBA\fR'-`\fBF\fR'.
|
||||
Octal digits are `\fB0\fR'-`\fB7\fR'.
|
||||
.PP
|
||||
The character-entry escapes are always taken as ordinary characters.
|
||||
For example,
|
||||
\fB\e135\fR
|
||||
is
|
||||
\fB]\fR
|
||||
in ASCII,
|
||||
but
|
||||
\fB\e135\fR
|
||||
does not terminate a bracket expression.
|
||||
Beware, however, that some applications (e.g., C compilers) interpret
|
||||
such sequences themselves before the regular-expression package
|
||||
gets to see them, which may require doubling (quadrupling, etc.) the `\fB\e\fR'.
|
||||
.PP
|
||||
Class-shorthand escapes (AREs only) provide shorthands for certain commonly-used
|
||||
character classes:
|
||||
.RS 2
|
||||
.TP 10
|
||||
\fB\ed\fR
|
||||
\fB[[:digit:]]\fR
|
||||
.TP
|
||||
\fB\es\fR
|
||||
\fB[[:space:]]\fR
|
||||
.TP
|
||||
\fB\ew\fR
|
||||
\fB[[:alnum:]_]\fR
|
||||
(note underscore)
|
||||
.TP
|
||||
\fB\eD\fR
|
||||
\fB[^[:digit:]]\fR
|
||||
.TP
|
||||
\fB\eS\fR
|
||||
\fB[^[:space:]]\fR
|
||||
.TP
|
||||
\fB\eW\fR
|
||||
\fB[^[:alnum:]_]\fR
|
||||
(note underscore)
|
||||
.RE
|
||||
.PP
|
||||
Within bracket expressions, `\fB\ed\fR', `\fB\es\fR',
|
||||
and `\fB\ew\fR'\&
|
||||
lose their outer brackets,
|
||||
and `\fB\eD\fR', `\fB\eS\fR',
|
||||
and `\fB\eW\fR'\&
|
||||
are illegal.
|
||||
.VS 8.2
|
||||
(So, for example, \fB[a-c\ed]\fR is equivalent to \fB[a-c[:digit:]]\fR.
|
||||
Also, \fB[a-c\eD]\fR, which is equivalent to \fB[a-c^[:digit:]]\fR, is illegal.)
|
||||
.VE 8.2
|
||||
.PP
|
||||
A constraint escape (AREs only) is a constraint,
|
||||
matching the empty string if specific conditions are met,
|
||||
written as an escape:
|
||||
.RS 2
|
||||
.TP 6
|
||||
\fB\eA\fR
|
||||
matches only at the beginning of the string
|
||||
(see MATCHING, below, for how this differs from `\fB^\fR')
|
||||
.TP
|
||||
\fB\em\fR
|
||||
matches only at the beginning of a word
|
||||
.TP
|
||||
\fB\eM\fR
|
||||
matches only at the end of a word
|
||||
.TP
|
||||
\fB\ey\fR
|
||||
matches only at the beginning or end of a word
|
||||
.TP
|
||||
\fB\eY\fR
|
||||
matches only at a point that is not the beginning or end of a word
|
||||
.TP
|
||||
\fB\eZ\fR
|
||||
matches only at the end of the string
|
||||
(see MATCHING, below, for how this differs from `\fB$\fR')
|
||||
.TP
|
||||
\fB\e\fIm\fR
|
||||
(where
|
||||
\fIm\fR
|
||||
is a nonzero digit) a \fIback reference\fR, see below
|
||||
.TP
|
||||
\fB\e\fImnn\fR
|
||||
(where
|
||||
\fIm\fR
|
||||
is a nonzero digit, and
|
||||
\fInn\fR
|
||||
is some more digits,
|
||||
and the decimal value
|
||||
\fImnn\fR
|
||||
is not greater than the number of closing capturing parentheses seen so far)
|
||||
a \fIback reference\fR, see below
|
||||
.RE
|
||||
.PP
|
||||
A word is defined as in the specification of
|
||||
\fB[[:<:]]\fR
|
||||
and
|
||||
\fB[[:>:]]\fR
|
||||
above.
|
||||
Constraint escapes are illegal within bracket expressions.
|
||||
.PP
|
||||
A back reference (AREs only) matches the same string matched by the parenthesized
|
||||
subexpression specified by the number,
|
||||
so that (e.g.)
|
||||
\fB([bc])\e1\fR
|
||||
matches
|
||||
\fBbb\fR
|
||||
or
|
||||
\fBcc\fR
|
||||
but not `\fBbc\fR'.
|
||||
The subexpression must entirely precede the back reference in the RE.
|
||||
Subexpressions are numbered in the order of their leading parentheses.
|
||||
Non-capturing parentheses do not define subexpressions.
|
||||
.PP
|
||||
There is an inherent historical ambiguity between octal character-entry
|
||||
escapes and back references, which is resolved by heuristics,
|
||||
as hinted at above.
|
||||
A leading zero always indicates an octal escape.
|
||||
A single non-zero digit, not followed by another digit,
|
||||
is always taken as a back reference.
|
||||
A multi-digit sequence not starting with a zero is taken as a back
|
||||
reference if it comes after a suitable subexpression
|
||||
(i.e. the number is in the legal range for a back reference),
|
||||
and otherwise is taken as octal.
|
||||
.SH "METASYNTAX"
|
||||
In addition to the main syntax described above, there are some special
|
||||
forms and miscellaneous syntactic facilities available.
|
||||
.PP
|
||||
Normally the flavor of RE being used is specified by
|
||||
application-dependent means.
|
||||
However, this can be overridden by a \fIdirector\fR.
|
||||
If an RE of any flavor begins with `\fB***:\fR',
|
||||
the rest of the RE is an ARE.
|
||||
If an RE of any flavor begins with `\fB***=\fR',
|
||||
the rest of the RE is taken to be a literal string,
|
||||
with all characters considered ordinary characters.
|
||||
.PP
|
||||
An ARE may begin with \fIembedded options\fR:
|
||||
a sequence
|
||||
\fB(?\fIxyz\fB)\fR
|
||||
(where
|
||||
\fIxyz\fR
|
||||
is one or more alphabetic characters)
|
||||
specifies options affecting the rest of the RE.
|
||||
These supplement, and can override,
|
||||
any options specified by the application.
|
||||
The available option letters are:
|
||||
.RS 2
|
||||
.TP 3
|
||||
\fBb\fR
|
||||
rest of RE is a BRE
|
||||
.TP 3
|
||||
\fBc\fR
|
||||
case-sensitive matching (usual default)
|
||||
.TP 3
|
||||
\fBe\fR
|
||||
rest of RE is an ERE
|
||||
.TP 3
|
||||
\fBi\fR
|
||||
case-insensitive matching (see MATCHING, below)
|
||||
.TP 3
|
||||
\fBm\fR
|
||||
historical synonym for
|
||||
\fBn\fR
|
||||
.TP 3
|
||||
\fBn\fR
|
||||
newline-sensitive matching (see MATCHING, below)
|
||||
.TP 3
|
||||
\fBp\fR
|
||||
partial newline-sensitive matching (see MATCHING, below)
|
||||
.TP 3
|
||||
\fBq\fR
|
||||
rest of RE is a literal (``quoted'') string, all ordinary characters
|
||||
.TP 3
|
||||
\fBs\fR
|
||||
non-newline-sensitive matching (usual default)
|
||||
.TP 3
|
||||
\fBt\fR
|
||||
tight syntax (usual default; see below)
|
||||
.TP 3
|
||||
\fBw\fR
|
||||
inverse partial newline-sensitive (``weird'') matching (see MATCHING, below)
|
||||
.TP 3
|
||||
\fBx\fR
|
||||
expanded syntax (see below)
|
||||
.RE
|
||||
.PP
|
||||
Embedded options take effect at the
|
||||
\fB)\fR
|
||||
terminating the sequence.
|
||||
They are available only at the start of an ARE,
|
||||
and may not be used later within it.
|
||||
.PP
|
||||
In addition to the usual (\fItight\fR) RE syntax, in which all characters are
|
||||
significant, there is an \fIexpanded\fR syntax,
|
||||
available in all flavors of RE
|
||||
with the \fB-expanded\fR switch, or in AREs with the embedded x option.
|
||||
In the expanded syntax,
|
||||
white-space characters are ignored
|
||||
and all characters between a
|
||||
\fB#\fR
|
||||
and the following newline (or the end of the RE) are ignored,
|
||||
permitting paragraphing and commenting a complex RE.
|
||||
There are three exceptions to that basic rule:
|
||||
.RS 2
|
||||
.PP
|
||||
a white-space character or `\fB#\fR' preceded by `\fB\e\fR' is retained
|
||||
.PP
|
||||
white space or `\fB#\fR' within a bracket expression is retained
|
||||
.PP
|
||||
white space and comments are illegal within multi-character symbols
|
||||
like the ARE `\fB(?:\fR' or the BRE `\fB\e(\fR'
|
||||
.RE
|
||||
.PP
|
||||
Expanded-syntax white-space characters are blank, tab, newline, and
|
||||
.VS 8.2
|
||||
any character that belongs to the \fIspace\fR character class.
|
||||
.VE 8.2
|
||||
.PP
|
||||
Finally, in an ARE,
|
||||
outside bracket expressions, the sequence `\fB(?#\fIttt\fB)\fR'
|
||||
(where
|
||||
\fIttt\fR
|
||||
is any text not containing a `\fB)\fR')
|
||||
is a comment,
|
||||
completely ignored.
|
||||
Again, this is not allowed between the characters of
|
||||
multi-character symbols like `\fB(?:\fR'.
|
||||
Such comments are more a historical artifact than a useful facility,
|
||||
and their use is deprecated;
|
||||
use the expanded syntax instead.
|
||||
.PP
|
||||
\fINone\fR of these metasyntax extensions is available if the application
|
||||
(or an initial
|
||||
\fB***=\fR
|
||||
director)
|
||||
has specified that the user's input be treated as a literal string
|
||||
rather than as an RE.
|
||||
.SH MATCHING
|
||||
In the event that an RE could match more than one substring of a given
|
||||
string,
|
||||
the RE matches the one starting earliest in the string.
|
||||
If the RE could match more than one substring starting at that point,
|
||||
its choice is determined by its \fIpreference\fR:
|
||||
either the longest substring, or the shortest.
|
||||
.PP
|
||||
Most atoms, and all constraints, have no preference.
|
||||
A parenthesized RE has the same preference (possibly none) as the RE.
|
||||
A quantified atom with quantifier
|
||||
\fB{\fIm\fB}\fR
|
||||
or
|
||||
\fB{\fIm\fB}?\fR
|
||||
has the same preference (possibly none) as the atom itself.
|
||||
A quantified atom with other normal quantifiers (including
|
||||
\fB{\fIm\fB,\fIn\fB}\fR
|
||||
with
|
||||
\fIm\fR
|
||||
equal to
|
||||
\fIn\fR)
|
||||
prefers longest match.
|
||||
A quantified atom with other non-greedy quantifiers (including
|
||||
\fB{\fIm\fB,\fIn\fB}?\fR
|
||||
with
|
||||
\fIm\fR
|
||||
equal to
|
||||
\fIn\fR)
|
||||
prefers shortest match.
|
||||
A branch has the same preference as the first quantified atom in it
|
||||
which has a preference.
|
||||
An RE consisting of two or more branches connected by the
|
||||
\fB|\fR
|
||||
operator prefers longest match.
|
||||
.PP
|
||||
Subject to the constraints imposed by the rules for matching the whole RE,
|
||||
subexpressions also match the longest or shortest possible substrings,
|
||||
based on their preferences,
|
||||
with subexpressions starting earlier in the RE taking priority over
|
||||
ones starting later.
|
||||
Note that outer subexpressions thus take priority over
|
||||
their component subexpressions.
|
||||
.PP
|
||||
Note that the quantifiers
|
||||
\fB{1,1}\fR
|
||||
and
|
||||
\fB{1,1}?\fR
|
||||
can be used to force longest and shortest preference, respectively,
|
||||
on a subexpression or a whole RE.
|
||||
.PP
|
||||
Match lengths are measured in characters, not collating elements.
|
||||
An empty string is considered longer than no match at all.
|
||||
For example,
|
||||
\fBbb*\fR
|
||||
matches the three middle characters of `\fBabbbc\fR',
|
||||
\fB(week|wee)(night|knights)\fR
|
||||
matches all ten characters of `\fBweeknights\fR',
|
||||
when
|
||||
\fB(.*).*\fR
|
||||
is matched against
|
||||
\fBabc\fR
|
||||
the parenthesized subexpression
|
||||
matches all three characters, and
|
||||
when
|
||||
\fB(a*)*\fR
|
||||
is matched against
|
||||
\fBbc\fR
|
||||
both the whole RE and the parenthesized
|
||||
subexpression match an empty string.
|
||||
.PP
|
||||
If case-independent matching is specified,
|
||||
the effect is much as if all case distinctions had vanished from the
|
||||
alphabet.
|
||||
When an alphabetic that exists in multiple cases appears as an
|
||||
ordinary character outside a bracket expression, it is effectively
|
||||
transformed into a bracket expression containing both cases,
|
||||
so that
|
||||
\fBx\fR
|
||||
becomes `\fB[xX]\fR'.
|
||||
When it appears inside a bracket expression, all case counterparts
|
||||
of it are added to the bracket expression, so that
|
||||
\fB[x]\fR
|
||||
becomes
|
||||
\fB[xX]\fR
|
||||
and
|
||||
\fB[^x]\fR
|
||||
becomes `\fB[^xX]\fR'.
|
||||
.PP
|
||||
If newline-sensitive matching is specified, \fB.\fR
|
||||
and bracket expressions using
|
||||
\fB^\fR
|
||||
will never match the newline character
|
||||
(so that matches will never cross newlines unless the RE
|
||||
explicitly arranges it)
|
||||
and
|
||||
\fB^\fR
|
||||
and
|
||||
\fB$\fR
|
||||
will match the empty string after and before a newline
|
||||
respectively, in addition to matching at beginning and end of string
|
||||
respectively.
|
||||
ARE
|
||||
\fB\eA\fR
|
||||
and
|
||||
\fB\eZ\fR
|
||||
continue to match beginning or end of string \fIonly\fR.
|
||||
.PP
|
||||
If partial newline-sensitive matching is specified,
|
||||
this affects \fB.\fR
|
||||
and bracket expressions
|
||||
as with newline-sensitive matching, but not
|
||||
\fB^\fR
|
||||
and `\fB$\fR'.
|
||||
.PP
|
||||
If inverse partial newline-sensitive matching is specified,
|
||||
this affects
|
||||
\fB^\fR
|
||||
and
|
||||
\fB$\fR
|
||||
as with
|
||||
newline-sensitive matching,
|
||||
but not \fB.\fR
|
||||
and bracket expressions.
|
||||
This isn't very useful but is provided for symmetry.
|
||||
.SH "LIMITS AND COMPATIBILITY"
|
||||
No particular limit is imposed on the length of REs.
|
||||
Programs intended to be highly portable should not employ REs longer
|
||||
than 256 bytes,
|
||||
as a POSIX-compliant implementation can refuse to accept such REs.
|
||||
.PP
|
||||
The only feature of AREs that is actually incompatible with
|
||||
POSIX EREs is that
|
||||
\fB\e\fR
|
||||
does not lose its special
|
||||
significance inside bracket expressions.
|
||||
All other ARE features use syntax which is illegal or has
|
||||
undefined or unspecified effects in POSIX EREs;
|
||||
the
|
||||
\fB***\fR
|
||||
syntax of directors likewise is outside the POSIX
|
||||
syntax for both BREs and EREs.
|
||||
.PP
|
||||
Many of the ARE extensions are borrowed from Perl, but some have
|
||||
been changed to clean them up, and a few Perl extensions are not present.
|
||||
Incompatibilities of note include `\fB\eb\fR', `\fB\eB\fR',
|
||||
the lack of special treatment for a trailing newline,
|
||||
the addition of complemented bracket expressions to the things
|
||||
affected by newline-sensitive matching,
|
||||
the restrictions on parentheses and back references in lookahead constraints,
|
||||
and the longest/shortest-match (rather than first-match) matching semantics.
|
||||
.PP
|
||||
The matching rules for REs containing both normal and non-greedy quantifiers
|
||||
have changed since early beta-test versions of this package.
|
||||
(The new rules are much simpler and cleaner,
|
||||
but don't work as hard at guessing the user's real intentions.)
|
||||
.PP
|
||||
Henry Spencer's original 1986 \fIregexp\fR package,
|
||||
still in widespread use (e.g., in pre-8.1 releases of Tcl),
|
||||
implemented an early version of today's EREs.
|
||||
There are four incompatibilities between \fIregexp\fR's near-EREs
|
||||
(`RREs' for short) and AREs.
|
||||
In roughly increasing order of significance:
|
||||
.PP
|
||||
.RS
|
||||
In AREs,
|
||||
\fB\e\fR
|
||||
followed by an alphanumeric character is either an
|
||||
escape or an error,
|
||||
while in RREs, it was just another way of writing the
|
||||
alphanumeric.
|
||||
This should not be a problem because there was no reason to write
|
||||
such a sequence in RREs.
|
||||
.PP
|
||||
\fB{\fR
|
||||
followed by a digit in an ARE is the beginning of a bound,
|
||||
while in RREs,
|
||||
\fB{\fR
|
||||
was always an ordinary character.
|
||||
Such sequences should be rare,
|
||||
and will often result in an error because following characters
|
||||
will not look like a valid bound.
|
||||
.PP
|
||||
In AREs,
|
||||
\fB\e\fR
|
||||
remains a special character within `\fB[\|]\fR',
|
||||
so a literal
|
||||
\fB\e\fR
|
||||
within
|
||||
\fB[\|]\fR
|
||||
must be written `\fB\e\e\fR'.
|
||||
\fB\e\e\fR
|
||||
also gives a literal
|
||||
\fB\e\fR
|
||||
within
|
||||
\fB[\|]\fR
|
||||
in RREs,
|
||||
but only truly paranoid programmers routinely doubled the backslash.
|
||||
.PP
|
||||
AREs report the longest/shortest match for the RE,
|
||||
rather than the first found in a specified search order.
|
||||
This may affect some RREs which were written in the expectation that
|
||||
the first match would be reported.
|
||||
(The careful crafting of RREs to optimize the search order for fast
|
||||
matching is obsolete (AREs examine all possible matches
|
||||
in parallel, and their performance is largely insensitive to their
|
||||
complexity) but cases where the search order was exploited to deliberately
|
||||
find a match which was \fInot\fR the longest/shortest will need rewriting.)
|
||||
.RE
|
||||
|
||||
.SH "BASIC REGULAR EXPRESSIONS"
|
||||
BREs differ from EREs in several respects. `\fB|\fR', `\fB+\fR',
|
||||
and
|
||||
\fB?\fR
|
||||
are ordinary characters and there is no equivalent
|
||||
for their functionality.
|
||||
The delimiters for bounds are
|
||||
\fB\e{\fR
|
||||
and `\fB\e}\fR',
|
||||
with
|
||||
\fB{\fR
|
||||
and
|
||||
\fB}\fR
|
||||
by themselves ordinary characters.
|
||||
The parentheses for nested subexpressions are
|
||||
\fB\e(\fR
|
||||
and `\fB\e)\fR',
|
||||
with
|
||||
\fB(\fR
|
||||
and
|
||||
\fB)\fR
|
||||
by themselves ordinary characters.
|
||||
\fB^\fR
|
||||
is an ordinary character except at the beginning of the
|
||||
RE or the beginning of a parenthesized subexpression,
|
||||
\fB$\fR
|
||||
is an ordinary character except at the end of the
|
||||
RE or the end of a parenthesized subexpression,
|
||||
and
|
||||
\fB*\fR
|
||||
is an ordinary character if it appears at the beginning of the
|
||||
RE or the beginning of a parenthesized subexpression
|
||||
(after a possible leading `\fB^\fR').
|
||||
Finally,
|
||||
single-digit back references are available,
|
||||
and
|
||||
\fB\e<\fR
|
||||
and
|
||||
\fB\e>\fR
|
||||
are synonyms for
|
||||
\fB[[:<:]]\fR
|
||||
and
|
||||
\fB[[:>:]]\fR
|
||||
respectively;
|
||||
no other escapes are available.
|
||||
|
||||
.SH "SEE ALSO"
|
||||
RegExp(3), regexp(n), regsub(n), lsearch(n), switch(n), text(n)
|
||||
|
||||
.SH KEYWORDS
|
||||
match, regular expression, string
|
||||
@@ -1,780 +0,0 @@
|
||||
/*
|
||||
* colorings of characters
|
||||
* This file is #included by regcomp.c.
|
||||
*
|
||||
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
|
||||
*
|
||||
* Development of this software was funded, in part, by Cray Research Inc.,
|
||||
* UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
|
||||
* Corporation, none of whom are responsible for the results. The author
|
||||
* thanks all of them.
|
||||
*
|
||||
* Redistribution and use in source and binary forms -- with or without
|
||||
* modification -- are permitted for any purpose, provided that
|
||||
* redistributions in source form retain this entire copyright notice and
|
||||
* indicate the origin and nature of any modifications.
|
||||
*
|
||||
* I'd appreciate being given credit for this package in the documentation
|
||||
* of software which uses it, but that is not a requirement.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED ``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
|
||||
* HENRY SPENCER 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.
|
||||
*
|
||||
* $Header$
|
||||
*
|
||||
*
|
||||
* Note that there are some incestuous relationships between this code and
|
||||
* NFA arc maintenance, which perhaps ought to be cleaned up sometime.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
#define CISERR() VISERR(cm->v)
|
||||
#define CERR(e) VERR(cm->v, (e))
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* initcm - set up new colormap
|
||||
*/
|
||||
static void
|
||||
initcm(struct vars * v,
|
||||
struct colormap * cm)
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
union tree *t;
|
||||
union tree *nextt;
|
||||
struct colordesc *cd;
|
||||
|
||||
cm->magic = CMMAGIC;
|
||||
cm->v = v;
|
||||
|
||||
cm->ncds = NINLINECDS;
|
||||
cm->cd = cm->cdspace;
|
||||
cm->max = 0;
|
||||
cm->free = 0;
|
||||
|
||||
cd = cm->cd; /* cm->cd[WHITE] */
|
||||
cd->sub = NOSUB;
|
||||
cd->arcs = NULL;
|
||||
cd->flags = 0;
|
||||
cd->nchrs = CHR_MAX - CHR_MIN + 1;
|
||||
|
||||
/* upper levels of tree */
|
||||
for (t = &cm->tree[0], j = NBYTS - 1; j > 0; t = nextt, j--)
|
||||
{
|
||||
nextt = t + 1;
|
||||
for (i = BYTTAB - 1; i >= 0; i--)
|
||||
t->tptr[i] = nextt;
|
||||
}
|
||||
/* bottom level is solid white */
|
||||
t = &cm->tree[NBYTS - 1];
|
||||
for (i = BYTTAB - 1; i >= 0; i--)
|
||||
t->tcolor[i] = WHITE;
|
||||
cd->block = t;
|
||||
}
|
||||
|
||||
/*
|
||||
* freecm - free dynamically-allocated things in a colormap
|
||||
*/
|
||||
static void
|
||||
freecm(struct colormap * cm)
|
||||
{
|
||||
size_t i;
|
||||
union tree *cb;
|
||||
|
||||
cm->magic = 0;
|
||||
if (NBYTS > 1)
|
||||
cmtreefree(cm, cm->tree, 0);
|
||||
for (i = 1; i <= cm->max; i++) /* skip WHITE */
|
||||
if (!UNUSEDCOLOR(&cm->cd[i]))
|
||||
{
|
||||
cb = cm->cd[i].block;
|
||||
if (cb != NULL)
|
||||
FREE(cb);
|
||||
}
|
||||
if (cm->cd != cm->cdspace)
|
||||
FREE(cm->cd);
|
||||
}
|
||||
|
||||
/*
|
||||
* cmtreefree - free a non-terminal part of a colormap tree
|
||||
*/
|
||||
static void
|
||||
cmtreefree(struct colormap * cm,
|
||||
union tree * tree,
|
||||
int level) /* level number (top == 0) of this block */
|
||||
{
|
||||
int i;
|
||||
union tree *t;
|
||||
union tree *fillt = &cm->tree[level + 1];
|
||||
union tree *cb;
|
||||
|
||||
assert(level < NBYTS - 1); /* this level has pointers */
|
||||
for (i = BYTTAB - 1; i >= 0; i--)
|
||||
{
|
||||
t = tree->tptr[i];
|
||||
assert(t != NULL);
|
||||
if (t != fillt)
|
||||
{
|
||||
if (level < NBYTS - 2)
|
||||
{ /* more pointer blocks below */
|
||||
cmtreefree(cm, t, level + 1);
|
||||
FREE(t);
|
||||
}
|
||||
else
|
||||
{ /* color block below */
|
||||
cb = cm->cd[t->tcolor[0]].block;
|
||||
if (t != cb) /* not a solid block */
|
||||
FREE(t);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* setcolor - set the color of a character in a colormap
|
||||
*/
|
||||
static color /* previous color */
|
||||
setcolor(struct colormap * cm,
|
||||
chr c,
|
||||
pcolor co)
|
||||
{
|
||||
uchr uc = c;
|
||||
int shift;
|
||||
int level;
|
||||
int b;
|
||||
int bottom;
|
||||
union tree *t;
|
||||
union tree *newt;
|
||||
union tree *fillt;
|
||||
union tree *lastt;
|
||||
union tree *cb;
|
||||
color prev;
|
||||
|
||||
assert(cm->magic == CMMAGIC);
|
||||
if (CISERR() || co == COLORLESS)
|
||||
return COLORLESS;
|
||||
|
||||
t = cm->tree;
|
||||
for (level = 0, shift = BYTBITS * (NBYTS - 1); shift > 0;
|
||||
level++, shift -= BYTBITS)
|
||||
{
|
||||
b = (uc >> shift) & BYTMASK;
|
||||
lastt = t;
|
||||
t = lastt->tptr[b];
|
||||
assert(t != NULL);
|
||||
fillt = &cm->tree[level + 1];
|
||||
bottom = (shift <= BYTBITS) ? 1 : 0;
|
||||
cb = (bottom) ? cm->cd[t->tcolor[0]].block : fillt;
|
||||
if (t == fillt || t == cb)
|
||||
{ /* must allocate a new block */
|
||||
newt = (union tree *) MALLOC((bottom) ?
|
||||
sizeof(struct colors) : sizeof(struct ptrs));
|
||||
if (newt == NULL)
|
||||
{
|
||||
CERR(REG_ESPACE);
|
||||
return COLORLESS;
|
||||
}
|
||||
if (bottom)
|
||||
memcpy(VS(newt->tcolor), VS(t->tcolor),
|
||||
BYTTAB * sizeof(color));
|
||||
else
|
||||
memcpy(VS(newt->tptr), VS(t->tptr),
|
||||
BYTTAB * sizeof(union tree *));
|
||||
t = newt;
|
||||
lastt->tptr[b] = t;
|
||||
}
|
||||
}
|
||||
|
||||
b = uc & BYTMASK;
|
||||
prev = t->tcolor[b];
|
||||
t->tcolor[b] = (color) co;
|
||||
return prev;
|
||||
}
|
||||
|
||||
/*
|
||||
* maxcolor - report largest color number in use
|
||||
*/
|
||||
static color
|
||||
maxcolor(struct colormap * cm)
|
||||
{
|
||||
if (CISERR())
|
||||
return COLORLESS;
|
||||
|
||||
return (color) cm->max;
|
||||
}
|
||||
|
||||
/*
|
||||
* newcolor - find a new color (must be subject of setcolor at once)
|
||||
* Beware: may relocate the colordescs.
|
||||
*/
|
||||
static color /* COLORLESS for error */
|
||||
newcolor(struct colormap * cm)
|
||||
{
|
||||
struct colordesc *cd;
|
||||
struct colordesc *new;
|
||||
size_t n;
|
||||
|
||||
if (CISERR())
|
||||
return COLORLESS;
|
||||
|
||||
if (cm->free != 0)
|
||||
{
|
||||
assert(cm->free > 0);
|
||||
assert((size_t) cm->free < cm->ncds);
|
||||
cd = &cm->cd[cm->free];
|
||||
assert(UNUSEDCOLOR(cd));
|
||||
assert(cd->arcs == NULL);
|
||||
cm->free = cd->sub;
|
||||
}
|
||||
else if (cm->max < cm->ncds - 1)
|
||||
{
|
||||
cm->max++;
|
||||
cd = &cm->cd[cm->max];
|
||||
}
|
||||
else
|
||||
{
|
||||
/* oops, must allocate more */
|
||||
n = cm->ncds * 2;
|
||||
if (cm->cd == cm->cdspace)
|
||||
{
|
||||
new = (struct colordesc *) MALLOC(n *
|
||||
sizeof(struct colordesc));
|
||||
if (new != NULL)
|
||||
memcpy(VS(new), VS(cm->cdspace), cm->ncds *
|
||||
sizeof(struct colordesc));
|
||||
}
|
||||
else
|
||||
new = (struct colordesc *) REALLOC(cm->cd,
|
||||
n * sizeof(struct colordesc));
|
||||
if (new == NULL)
|
||||
{
|
||||
CERR(REG_ESPACE);
|
||||
return COLORLESS;
|
||||
}
|
||||
cm->cd = new;
|
||||
cm->ncds = n;
|
||||
assert(cm->max < cm->ncds - 1);
|
||||
cm->max++;
|
||||
cd = &cm->cd[cm->max];
|
||||
}
|
||||
|
||||
cd->nchrs = 0;
|
||||
cd->sub = NOSUB;
|
||||
cd->arcs = NULL;
|
||||
cd->flags = 0;
|
||||
cd->block = NULL;
|
||||
|
||||
return (color) (cd - cm->cd);
|
||||
}
|
||||
|
||||
/*
|
||||
* freecolor - free a color (must have no arcs or subcolor)
|
||||
*/
|
||||
static void
|
||||
freecolor(struct colormap * cm,
|
||||
pcolor co)
|
||||
{
|
||||
struct colordesc *cd = &cm->cd[co];
|
||||
color pco,
|
||||
nco; /* for freelist scan */
|
||||
|
||||
assert(co >= 0);
|
||||
if (co == WHITE)
|
||||
return;
|
||||
|
||||
assert(cd->arcs == NULL);
|
||||
assert(cd->sub == NOSUB);
|
||||
assert(cd->nchrs == 0);
|
||||
cd->flags = FREECOL;
|
||||
if (cd->block != NULL)
|
||||
{
|
||||
FREE(cd->block);
|
||||
cd->block = NULL; /* just paranoia */
|
||||
}
|
||||
|
||||
if ((size_t) co == cm->max)
|
||||
{
|
||||
while (cm->max > WHITE && UNUSEDCOLOR(&cm->cd[cm->max]))
|
||||
cm->max--;
|
||||
assert(cm->free >= 0);
|
||||
while ((size_t) cm->free > cm->max)
|
||||
cm->free = cm->cd[cm->free].sub;
|
||||
if (cm->free > 0)
|
||||
{
|
||||
assert(cm->free < cm->max);
|
||||
pco = cm->free;
|
||||
nco = cm->cd[pco].sub;
|
||||
while (nco > 0)
|
||||
if ((size_t) nco > cm->max)
|
||||
{
|
||||
/* take this one out of freelist */
|
||||
nco = cm->cd[nco].sub;
|
||||
cm->cd[pco].sub = nco;
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(nco < cm->max);
|
||||
pco = nco;
|
||||
nco = cm->cd[pco].sub;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
cd->sub = cm->free;
|
||||
cm->free = (color) (cd - cm->cd);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* pseudocolor - allocate a false color, to be managed by other means
|
||||
*/
|
||||
static color
|
||||
pseudocolor(struct colormap * cm)
|
||||
{
|
||||
color co;
|
||||
|
||||
co = newcolor(cm);
|
||||
if (CISERR())
|
||||
return COLORLESS;
|
||||
cm->cd[co].nchrs = 1;
|
||||
cm->cd[co].flags = PSEUDO;
|
||||
return co;
|
||||
}
|
||||
|
||||
/*
|
||||
* subcolor - allocate a new subcolor (if necessary) to this chr
|
||||
*/
|
||||
static color
|
||||
subcolor(struct colormap * cm, chr c)
|
||||
{
|
||||
color co; /* current color of c */
|
||||
color sco; /* new subcolor */
|
||||
|
||||
co = GETCOLOR(cm, c);
|
||||
sco = newsub(cm, co);
|
||||
if (CISERR())
|
||||
return COLORLESS;
|
||||
assert(sco != COLORLESS);
|
||||
|
||||
if (co == sco) /* already in an open subcolor */
|
||||
return co; /* rest is redundant */
|
||||
cm->cd[co].nchrs--;
|
||||
cm->cd[sco].nchrs++;
|
||||
setcolor(cm, c, sco);
|
||||
return sco;
|
||||
}
|
||||
|
||||
/*
|
||||
* newsub - allocate a new subcolor (if necessary) for a color
|
||||
*/
|
||||
static color
|
||||
newsub(struct colormap * cm,
|
||||
pcolor co)
|
||||
{
|
||||
color sco; /* new subcolor */
|
||||
|
||||
sco = cm->cd[co].sub;
|
||||
if (sco == NOSUB)
|
||||
{ /* color has no open subcolor */
|
||||
if (cm->cd[co].nchrs == 1) /* optimization */
|
||||
return co;
|
||||
sco = newcolor(cm); /* must create subcolor */
|
||||
if (sco == COLORLESS)
|
||||
{
|
||||
assert(CISERR());
|
||||
return COLORLESS;
|
||||
}
|
||||
cm->cd[co].sub = sco;
|
||||
cm->cd[sco].sub = sco; /* open subcolor points to self */
|
||||
}
|
||||
assert(sco != NOSUB);
|
||||
|
||||
return sco;
|
||||
}
|
||||
|
||||
/*
|
||||
* subrange - allocate new subcolors to this range of chrs, fill in arcs
|
||||
*/
|
||||
static void
|
||||
subrange(struct vars * v,
|
||||
chr from,
|
||||
chr to,
|
||||
struct state * lp,
|
||||
struct state * rp)
|
||||
{
|
||||
uchr uf;
|
||||
int i;
|
||||
|
||||
assert(from <= to);
|
||||
|
||||
/* first, align "from" on a tree-block boundary */
|
||||
uf = (uchr) from;
|
||||
i = (int) (((uf + BYTTAB - 1) & (uchr) ~BYTMASK) - uf);
|
||||
for (; from <= to && i > 0; i--, from++)
|
||||
newarc(v->nfa, PLAIN, subcolor(v->cm, from), lp, rp);
|
||||
if (from > to) /* didn't reach a boundary */
|
||||
return;
|
||||
|
||||
/* deal with whole blocks */
|
||||
for (; to - from >= BYTTAB; from += BYTTAB)
|
||||
subblock(v, from, lp, rp);
|
||||
|
||||
/* clean up any remaining partial table */
|
||||
for (; from <= to; from++)
|
||||
newarc(v->nfa, PLAIN, subcolor(v->cm, from), lp, rp);
|
||||
}
|
||||
|
||||
/*
|
||||
* subblock - allocate new subcolors for one tree block of chrs, fill in arcs
|
||||
*/
|
||||
static void
|
||||
subblock(struct vars * v,
|
||||
chr start, /* first of BYTTAB chrs */
|
||||
struct state * lp,
|
||||
struct state * rp)
|
||||
{
|
||||
uchr uc = start;
|
||||
struct colormap *cm = v->cm;
|
||||
int shift;
|
||||
int level;
|
||||
int i;
|
||||
int b;
|
||||
union tree *t;
|
||||
union tree *cb;
|
||||
union tree *fillt;
|
||||
union tree *lastt;
|
||||
int previ;
|
||||
int ndone;
|
||||
color co;
|
||||
color sco;
|
||||
|
||||
assert((uc % BYTTAB) == 0);
|
||||
|
||||
/* find its color block, making new pointer blocks as needed */
|
||||
t = cm->tree;
|
||||
fillt = NULL;
|
||||
for (level = 0, shift = BYTBITS * (NBYTS - 1); shift > 0;
|
||||
level++, shift -= BYTBITS)
|
||||
{
|
||||
b = (uc >> shift) & BYTMASK;
|
||||
lastt = t;
|
||||
t = lastt->tptr[b];
|
||||
assert(t != NULL);
|
||||
fillt = &cm->tree[level + 1];
|
||||
if (t == fillt && shift > BYTBITS)
|
||||
{ /* need new ptr block */
|
||||
t = (union tree *) MALLOC(sizeof(struct ptrs));
|
||||
if (t == NULL)
|
||||
{
|
||||
CERR(REG_ESPACE);
|
||||
return;
|
||||
}
|
||||
memcpy(VS(t->tptr), VS(fillt->tptr),
|
||||
BYTTAB * sizeof(union tree *));
|
||||
lastt->tptr[b] = t;
|
||||
}
|
||||
}
|
||||
|
||||
/* special cases: fill block or solid block */
|
||||
co = t->tcolor[0];
|
||||
cb = cm->cd[co].block;
|
||||
if (t == fillt || t == cb)
|
||||
{
|
||||
/* either way, we want a subcolor solid block */
|
||||
sco = newsub(cm, co);
|
||||
t = cm->cd[sco].block;
|
||||
if (t == NULL)
|
||||
{ /* must set it up */
|
||||
t = (union tree *) MALLOC(sizeof(struct colors));
|
||||
if (t == NULL)
|
||||
{
|
||||
CERR(REG_ESPACE);
|
||||
return;
|
||||
}
|
||||
for (i = 0; i < BYTTAB; i++)
|
||||
t->tcolor[i] = sco;
|
||||
cm->cd[sco].block = t;
|
||||
}
|
||||
/* find loop must have run at least once */
|
||||
lastt->tptr[b] = t;
|
||||
newarc(v->nfa, PLAIN, sco, lp, rp);
|
||||
cm->cd[co].nchrs -= BYTTAB;
|
||||
cm->cd[sco].nchrs += BYTTAB;
|
||||
return;
|
||||
}
|
||||
|
||||
/* general case, a mixed block to be altered */
|
||||
i = 0;
|
||||
while (i < BYTTAB)
|
||||
{
|
||||
co = t->tcolor[i];
|
||||
sco = newsub(cm, co);
|
||||
newarc(v->nfa, PLAIN, sco, lp, rp);
|
||||
previ = i;
|
||||
do
|
||||
{
|
||||
t->tcolor[i++] = sco;
|
||||
} while (i < BYTTAB && t->tcolor[i] == co);
|
||||
ndone = i - previ;
|
||||
cm->cd[co].nchrs -= ndone;
|
||||
cm->cd[sco].nchrs += ndone;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* okcolors - promote subcolors to full colors
|
||||
*/
|
||||
static void
|
||||
okcolors(struct nfa * nfa,
|
||||
struct colormap * cm)
|
||||
{
|
||||
struct colordesc *cd;
|
||||
struct colordesc *end = CDEND(cm);
|
||||
struct colordesc *scd;
|
||||
struct arc *a;
|
||||
color co;
|
||||
color sco;
|
||||
|
||||
for (cd = cm->cd, co = 0; cd < end; cd++, co++)
|
||||
{
|
||||
sco = cd->sub;
|
||||
if (UNUSEDCOLOR(cd) || sco == NOSUB)
|
||||
{
|
||||
/* has no subcolor, no further action */
|
||||
}
|
||||
else if (sco == co)
|
||||
{
|
||||
/* is subcolor, let parent deal with it */
|
||||
}
|
||||
else if (cd->nchrs == 0)
|
||||
{
|
||||
/* parent empty, its arcs change color to subcolor */
|
||||
cd->sub = NOSUB;
|
||||
scd = &cm->cd[sco];
|
||||
assert(scd->nchrs > 0);
|
||||
assert(scd->sub == sco);
|
||||
scd->sub = NOSUB;
|
||||
while ((a = cd->arcs) != NULL)
|
||||
{
|
||||
assert(a->co == co);
|
||||
/* uncolorchain(cm, a); */
|
||||
cd->arcs = a->colorchain;
|
||||
a->co = sco;
|
||||
/* colorchain(cm, a); */
|
||||
a->colorchain = scd->arcs;
|
||||
scd->arcs = a;
|
||||
}
|
||||
freecolor(cm, co);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* parent's arcs must gain parallel subcolor arcs */
|
||||
cd->sub = NOSUB;
|
||||
scd = &cm->cd[sco];
|
||||
assert(scd->nchrs > 0);
|
||||
assert(scd->sub == sco);
|
||||
scd->sub = NOSUB;
|
||||
for (a = cd->arcs; a != NULL; a = a->colorchain)
|
||||
{
|
||||
assert(a->co == co);
|
||||
newarc(nfa, a->type, sco, a->from, a->to);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* colorchain - add this arc to the color chain of its color
|
||||
*/
|
||||
static void
|
||||
colorchain(struct colormap * cm,
|
||||
struct arc * a)
|
||||
{
|
||||
struct colordesc *cd = &cm->cd[a->co];
|
||||
|
||||
a->colorchain = cd->arcs;
|
||||
cd->arcs = a;
|
||||
}
|
||||
|
||||
/*
|
||||
* uncolorchain - delete this arc from the color chain of its color
|
||||
*/
|
||||
static void
|
||||
uncolorchain(struct colormap * cm,
|
||||
struct arc * a)
|
||||
{
|
||||
struct colordesc *cd = &cm->cd[a->co];
|
||||
struct arc *aa;
|
||||
|
||||
aa = cd->arcs;
|
||||
if (aa == a) /* easy case */
|
||||
cd->arcs = a->colorchain;
|
||||
else
|
||||
{
|
||||
for (; aa != NULL && aa->colorchain != a; aa = aa->colorchain)
|
||||
continue;
|
||||
assert(aa != NULL);
|
||||
aa->colorchain = a->colorchain;
|
||||
}
|
||||
a->colorchain = NULL; /* paranoia */
|
||||
}
|
||||
|
||||
/*
|
||||
* singleton - is this character in its own color?
|
||||
*/
|
||||
static int /* predicate */
|
||||
singleton(struct colormap * cm,
|
||||
chr c)
|
||||
{
|
||||
color co; /* color of c */
|
||||
|
||||
co = GETCOLOR(cm, c);
|
||||
if (cm->cd[co].nchrs == 1 && cm->cd[co].sub == NOSUB)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* rainbow - add arcs of all full colors (but one) between specified states
|
||||
*/
|
||||
static void
|
||||
rainbow(struct nfa * nfa,
|
||||
struct colormap * cm,
|
||||
int type,
|
||||
pcolor but, /* COLORLESS if no exceptions */
|
||||
struct state * from,
|
||||
struct state * to)
|
||||
{
|
||||
struct colordesc *cd;
|
||||
struct colordesc *end = CDEND(cm);
|
||||
color co;
|
||||
|
||||
for (cd = cm->cd, co = 0; cd < end && !CISERR(); cd++, co++)
|
||||
if (!UNUSEDCOLOR(cd) && cd->sub != co && co != but &&
|
||||
!(cd->flags & PSEUDO))
|
||||
newarc(nfa, type, co, from, to);
|
||||
}
|
||||
|
||||
/*
|
||||
* colorcomplement - add arcs of complementary colors
|
||||
*
|
||||
* The calling sequence ought to be reconciled with cloneouts().
|
||||
*/
|
||||
static void
|
||||
colorcomplement(struct nfa * nfa,
|
||||
struct colormap * cm,
|
||||
int type,
|
||||
struct state * of, /* complements of this guy's PLAIN
|
||||
* outarcs */
|
||||
struct state * from,
|
||||
struct state * to)
|
||||
{
|
||||
struct colordesc *cd;
|
||||
struct colordesc *end = CDEND(cm);
|
||||
color co;
|
||||
|
||||
assert(of != from);
|
||||
for (cd = cm->cd, co = 0; cd < end && !CISERR(); cd++, co++)
|
||||
if (!UNUSEDCOLOR(cd) && !(cd->flags & PSEUDO))
|
||||
if (findarc(of, PLAIN, co) == NULL)
|
||||
newarc(nfa, type, co, from, to);
|
||||
}
|
||||
|
||||
|
||||
#ifdef REG_DEBUG
|
||||
|
||||
/*
|
||||
* dumpcolors - debugging output
|
||||
*/
|
||||
static void
|
||||
dumpcolors(struct colormap * cm,
|
||||
FILE *f)
|
||||
{
|
||||
struct colordesc *cd;
|
||||
struct colordesc *end;
|
||||
color co;
|
||||
chr c;
|
||||
char *has;
|
||||
|
||||
fprintf(f, "max %ld\n", (long) cm->max);
|
||||
if (NBYTS > 1)
|
||||
fillcheck(cm, cm->tree, 0, f);
|
||||
end = CDEND(cm);
|
||||
for (cd = cm->cd + 1, co = 1; cd < end; cd++, co++) /* skip 0 */
|
||||
if (!UNUSEDCOLOR(cd))
|
||||
{
|
||||
assert(cd->nchrs > 0);
|
||||
has = (cd->block != NULL) ? "#" : "";
|
||||
if (cd->flags & PSEUDO)
|
||||
fprintf(f, "#%2ld%s(ps): ", (long) co, has);
|
||||
else
|
||||
fprintf(f, "#%2ld%s(%2d): ", (long) co,
|
||||
has, cd->nchrs);
|
||||
/* it's hard to do this more efficiently */
|
||||
for (c = CHR_MIN; c < CHR_MAX; c++)
|
||||
if (GETCOLOR(cm, c) == co)
|
||||
dumpchr(c, f);
|
||||
assert(c == CHR_MAX);
|
||||
if (GETCOLOR(cm, c) == co)
|
||||
dumpchr(c, f);
|
||||
fprintf(f, "\n");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* fillcheck - check proper filling of a tree
|
||||
*/
|
||||
static void
|
||||
fillcheck(struct colormap * cm,
|
||||
union tree * tree,
|
||||
int level, /* level number (top == 0) of this block */
|
||||
FILE *f)
|
||||
{
|
||||
int i;
|
||||
union tree *t;
|
||||
union tree *fillt = &cm->tree[level + 1];
|
||||
|
||||
assert(level < NBYTS - 1); /* this level has pointers */
|
||||
for (i = BYTTAB - 1; i >= 0; i--)
|
||||
{
|
||||
t = tree->tptr[i];
|
||||
if (t == NULL)
|
||||
fprintf(f, "NULL found in filled tree!\n");
|
||||
else if (t == fillt)
|
||||
{
|
||||
}
|
||||
else if (level < NBYTS - 2) /* more pointer blocks below */
|
||||
fillcheck(cm, t, level + 1, f);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* dumpchr - print a chr
|
||||
*
|
||||
* Kind of char-centric but works well enough for debug use.
|
||||
*/
|
||||
static void
|
||||
dumpchr(chr c,
|
||||
FILE *f)
|
||||
{
|
||||
if (c == '\\')
|
||||
fprintf(f, "\\\\");
|
||||
else if (c > ' ' && c <= '~')
|
||||
putc((char) c, f);
|
||||
else
|
||||
fprintf(f, "\\u%04lx", (long) c);
|
||||
}
|
||||
|
||||
#endif /* REG_DEBUG */
|
||||
1146
src/regex/regc_lex.c
1146
src/regex/regc_lex.c
File diff suppressed because it is too large
Load Diff
1559
src/regex/regc_nfa.c
1559
src/regex/regc_nfa.c
File diff suppressed because it is too large
Load Diff
@@ -1,51 +0,0 @@
|
||||
/* ========= begin header generated by ./mkh ========= */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* === regcomp.c === */
|
||||
static void p_ere(register struct parse *p, int stop);
|
||||
static void p_ere_exp(register struct parse *p);
|
||||
static void p_str(register struct parse *p);
|
||||
static void p_bre(register struct parse *p, register int end1, register int end2);
|
||||
static int p_simp_re(register struct parse *p, int starordinary);
|
||||
static int p_count(register struct parse *p);
|
||||
static void p_bracket(register struct parse *p);
|
||||
static void p_b_term(register struct parse *p, register cset *cs);
|
||||
static void p_b_cclass(register struct parse *p, register cset *cs);
|
||||
static void p_b_eclass(register struct parse *p, register cset *cs);
|
||||
static char p_b_symbol(register struct parse *p);
|
||||
static char p_b_coll_elem(register struct parse *p, int endc);
|
||||
static char othercase(int ch);
|
||||
static void bothcases(register struct parse *p, int ch);
|
||||
static void ordinary(register struct parse *p, register int ch);
|
||||
static void nonnewline(register struct parse *p);
|
||||
static void repeat(register struct parse *p, sopno start, int from, int to);
|
||||
static int seterr(register struct parse *p, int e);
|
||||
static cset *allocset(register struct parse *p);
|
||||
static void freeset(register struct parse *p, register cset *cs);
|
||||
static int freezeset(register struct parse *p, register cset *cs);
|
||||
static int firstch(register struct parse *p, register cset *cs);
|
||||
static int nch(register struct parse *p, register cset *cs);
|
||||
static void mcadd(register struct parse *p, register cset *cs, register char *cp);
|
||||
static void mcsub(register cset *cs, register char *cp);
|
||||
static int mcin(register cset *cs, register char *cp);
|
||||
static char *mcfind(register cset *cs, register char *cp);
|
||||
static void mcinvert(register struct parse *p, register cset *cs);
|
||||
static void mccase(register struct parse *p, register cset *cs);
|
||||
static int isinsets(register struct re_guts *g, int c);
|
||||
static int samesets(register struct re_guts *g, int c1, int c2);
|
||||
static void categorize(struct parse *p, register struct re_guts *g);
|
||||
static sopno dupl(register struct parse *p, sopno start, sopno finish);
|
||||
static void doemit(register struct parse *p, sop op, size_t opnd);
|
||||
static void doinsert(register struct parse *p, sop op, size_t opnd, sopno pos);
|
||||
static void dofwd(register struct parse *p, sopno pos, sop value);
|
||||
static void enlarge(register struct parse *p, sopno size);
|
||||
static void stripsnug(register struct parse *p, register struct re_guts *g);
|
||||
static void findmust(register struct parse *p, register struct re_guts *g);
|
||||
static sopno pluscount(register struct parse *p, register struct re_guts *g);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/* ========= end header generated by ./mkh ========= */
|
||||
@@ -1,699 +0,0 @@
|
||||
/*
|
||||
* DFA routines
|
||||
* This file is #included by regexec.c.
|
||||
*
|
||||
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
|
||||
*
|
||||
* Development of this software was funded, in part, by Cray Research Inc.,
|
||||
* UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
|
||||
* Corporation, none of whom are responsible for the results. The author
|
||||
* thanks all of them.
|
||||
*
|
||||
* Redistribution and use in source and binary forms -- with or without
|
||||
* modification -- are permitted for any purpose, provided that
|
||||
* redistributions in source form retain this entire copyright notice and
|
||||
* indicate the origin and nature of any modifications.
|
||||
*
|
||||
* I'd appreciate being given credit for this package in the documentation
|
||||
* of software which uses it, but that is not a requirement.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED ``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
|
||||
* HENRY SPENCER 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.
|
||||
*
|
||||
* $Header$
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* longest - longest-preferred matching engine
|
||||
*/
|
||||
static chr * /* endpoint, or NULL */
|
||||
longest(struct vars * v, /* used only for debug and exec flags */
|
||||
struct dfa * d,
|
||||
chr *start, /* where the match should start */
|
||||
chr *stop, /* match must end at or before here */
|
||||
int *hitstopp) /* record whether hit v->stop, if non-NULL */
|
||||
{
|
||||
chr *cp;
|
||||
chr *realstop = (stop == v->stop) ? stop : stop + 1;
|
||||
color co;
|
||||
struct sset *css;
|
||||
struct sset *ss;
|
||||
chr *post;
|
||||
int i;
|
||||
struct colormap *cm = d->cm;
|
||||
|
||||
/* initialize */
|
||||
css = initialize(v, d, start);
|
||||
cp = start;
|
||||
if (hitstopp != NULL)
|
||||
*hitstopp = 0;
|
||||
|
||||
/* startup */
|
||||
FDEBUG(("+++ startup +++\n"));
|
||||
if (cp == v->start)
|
||||
{
|
||||
co = d->cnfa->bos[(v->eflags & REG_NOTBOL) ? 0 : 1];
|
||||
FDEBUG(("color %ld\n", (long) co));
|
||||
}
|
||||
else
|
||||
{
|
||||
co = GETCOLOR(cm, *(cp - 1));
|
||||
FDEBUG(("char %c, color %ld\n", (char) *(cp - 1), (long) co));
|
||||
}
|
||||
css = miss(v, d, css, co, cp, start);
|
||||
if (css == NULL)
|
||||
return NULL;
|
||||
css->lastseen = cp;
|
||||
|
||||
/* main loop */
|
||||
if (v->eflags & REG_FTRACE)
|
||||
while (cp < realstop)
|
||||
{
|
||||
FDEBUG(("+++ at c%d +++\n", css - d->ssets));
|
||||
co = GETCOLOR(cm, *cp);
|
||||
FDEBUG(("char %c, color %ld\n", (char) *cp, (long) co));
|
||||
ss = css->outs[co];
|
||||
if (ss == NULL)
|
||||
{
|
||||
ss = miss(v, d, css, co, cp + 1, start);
|
||||
if (ss == NULL)
|
||||
break; /* NOTE BREAK OUT */
|
||||
}
|
||||
cp++;
|
||||
ss->lastseen = cp;
|
||||
css = ss;
|
||||
}
|
||||
else
|
||||
while (cp < realstop)
|
||||
{
|
||||
co = GETCOLOR(cm, *cp);
|
||||
ss = css->outs[co];
|
||||
if (ss == NULL)
|
||||
{
|
||||
ss = miss(v, d, css, co, cp + 1, start);
|
||||
if (ss == NULL)
|
||||
break; /* NOTE BREAK OUT */
|
||||
}
|
||||
cp++;
|
||||
ss->lastseen = cp;
|
||||
css = ss;
|
||||
}
|
||||
|
||||
/* shutdown */
|
||||
FDEBUG(("+++ shutdown at c%d +++\n", css - d->ssets));
|
||||
if (cp == v->stop && stop == v->stop)
|
||||
{
|
||||
if (hitstopp != NULL)
|
||||
*hitstopp = 1;
|
||||
co = d->cnfa->eos[(v->eflags & REG_NOTEOL) ? 0 : 1];
|
||||
FDEBUG(("color %ld\n", (long) co));
|
||||
ss = miss(v, d, css, co, cp, start);
|
||||
/* special case: match ended at eol? */
|
||||
if (ss != NULL && (ss->flags & POSTSTATE))
|
||||
return cp;
|
||||
else if (ss != NULL)
|
||||
ss->lastseen = cp; /* to be tidy */
|
||||
}
|
||||
|
||||
/* find last match, if any */
|
||||
post = d->lastpost;
|
||||
for (ss = d->ssets, i = d->nssused; i > 0; ss++, i--)
|
||||
if ((ss->flags & POSTSTATE) && post != ss->lastseen &&
|
||||
(post == NULL || post < ss->lastseen))
|
||||
post = ss->lastseen;
|
||||
if (post != NULL) /* found one */
|
||||
return post - 1;
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* shortest - shortest-preferred matching engine
|
||||
*/
|
||||
static chr * /* endpoint, or NULL */
|
||||
shortest(struct vars * v,
|
||||
struct dfa * d,
|
||||
chr *start, /* where the match should start */
|
||||
chr *min, /* match must end at or after here */
|
||||
chr *max, /* match must end at or before here */
|
||||
chr **coldp, /* store coldstart pointer here, if
|
||||
* nonNULL */
|
||||
int *hitstopp) /* record whether hit v->stop, if non-NULL */
|
||||
{
|
||||
chr *cp;
|
||||
chr *realmin = (min == v->stop) ? min : min + 1;
|
||||
chr *realmax = (max == v->stop) ? max : max + 1;
|
||||
color co;
|
||||
struct sset *css;
|
||||
struct sset *ss;
|
||||
struct colormap *cm = d->cm;
|
||||
|
||||
/* initialize */
|
||||
css = initialize(v, d, start);
|
||||
cp = start;
|
||||
if (hitstopp != NULL)
|
||||
*hitstopp = 0;
|
||||
|
||||
/* startup */
|
||||
FDEBUG(("--- startup ---\n"));
|
||||
if (cp == v->start)
|
||||
{
|
||||
co = d->cnfa->bos[(v->eflags & REG_NOTBOL) ? 0 : 1];
|
||||
FDEBUG(("color %ld\n", (long) co));
|
||||
}
|
||||
else
|
||||
{
|
||||
co = GETCOLOR(cm, *(cp - 1));
|
||||
FDEBUG(("char %c, color %ld\n", (char) *(cp - 1), (long) co));
|
||||
}
|
||||
css = miss(v, d, css, co, cp, start);
|
||||
if (css == NULL)
|
||||
return NULL;
|
||||
css->lastseen = cp;
|
||||
ss = css;
|
||||
|
||||
/* main loop */
|
||||
if (v->eflags & REG_FTRACE)
|
||||
while (cp < realmax)
|
||||
{
|
||||
FDEBUG(("--- at c%d ---\n", css - d->ssets));
|
||||
co = GETCOLOR(cm, *cp);
|
||||
FDEBUG(("char %c, color %ld\n", (char) *cp, (long) co));
|
||||
ss = css->outs[co];
|
||||
if (ss == NULL)
|
||||
{
|
||||
ss = miss(v, d, css, co, cp + 1, start);
|
||||
if (ss == NULL)
|
||||
break; /* NOTE BREAK OUT */
|
||||
}
|
||||
cp++;
|
||||
ss->lastseen = cp;
|
||||
css = ss;
|
||||
if ((ss->flags & POSTSTATE) && cp >= realmin)
|
||||
break; /* NOTE BREAK OUT */
|
||||
}
|
||||
else
|
||||
while (cp < realmax)
|
||||
{
|
||||
co = GETCOLOR(cm, *cp);
|
||||
ss = css->outs[co];
|
||||
if (ss == NULL)
|
||||
{
|
||||
ss = miss(v, d, css, co, cp + 1, start);
|
||||
if (ss == NULL)
|
||||
break; /* NOTE BREAK OUT */
|
||||
}
|
||||
cp++;
|
||||
ss->lastseen = cp;
|
||||
css = ss;
|
||||
if ((ss->flags & POSTSTATE) && cp >= realmin)
|
||||
break; /* NOTE BREAK OUT */
|
||||
}
|
||||
|
||||
if (ss == NULL)
|
||||
return NULL;
|
||||
|
||||
if (coldp != NULL) /* report last no-progress state set, if
|
||||
* any */
|
||||
*coldp = lastcold(v, d);
|
||||
|
||||
if ((ss->flags & POSTSTATE) && cp > min)
|
||||
{
|
||||
assert(cp >= realmin);
|
||||
cp--;
|
||||
}
|
||||
else if (cp == v->stop && max == v->stop)
|
||||
{
|
||||
co = d->cnfa->eos[(v->eflags & REG_NOTEOL) ? 0 : 1];
|
||||
FDEBUG(("color %ld\n", (long) co));
|
||||
ss = miss(v, d, css, co, cp, start);
|
||||
/* match might have ended at eol */
|
||||
if ((ss == NULL || !(ss->flags & POSTSTATE)) && hitstopp != NULL)
|
||||
*hitstopp = 1;
|
||||
}
|
||||
|
||||
if (ss == NULL || !(ss->flags & POSTSTATE))
|
||||
return NULL;
|
||||
|
||||
return cp;
|
||||
}
|
||||
|
||||
/*
|
||||
* lastcold - determine last point at which no progress had been made
|
||||
*/
|
||||
static chr * /* endpoint, or NULL */
|
||||
lastcold(struct vars * v,
|
||||
struct dfa * d)
|
||||
{
|
||||
struct sset *ss;
|
||||
chr *nopr;
|
||||
int i;
|
||||
|
||||
nopr = d->lastnopr;
|
||||
if (nopr == NULL)
|
||||
nopr = v->start;
|
||||
for (ss = d->ssets, i = d->nssused; i > 0; ss++, i--)
|
||||
if ((ss->flags & NOPROGRESS) && nopr < ss->lastseen)
|
||||
nopr = ss->lastseen;
|
||||
return nopr;
|
||||
}
|
||||
|
||||
/*
|
||||
* newdfa - set up a fresh DFA
|
||||
*/
|
||||
static struct dfa *
|
||||
newdfa(struct vars * v,
|
||||
struct cnfa * cnfa,
|
||||
struct colormap * cm,
|
||||
struct smalldfa * small) /* preallocated space, may be NULL */
|
||||
{
|
||||
struct dfa *d;
|
||||
size_t nss = cnfa->nstates * 2;
|
||||
int wordsper = (cnfa->nstates + UBITS - 1) / UBITS;
|
||||
struct smalldfa *smallwas = small;
|
||||
|
||||
assert(cnfa != NULL && cnfa->nstates != 0);
|
||||
|
||||
if (nss <= FEWSTATES && cnfa->ncolors <= FEWCOLORS)
|
||||
{
|
||||
assert(wordsper == 1);
|
||||
if (small == NULL)
|
||||
{
|
||||
small = (struct smalldfa *) MALLOC(
|
||||
sizeof(struct smalldfa));
|
||||
if (small == NULL)
|
||||
{
|
||||
ERR(REG_ESPACE);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
d = &small->dfa;
|
||||
d->ssets = small->ssets;
|
||||
d->statesarea = small->statesarea;
|
||||
d->work = &d->statesarea[nss];
|
||||
d->outsarea = small->outsarea;
|
||||
d->incarea = small->incarea;
|
||||
d->cptsmalloced = 0;
|
||||
d->mallocarea = (smallwas == NULL) ? (char *) small : NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
d = (struct dfa *) MALLOC(sizeof(struct dfa));
|
||||
if (d == NULL)
|
||||
{
|
||||
ERR(REG_ESPACE);
|
||||
return NULL;
|
||||
}
|
||||
d->ssets = (struct sset *) MALLOC(nss * sizeof(struct sset));
|
||||
d->statesarea = (unsigned *) MALLOC((nss + WORK) * wordsper *
|
||||
sizeof(unsigned));
|
||||
d->work = &d->statesarea[nss * wordsper];
|
||||
d->outsarea = (struct sset **) MALLOC(nss * cnfa->ncolors *
|
||||
sizeof(struct sset *));
|
||||
d->incarea = (struct arcp *) MALLOC(nss * cnfa->ncolors *
|
||||
sizeof(struct arcp));
|
||||
d->cptsmalloced = 1;
|
||||
d->mallocarea = (char *) d;
|
||||
if (d->ssets == NULL || d->statesarea == NULL ||
|
||||
d->outsarea == NULL || d->incarea == NULL)
|
||||
{
|
||||
freedfa(d);
|
||||
ERR(REG_ESPACE);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
d->nssets = (v->eflags & REG_SMALL) ? 7 : nss;
|
||||
d->nssused = 0;
|
||||
d->nstates = cnfa->nstates;
|
||||
d->ncolors = cnfa->ncolors;
|
||||
d->wordsper = wordsper;
|
||||
d->cnfa = cnfa;
|
||||
d->cm = cm;
|
||||
d->lastpost = NULL;
|
||||
d->lastnopr = NULL;
|
||||
d->search = d->ssets;
|
||||
|
||||
/* initialization of sset fields is done as needed */
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
/*
|
||||
* freedfa - free a DFA
|
||||
*/
|
||||
static void
|
||||
freedfa(struct dfa * d)
|
||||
{
|
||||
if (d->cptsmalloced)
|
||||
{
|
||||
if (d->ssets != NULL)
|
||||
FREE(d->ssets);
|
||||
if (d->statesarea != NULL)
|
||||
FREE(d->statesarea);
|
||||
if (d->outsarea != NULL)
|
||||
FREE(d->outsarea);
|
||||
if (d->incarea != NULL)
|
||||
FREE(d->incarea);
|
||||
}
|
||||
|
||||
if (d->mallocarea != NULL)
|
||||
FREE(d->mallocarea);
|
||||
}
|
||||
|
||||
/*
|
||||
* hash - construct a hash code for a bitvector
|
||||
*
|
||||
* There are probably better ways, but they're more expensive.
|
||||
*/
|
||||
static unsigned
|
||||
hash(unsigned *uv,
|
||||
int n)
|
||||
{
|
||||
int i;
|
||||
unsigned h;
|
||||
|
||||
h = 0;
|
||||
for (i = 0; i < n; i++)
|
||||
h ^= uv[i];
|
||||
return h;
|
||||
}
|
||||
|
||||
/*
|
||||
* initialize - hand-craft a cache entry for startup, otherwise get ready
|
||||
*/
|
||||
static struct sset *
|
||||
initialize(struct vars * v, /* used only for debug flags */
|
||||
struct dfa * d,
|
||||
chr *start)
|
||||
{
|
||||
struct sset *ss;
|
||||
int i;
|
||||
|
||||
/* is previous one still there? */
|
||||
if (d->nssused > 0 && (d->ssets[0].flags & STARTER))
|
||||
ss = &d->ssets[0];
|
||||
else
|
||||
{ /* no, must (re)build it */
|
||||
ss = getvacant(v, d, start, start);
|
||||
for (i = 0; i < d->wordsper; i++)
|
||||
ss->states[i] = 0;
|
||||
BSET(ss->states, d->cnfa->pre);
|
||||
ss->hash = HASH(ss->states, d->wordsper);
|
||||
assert(d->cnfa->pre != d->cnfa->post);
|
||||
ss->flags = STARTER | LOCKED | NOPROGRESS;
|
||||
/* lastseen dealt with below */
|
||||
}
|
||||
|
||||
for (i = 0; i < d->nssused; i++)
|
||||
d->ssets[i].lastseen = NULL;
|
||||
ss->lastseen = start; /* maybe untrue, but harmless */
|
||||
d->lastpost = NULL;
|
||||
d->lastnopr = NULL;
|
||||
return ss;
|
||||
}
|
||||
|
||||
/*
|
||||
* miss - handle a cache miss
|
||||
*/
|
||||
static struct sset * /* NULL if goes to empty set */
|
||||
miss(struct vars * v, /* used only for debug flags */
|
||||
struct dfa * d,
|
||||
struct sset * css,
|
||||
pcolor co,
|
||||
chr *cp, /* next chr */
|
||||
chr *start) /* where the attempt got started */
|
||||
{
|
||||
struct cnfa *cnfa = d->cnfa;
|
||||
int i;
|
||||
unsigned h;
|
||||
struct carc *ca;
|
||||
struct sset *p;
|
||||
int ispost;
|
||||
int noprogress;
|
||||
int gotstate;
|
||||
int dolacons;
|
||||
int sawlacons;
|
||||
|
||||
/* for convenience, we can be called even if it might not be a miss */
|
||||
if (css->outs[co] != NULL)
|
||||
{
|
||||
FDEBUG(("hit\n"));
|
||||
return css->outs[co];
|
||||
}
|
||||
FDEBUG(("miss\n"));
|
||||
|
||||
/* first, what set of states would we end up in? */
|
||||
for (i = 0; i < d->wordsper; i++)
|
||||
d->work[i] = 0;
|
||||
ispost = 0;
|
||||
noprogress = 1;
|
||||
gotstate = 0;
|
||||
for (i = 0; i < d->nstates; i++)
|
||||
if (ISBSET(css->states, i))
|
||||
for (ca = cnfa->states[i] + 1; ca->co != COLORLESS; ca++)
|
||||
if (ca->co == co)
|
||||
{
|
||||
BSET(d->work, ca->to);
|
||||
gotstate = 1;
|
||||
if (ca->to == cnfa->post)
|
||||
ispost = 1;
|
||||
if (!cnfa->states[ca->to]->co)
|
||||
noprogress = 0;
|
||||
FDEBUG(("%d -> %d\n", i, ca->to));
|
||||
}
|
||||
dolacons = (gotstate) ? (cnfa->flags & HASLACONS) : 0;
|
||||
sawlacons = 0;
|
||||
while (dolacons)
|
||||
{ /* transitive closure */
|
||||
dolacons = 0;
|
||||
for (i = 0; i < d->nstates; i++)
|
||||
if (ISBSET(d->work, i))
|
||||
for (ca = cnfa->states[i] + 1; ca->co != COLORLESS;
|
||||
ca++)
|
||||
{
|
||||
if (ca->co <= cnfa->ncolors)
|
||||
continue; /* NOTE CONTINUE */
|
||||
sawlacons = 1;
|
||||
if (ISBSET(d->work, ca->to))
|
||||
continue; /* NOTE CONTINUE */
|
||||
if (!lacon(v, cnfa, cp, ca->co))
|
||||
continue; /* NOTE CONTINUE */
|
||||
BSET(d->work, ca->to);
|
||||
dolacons = 1;
|
||||
if (ca->to == cnfa->post)
|
||||
ispost = 1;
|
||||
if (!cnfa->states[ca->to]->co)
|
||||
noprogress = 0;
|
||||
FDEBUG(("%d :> %d\n", i, ca->to));
|
||||
}
|
||||
}
|
||||
if (!gotstate)
|
||||
return NULL;
|
||||
h = HASH(d->work, d->wordsper);
|
||||
|
||||
/* next, is that in the cache? */
|
||||
for (p = d->ssets, i = d->nssused; i > 0; p++, i--)
|
||||
if (HIT(h, d->work, p, d->wordsper))
|
||||
{
|
||||
FDEBUG(("cached c%d\n", p - d->ssets));
|
||||
break; /* NOTE BREAK OUT */
|
||||
}
|
||||
if (i == 0)
|
||||
{ /* nope, need a new cache entry */
|
||||
p = getvacant(v, d, cp, start);
|
||||
assert(p != css);
|
||||
for (i = 0; i < d->wordsper; i++)
|
||||
p->states[i] = d->work[i];
|
||||
p->hash = h;
|
||||
p->flags = (ispost) ? POSTSTATE : 0;
|
||||
if (noprogress)
|
||||
p->flags |= NOPROGRESS;
|
||||
/* lastseen to be dealt with by caller */
|
||||
}
|
||||
|
||||
if (!sawlacons)
|
||||
{ /* lookahead conds. always cache miss */
|
||||
FDEBUG(("c%d[%d]->c%d\n", css - d->ssets, co, p - d->ssets));
|
||||
css->outs[co] = p;
|
||||
css->inchain[co] = p->ins;
|
||||
p->ins.ss = css;
|
||||
p->ins.co = (color) co;
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
/*
|
||||
* lacon - lookahead-constraint checker for miss()
|
||||
*/
|
||||
static int /* predicate: constraint satisfied? */
|
||||
lacon(struct vars * v,
|
||||
struct cnfa * pcnfa, /* parent cnfa */
|
||||
chr *cp,
|
||||
pcolor co) /* "color" of the lookahead constraint */
|
||||
{
|
||||
int n;
|
||||
struct subre *sub;
|
||||
struct dfa *d;
|
||||
struct smalldfa sd;
|
||||
chr *end;
|
||||
|
||||
n = co - pcnfa->ncolors;
|
||||
assert(n < v->g->nlacons && v->g->lacons != NULL);
|
||||
FDEBUG(("=== testing lacon %d\n", n));
|
||||
sub = &v->g->lacons[n];
|
||||
d = newdfa(v, &sub->cnfa, &v->g->cmap, &sd);
|
||||
if (d == NULL)
|
||||
{
|
||||
ERR(REG_ESPACE);
|
||||
return 0;
|
||||
}
|
||||
end = longest(v, d, cp, v->stop, (int *) NULL);
|
||||
freedfa(d);
|
||||
FDEBUG(("=== lacon %d match %d\n", n, (end != NULL)));
|
||||
return (sub->subno) ? (end != NULL) : (end == NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* getvacant - get a vacant state set
|
||||
* This routine clears out the inarcs and outarcs, but does not otherwise
|
||||
* clear the innards of the state set -- that's up to the caller.
|
||||
*/
|
||||
static struct sset *
|
||||
getvacant(struct vars * v, /* used only for debug flags */
|
||||
struct dfa * d,
|
||||
chr *cp,
|
||||
chr *start)
|
||||
{
|
||||
int i;
|
||||
struct sset *ss;
|
||||
struct sset *p;
|
||||
struct arcp ap;
|
||||
struct arcp lastap;
|
||||
color co;
|
||||
|
||||
ss = pickss(v, d, cp, start);
|
||||
assert(!(ss->flags & LOCKED));
|
||||
|
||||
/* clear out its inarcs, including self-referential ones */
|
||||
ap = ss->ins;
|
||||
while ((p = ap.ss) != NULL)
|
||||
{
|
||||
co = ap.co;
|
||||
FDEBUG(("zapping c%d's %ld outarc\n", p - d->ssets, (long) co));
|
||||
p->outs[co] = NULL;
|
||||
ap = p->inchain[co];
|
||||
p->inchain[co].ss = NULL; /* paranoia */
|
||||
}
|
||||
ss->ins.ss = NULL;
|
||||
|
||||
/* take it off the inarc chains of the ssets reached by its outarcs */
|
||||
for (i = 0; i < d->ncolors; i++)
|
||||
{
|
||||
p = ss->outs[i];
|
||||
assert(p != ss); /* not self-referential */
|
||||
if (p == NULL)
|
||||
continue; /* NOTE CONTINUE */
|
||||
FDEBUG(("del outarc %d from c%d's in chn\n", i, p - d->ssets));
|
||||
if (p->ins.ss == ss && p->ins.co == i)
|
||||
p->ins = ss->inchain[i];
|
||||
else
|
||||
{
|
||||
assert(p->ins.ss != NULL);
|
||||
for (ap = p->ins; ap.ss != NULL &&
|
||||
!(ap.ss == ss && ap.co == i);
|
||||
ap = ap.ss->inchain[ap.co])
|
||||
lastap = ap;
|
||||
assert(ap.ss != NULL);
|
||||
lastap.ss->inchain[lastap.co] = ss->inchain[i];
|
||||
}
|
||||
ss->outs[i] = NULL;
|
||||
ss->inchain[i].ss = NULL;
|
||||
}
|
||||
|
||||
/* if ss was a success state, may need to remember location */
|
||||
if ((ss->flags & POSTSTATE) && ss->lastseen != d->lastpost &&
|
||||
(d->lastpost == NULL || d->lastpost < ss->lastseen))
|
||||
d->lastpost = ss->lastseen;
|
||||
|
||||
/* likewise for a no-progress state */
|
||||
if ((ss->flags & NOPROGRESS) && ss->lastseen != d->lastnopr &&
|
||||
(d->lastnopr == NULL || d->lastnopr < ss->lastseen))
|
||||
d->lastnopr = ss->lastseen;
|
||||
|
||||
return ss;
|
||||
}
|
||||
|
||||
/*
|
||||
* pickss - pick the next stateset to be used
|
||||
*/
|
||||
static struct sset *
|
||||
pickss(struct vars * v, /* used only for debug flags */
|
||||
struct dfa * d,
|
||||
chr *cp,
|
||||
chr *start)
|
||||
{
|
||||
int i;
|
||||
struct sset *ss;
|
||||
struct sset *end;
|
||||
chr *ancient;
|
||||
|
||||
/* shortcut for cases where cache isn't full */
|
||||
if (d->nssused < d->nssets)
|
||||
{
|
||||
i = d->nssused;
|
||||
d->nssused++;
|
||||
ss = &d->ssets[i];
|
||||
FDEBUG(("new c%d\n", i));
|
||||
/* set up innards */
|
||||
ss->states = &d->statesarea[i * d->wordsper];
|
||||
ss->flags = 0;
|
||||
ss->ins.ss = NULL;
|
||||
ss->ins.co = WHITE; /* give it some value */
|
||||
ss->outs = &d->outsarea[i * d->ncolors];
|
||||
ss->inchain = &d->incarea[i * d->ncolors];
|
||||
for (i = 0; i < d->ncolors; i++)
|
||||
{
|
||||
ss->outs[i] = NULL;
|
||||
ss->inchain[i].ss = NULL;
|
||||
}
|
||||
return ss;
|
||||
}
|
||||
|
||||
/* look for oldest, or old enough anyway */
|
||||
if (cp - start > d->nssets * 2 / 3) /* oldest 33% are expendable */
|
||||
ancient = cp - d->nssets * 2 / 3;
|
||||
else
|
||||
ancient = start;
|
||||
for (ss = d->search, end = &d->ssets[d->nssets]; ss < end; ss++)
|
||||
if ((ss->lastseen == NULL || ss->lastseen < ancient) &&
|
||||
!(ss->flags & LOCKED))
|
||||
{
|
||||
d->search = ss + 1;
|
||||
FDEBUG(("replacing c%d\n", ss - d->ssets));
|
||||
return ss;
|
||||
}
|
||||
for (ss = d->ssets, end = d->search; ss < end; ss++)
|
||||
if ((ss->lastseen == NULL || ss->lastseen < ancient) &&
|
||||
!(ss->flags & LOCKED))
|
||||
{
|
||||
d->search = ss + 1;
|
||||
FDEBUG(("replacing c%d\n", ss - d->ssets));
|
||||
return ss;
|
||||
}
|
||||
|
||||
/* nobody's old enough?!? -- something's really wrong */
|
||||
FDEBUG(("can't find victim to replace!\n"));
|
||||
assert(NOTREACHED);
|
||||
ERR(REG_ASSERT);
|
||||
return d->ssets;
|
||||
}
|
||||
@@ -1,109 +0,0 @@
|
||||
/*
|
||||
* regerror - error-code expansion
|
||||
*
|
||||
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
|
||||
*
|
||||
* Development of this software was funded, in part, by Cray Research Inc.,
|
||||
* UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
|
||||
* Corporation, none of whom are responsible for the results. The author
|
||||
* thanks all of them.
|
||||
*
|
||||
* Redistribution and use in source and binary forms -- with or without
|
||||
* modification -- are permitted for any purpose, provided that
|
||||
* redistributions in source form retain this entire copyright notice and
|
||||
* indicate the origin and nature of any modifications.
|
||||
*
|
||||
* I'd appreciate being given credit for this package in the documentation
|
||||
* of software which uses it, but that is not a requirement.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED ``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
|
||||
* HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
||||
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "regguts.h"
|
||||
|
||||
/* unknown-error explanation */
|
||||
static char unk[] = "*** unknown regex error code 0x%x ***";
|
||||
|
||||
/* struct to map among codes, code names, and explanations */
|
||||
static struct rerr {
|
||||
int code;
|
||||
char *name;
|
||||
char *explain;
|
||||
} rerrs[] = {
|
||||
/* the actual table is built from regex.h */
|
||||
# include "regerrs.h"
|
||||
{ -1, "", "oops" }, /* explanation special-cased in code */
|
||||
};
|
||||
|
||||
/*
|
||||
- regerror - the interface to error numbers
|
||||
*/
|
||||
/* ARGSUSED */
|
||||
size_t /* actual space needed (including NUL) */
|
||||
regerror(errcode, preg, errbuf, errbuf_size)
|
||||
int errcode; /* error code, or REG_ATOI or REG_ITOA */
|
||||
CONST regex_t *preg; /* associated regex_t (unused at present) */
|
||||
char *errbuf; /* result buffer (unless errbuf_size==0) */
|
||||
size_t errbuf_size; /* available space in errbuf, can be 0 */
|
||||
{
|
||||
struct rerr *r;
|
||||
char *msg;
|
||||
char convbuf[sizeof(unk)+50]; /* 50 = plenty for int */
|
||||
size_t len;
|
||||
int icode;
|
||||
|
||||
switch (errcode) {
|
||||
case REG_ATOI: /* convert name to number */
|
||||
for (r = rerrs; r->code >= 0; r++)
|
||||
if (strcmp(r->name, errbuf) == 0)
|
||||
break;
|
||||
sprintf(convbuf, "%d", r->code); /* -1 for unknown */
|
||||
msg = convbuf;
|
||||
break;
|
||||
case REG_ITOA: /* convert number to name */
|
||||
icode = atoi(errbuf); /* not our problem if this fails */
|
||||
for (r = rerrs; r->code >= 0; r++)
|
||||
if (r->code == icode)
|
||||
break;
|
||||
if (r->code >= 0)
|
||||
msg = r->name;
|
||||
else { /* unknown; tell him the number */
|
||||
sprintf(convbuf, "REG_%u", (unsigned)icode);
|
||||
msg = convbuf;
|
||||
}
|
||||
break;
|
||||
default: /* a real, normal error code */
|
||||
for (r = rerrs; r->code >= 0; r++)
|
||||
if (r->code == errcode)
|
||||
break;
|
||||
if (r->code >= 0)
|
||||
msg = r->explain;
|
||||
else { /* unknown; say so */
|
||||
sprintf(convbuf, unk, errcode);
|
||||
msg = convbuf;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
len = strlen(msg) + 1; /* space needed, including NUL */
|
||||
if (errbuf_size > 0) {
|
||||
if (errbuf_size > len)
|
||||
strcpy(errbuf, msg);
|
||||
else { /* truncate to fit */
|
||||
strncpy(errbuf, msg, errbuf_size-1);
|
||||
errbuf[errbuf_size-1] = '\0';
|
||||
}
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
/* ========= begin header generated by ./mkh ========= */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* === regerror.c === */
|
||||
static char *regatoi(const regex_t *preg, char *localbuf);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/* ========= end header generated by ./mkh ========= */
|
||||
@@ -1,75 +0,0 @@
|
||||
/*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
{
|
||||
REG_OKAY, "REG_OKAY", "no errors detected"
|
||||
},
|
||||
|
||||
{
|
||||
REG_NOMATCH, "REG_NOMATCH", "failed to match"
|
||||
},
|
||||
|
||||
{
|
||||
REG_BADPAT, "REG_BADPAT", "invalid regexp (reg version 0.8)"
|
||||
},
|
||||
|
||||
{
|
||||
REG_ECOLLATE, "REG_ECOLLATE", "invalid collating element"
|
||||
},
|
||||
|
||||
{
|
||||
REG_ECTYPE, "REG_ECTYPE", "invalid character class"
|
||||
},
|
||||
|
||||
{
|
||||
REG_EESCAPE, "REG_EESCAPE", "invalid escape \\ sequence"
|
||||
},
|
||||
|
||||
{
|
||||
REG_ESUBREG, "REG_ESUBREG", "invalid backreference number"
|
||||
},
|
||||
|
||||
{
|
||||
REG_EBRACK, "REG_EBRACK", "brackets [] not balanced"
|
||||
},
|
||||
|
||||
{
|
||||
REG_EPAREN, "REG_EPAREN", "parentheses () not balanced"
|
||||
},
|
||||
|
||||
{
|
||||
REG_EBRACE, "REG_EBRACE", "braces {} not balanced"
|
||||
},
|
||||
|
||||
{
|
||||
REG_BADBR, "REG_BADBR", "invalid repetition count(s)"
|
||||
},
|
||||
|
||||
{
|
||||
REG_ERANGE, "REG_ERANGE", "invalid character range"
|
||||
},
|
||||
|
||||
{
|
||||
REG_ESPACE, "REG_ESPACE", "out of memory"
|
||||
},
|
||||
|
||||
{
|
||||
REG_BADRPT, "REG_BADRPT", "quantifier operand invalid"
|
||||
},
|
||||
|
||||
{
|
||||
REG_ASSERT, "REG_ASSERT", "\"can't happen\" -- you found a bug"
|
||||
},
|
||||
|
||||
{
|
||||
REG_INVARG, "REG_INVARG", "invalid argument to regex function"
|
||||
},
|
||||
|
||||
{
|
||||
REG_MIXED, "REG_MIXED", "character widths of regex and string differ"
|
||||
},
|
||||
|
||||
{
|
||||
REG_BADOPT, "REG_BADOPT", "invalid embedded option"
|
||||
},
|
||||
@@ -1,509 +0,0 @@
|
||||
.TH REGEX 3 "25 Sept 1997"
|
||||
.BY "Henry Spencer"
|
||||
.de ZR
|
||||
.\" one other place knows this name: the SEE ALSO section
|
||||
.IR regex (7) \\$1
|
||||
..
|
||||
.SH NAME
|
||||
regcomp, regexec, regerror, regfree \- regular-expression library
|
||||
.SH SYNOPSIS
|
||||
.ft B
|
||||
.\".na
|
||||
#include <sys/types.h>
|
||||
.br
|
||||
#include <regex.h>
|
||||
.HP 10
|
||||
int regcomp(regex_t\ *preg, const\ char\ *pattern, int\ cflags);
|
||||
.HP
|
||||
int\ regexec(const\ regex_t\ *preg, const\ char\ *string,
|
||||
size_t\ nmatch, regmatch_t\ pmatch[], int\ eflags);
|
||||
.HP
|
||||
size_t\ regerror(int\ errcode, const\ regex_t\ *preg,
|
||||
char\ *errbuf, size_t\ errbuf_size);
|
||||
.HP
|
||||
void\ regfree(regex_t\ *preg);
|
||||
.\".ad
|
||||
.ft
|
||||
.SH DESCRIPTION
|
||||
These routines implement POSIX 1003.2 regular expressions (``RE''s);
|
||||
see
|
||||
.ZR .
|
||||
.I Regcomp
|
||||
compiles an RE written as a string into an internal form,
|
||||
.I regexec
|
||||
matches that internal form against a string and reports results,
|
||||
.I regerror
|
||||
transforms error codes from either into human-readable messages,
|
||||
and
|
||||
.I regfree
|
||||
frees any dynamically-allocated storage used by the internal form
|
||||
of an RE.
|
||||
.PP
|
||||
The header
|
||||
.I <regex.h>
|
||||
declares two structure types,
|
||||
.I regex_t
|
||||
and
|
||||
.IR regmatch_t ,
|
||||
the former for compiled internal forms and the latter for match reporting.
|
||||
It also declares the four functions,
|
||||
a type
|
||||
.IR regoff_t ,
|
||||
and a number of constants with names starting with ``REG_''.
|
||||
.PP
|
||||
.I Regcomp
|
||||
compiles the regular expression contained in the
|
||||
.I pattern
|
||||
string,
|
||||
subject to the flags in
|
||||
.IR cflags ,
|
||||
and places the results in the
|
||||
.I regex_t
|
||||
structure pointed to by
|
||||
.IR preg .
|
||||
.I Cflags
|
||||
is the bitwise OR of zero or more of the following flags:
|
||||
.IP REG_EXTENDED \w'REG_EXTENDED'u+2n
|
||||
Compile modern (``extended'') REs,
|
||||
rather than the obsolete (``basic'') REs that
|
||||
are the default.
|
||||
.IP REG_BASIC
|
||||
This is a synonym for 0,
|
||||
provided as a counterpart to REG_EXTENDED to improve readability.
|
||||
This is an extension,
|
||||
compatible with but not specified by POSIX 1003.2,
|
||||
and should be used with
|
||||
caution in software intended to be portable to other systems.
|
||||
.IP REG_NOSPEC
|
||||
Compile with recognition of all special characters turned off.
|
||||
All characters are thus considered ordinary,
|
||||
so the ``RE'' is a literal string.
|
||||
This is an extension,
|
||||
compatible with but not specified by POSIX 1003.2,
|
||||
and should be used with
|
||||
caution in software intended to be portable to other systems.
|
||||
REG_EXTENDED and REG_NOSPEC may not be used
|
||||
in the same call to
|
||||
.IR regcomp .
|
||||
.IP REG_ICASE
|
||||
Compile for matching that ignores upper/lower case distinctions.
|
||||
See
|
||||
.ZR .
|
||||
.IP REG_NOSUB
|
||||
Compile for matching that need only report success or failure,
|
||||
not what was matched.
|
||||
.IP REG_NEWLINE
|
||||
Compile for newline-sensitive matching.
|
||||
By default, newline is a completely ordinary character with no special
|
||||
meaning in either REs or strings.
|
||||
With this flag,
|
||||
`[^' bracket expressions and `.' never match newline,
|
||||
a `^' anchor matches the null string after any newline in the string
|
||||
in addition to its normal function,
|
||||
and the `$' anchor matches the null string before any newline in the
|
||||
string in addition to its normal function.
|
||||
.IP REG_PEND
|
||||
The regular expression ends,
|
||||
not at the first NUL,
|
||||
but just before the character pointed to by the
|
||||
.I re_endp
|
||||
member of the structure pointed to by
|
||||
.IR preg .
|
||||
The
|
||||
.I re_endp
|
||||
member is of type
|
||||
.IR const\ char\ * .
|
||||
This flag permits inclusion of NULs in the RE;
|
||||
they are considered ordinary characters.
|
||||
This is an extension,
|
||||
compatible with but not specified by POSIX 1003.2,
|
||||
and should be used with
|
||||
caution in software intended to be portable to other systems.
|
||||
.PP
|
||||
When successful,
|
||||
.I regcomp
|
||||
returns 0 and fills in the structure pointed to by
|
||||
.IR preg .
|
||||
One member of that structure
|
||||
(other than
|
||||
.IR re_endp )
|
||||
is publicized:
|
||||
.IR re_nsub ,
|
||||
of type
|
||||
.IR size_t ,
|
||||
contains the number of parenthesized subexpressions within the RE
|
||||
(except that the value of this member is undefined if the
|
||||
REG_NOSUB flag was used).
|
||||
If
|
||||
.I regcomp
|
||||
fails, it returns a non-zero error code;
|
||||
see DIAGNOSTICS.
|
||||
.PP
|
||||
.I Regexec
|
||||
matches the compiled RE pointed to by
|
||||
.I preg
|
||||
against the
|
||||
.IR string ,
|
||||
subject to the flags in
|
||||
.IR eflags ,
|
||||
and reports results using
|
||||
.IR nmatch ,
|
||||
.IR pmatch ,
|
||||
and the returned value.
|
||||
The RE must have been compiled by a previous invocation of
|
||||
.IR regcomp .
|
||||
The compiled form is not altered during execution of
|
||||
.IR regexec ,
|
||||
so a single compiled RE can be used simultaneously by multiple threads.
|
||||
.PP
|
||||
By default,
|
||||
the NUL-terminated string pointed to by
|
||||
.I string
|
||||
is considered to be the text of an entire line,
|
||||
with the NUL indicating the end of the line.
|
||||
(That is,
|
||||
any other end-of-line marker is considered to have been removed
|
||||
and replaced by the NUL.)
|
||||
The
|
||||
.I eflags
|
||||
argument is the bitwise OR of zero or more of the following flags:
|
||||
.IP REG_NOTBOL \w'REG_STARTEND'u+2n
|
||||
The first character of
|
||||
the string
|
||||
is not the beginning of a line, so the `^' anchor should not match before it.
|
||||
This does not affect the behavior of newlines under REG_NEWLINE.
|
||||
.IP REG_NOTEOL
|
||||
The NUL terminating
|
||||
the string
|
||||
does not end a line, so the `$' anchor should not match before it.
|
||||
This does not affect the behavior of newlines under REG_NEWLINE.
|
||||
.IP REG_STARTEND
|
||||
The string is considered to start at
|
||||
\fIstring\fR\ + \fIpmatch\fR[0].\fIrm_so\fR
|
||||
and to have a terminating NUL located at
|
||||
\fIstring\fR\ + \fIpmatch\fR[0].\fIrm_eo\fR
|
||||
(there need not actually be a NUL at that location),
|
||||
regardless of the value of
|
||||
.IR nmatch .
|
||||
See below for the definition of
|
||||
.IR pmatch
|
||||
and
|
||||
.IR nmatch .
|
||||
This is an extension,
|
||||
compatible with but not specified by POSIX 1003.2,
|
||||
and should be used with
|
||||
caution in software intended to be portable to other systems.
|
||||
Note that a non-zero \fIrm_so\fR does not imply REG_NOTBOL;
|
||||
REG_STARTEND affects only the location of the string,
|
||||
not how it is matched.
|
||||
.PP
|
||||
See
|
||||
.ZR
|
||||
for a discussion of what is matched in situations where an RE or a
|
||||
portion thereof could match any of several substrings of
|
||||
.IR string .
|
||||
.PP
|
||||
Normally,
|
||||
.I regexec
|
||||
returns 0 for success and the non-zero code REG_NOMATCH for failure.
|
||||
Other non-zero error codes may be returned in exceptional situations;
|
||||
see DIAGNOSTICS.
|
||||
.PP
|
||||
If REG_NOSUB was specified in the compilation of the RE,
|
||||
or if
|
||||
.I nmatch
|
||||
is 0,
|
||||
.I regexec
|
||||
ignores the
|
||||
.I pmatch
|
||||
argument (but see below for the case where REG_STARTEND is specified).
|
||||
Otherwise,
|
||||
.I pmatch
|
||||
points to an array of
|
||||
.I nmatch
|
||||
structures of type
|
||||
.IR regmatch_t .
|
||||
Such a structure has at least the members
|
||||
.I rm_so
|
||||
and
|
||||
.IR rm_eo ,
|
||||
both of type
|
||||
.I regoff_t
|
||||
(a signed arithmetic type at least as large as an
|
||||
.I off_t
|
||||
and a
|
||||
.IR ssize_t ),
|
||||
containing respectively the offset of the first character of a substring
|
||||
and the offset of the first character after the end of the substring.
|
||||
Offsets are measured from the beginning of the
|
||||
.I string
|
||||
argument given to
|
||||
.IR regexec .
|
||||
An empty substring is denoted by equal offsets,
|
||||
both indicating the character following the empty substring.
|
||||
.PP
|
||||
The 0th member of the
|
||||
.I pmatch
|
||||
array is filled in to indicate what substring of
|
||||
.I string
|
||||
was matched by the entire RE.
|
||||
Remaining members report what substring was matched by parenthesized
|
||||
subexpressions within the RE;
|
||||
member
|
||||
.I i
|
||||
reports subexpression
|
||||
.IR i ,
|
||||
with subexpressions counted (starting at 1) by the order of their opening
|
||||
parentheses in the RE, left to right.
|
||||
Unused entries in the array\(emcorresponding either to subexpressions that
|
||||
did not participate in the match at all, or to subexpressions that do not
|
||||
exist in the RE (that is, \fIi\fR\ > \fIpreg\fR\->\fIre_nsub\fR)\(emhave both
|
||||
.I rm_so
|
||||
and
|
||||
.I rm_eo
|
||||
set to \-1.
|
||||
If a subexpression participated in the match several times,
|
||||
the reported substring is the last one it matched.
|
||||
(Note, as an example in particular, that when the RE `(b*)+' matches `bbb',
|
||||
the parenthesized subexpression matches the three `b's and then
|
||||
an infinite number of empty strings following the last `b',
|
||||
so the reported substring is one of the empties.)
|
||||
.PP
|
||||
If REG_STARTEND is specified,
|
||||
.I pmatch
|
||||
must point to at least one
|
||||
.I regmatch_t
|
||||
(even if
|
||||
.I nmatch
|
||||
is 0 or REG_NOSUB was specified),
|
||||
to hold the input offsets for REG_STARTEND.
|
||||
Use for output is still entirely controlled by
|
||||
.IR nmatch ;
|
||||
if
|
||||
.I nmatch
|
||||
is 0 or REG_NOSUB was specified,
|
||||
the value of
|
||||
.IR pmatch [0]
|
||||
will not be changed by a successful
|
||||
.IR regexec .
|
||||
.PP
|
||||
.I Regerror
|
||||
maps a non-zero
|
||||
.I errcode
|
||||
from either
|
||||
.I regcomp
|
||||
or
|
||||
.I regexec
|
||||
to a human-readable, printable message.
|
||||
If
|
||||
.I preg
|
||||
is non-NULL,
|
||||
the error code should have arisen from use of
|
||||
the
|
||||
.I regex_t
|
||||
pointed to by
|
||||
.IR preg ,
|
||||
and if the error code came from
|
||||
.IR regcomp ,
|
||||
it should have been the result from the most recent
|
||||
.I regcomp
|
||||
using that
|
||||
.IR regex_t .
|
||||
.RI ( Regerror
|
||||
may be able to supply a more detailed message using information
|
||||
from the
|
||||
.IR regex_t .)
|
||||
.I Regerror
|
||||
places the NUL-terminated message into the buffer pointed to by
|
||||
.IR errbuf ,
|
||||
limiting the length (including the NUL) to at most
|
||||
.I errbuf_size
|
||||
bytes.
|
||||
If the whole message won't fit,
|
||||
as much of it as will fit before the terminating NUL is supplied.
|
||||
In any case,
|
||||
the returned value is the size of buffer needed to hold the whole
|
||||
message (including terminating NUL).
|
||||
If
|
||||
.I errbuf_size
|
||||
is 0,
|
||||
.I errbuf
|
||||
is ignored but the return value is still correct.
|
||||
.PP
|
||||
If the
|
||||
.I errcode
|
||||
given to
|
||||
.I regerror
|
||||
is first ORed with REG_ITOA,
|
||||
the ``message'' that results is the printable name of the error code,
|
||||
e.g. ``REG_NOMATCH'',
|
||||
rather than an explanation thereof.
|
||||
If
|
||||
.I errcode
|
||||
is REG_ATOI,
|
||||
then
|
||||
.I preg
|
||||
shall be non-NULL and the
|
||||
.I re_endp
|
||||
member of the structure it points to
|
||||
must point to the printable name of an error code;
|
||||
in this case, the result in
|
||||
.I errbuf
|
||||
is the decimal digits of
|
||||
the numeric value of the error code
|
||||
(0 if the name is not recognized).
|
||||
REG_ITOA and REG_ATOI are intended primarily as debugging facilities;
|
||||
they are extensions,
|
||||
compatible with but not specified by POSIX 1003.2,
|
||||
and should be used with
|
||||
caution in software intended to be portable to other systems.
|
||||
Be warned also that they are considered experimental and changes are possible.
|
||||
.PP
|
||||
.I Regfree
|
||||
frees any dynamically-allocated storage associated with the compiled RE
|
||||
pointed to by
|
||||
.IR preg .
|
||||
The remaining
|
||||
.I regex_t
|
||||
is no longer a valid compiled RE
|
||||
and the effect of supplying it to
|
||||
.I regexec
|
||||
or
|
||||
.I regerror
|
||||
is undefined.
|
||||
.PP
|
||||
None of these functions references global variables except for tables
|
||||
of constants;
|
||||
all are safe for use from multiple threads if the arguments are safe.
|
||||
.SH IMPLEMENTATION CHOICES
|
||||
There are a number of decisions that 1003.2 leaves up to the implementor,
|
||||
either by explicitly saying ``undefined'' or by virtue of them being
|
||||
forbidden by the RE grammar.
|
||||
This implementation treats them as follows.
|
||||
.PP
|
||||
See
|
||||
.ZR
|
||||
for a discussion of the definition of case-independent matching.
|
||||
.PP
|
||||
There is no particular limit on the length of REs,
|
||||
except insofar as memory is limited.
|
||||
Memory usage is approximately linear in RE size, and largely insensitive
|
||||
to RE complexity, except for bounded repetitions.
|
||||
See BUGS for one short RE using them
|
||||
that will run almost any system out of memory.
|
||||
.PP
|
||||
A backslashed character other than one specifically given a magic meaning
|
||||
by 1003.2 (such magic meanings occur only in obsolete [``basic''] REs)
|
||||
is taken as an ordinary character.
|
||||
.PP
|
||||
Any unmatched [ is a REG_EBRACK error.
|
||||
.PP
|
||||
Equivalence classes cannot begin or end bracket-expression ranges.
|
||||
The endpoint of one range cannot begin another.
|
||||
.PP
|
||||
RE_DUP_MAX, the limit on repetition counts in bounded repetitions, is 255.
|
||||
.PP
|
||||
A repetition operator (?, *, +, or bounds) cannot follow another
|
||||
repetition operator.
|
||||
A repetition operator cannot begin an expression or subexpression
|
||||
or follow `^' or `|'.
|
||||
.PP
|
||||
`|' cannot appear first or last in a (sub)expression or after another `|',
|
||||
i.e. an operand of `|' cannot be an empty subexpression.
|
||||
An empty parenthesized subexpression, `()', is legal and matches an
|
||||
empty (sub)string.
|
||||
An empty string is not a legal RE.
|
||||
.PP
|
||||
A `{' followed by a digit is considered the beginning of bounds for a
|
||||
bounded repetition, which must then follow the syntax for bounds.
|
||||
A `{' \fInot\fR followed by a digit is considered an ordinary character.
|
||||
.PP
|
||||
`^' and `$' beginning and ending subexpressions in obsolete (``basic'')
|
||||
REs are anchors, not ordinary characters.
|
||||
.SH SEE ALSO
|
||||
grep(1), regex(7)
|
||||
.PP
|
||||
POSIX 1003.2, sections 2.8 (Regular Expression Notation)
|
||||
and
|
||||
B.5 (C Binding for Regular Expression Matching).
|
||||
.SH DIAGNOSTICS
|
||||
Non-zero error codes from
|
||||
.I regcomp
|
||||
and
|
||||
.I regexec
|
||||
include the following:
|
||||
.PP
|
||||
.nf
|
||||
.ta \w'REG_ECOLLATE'u+3n
|
||||
REG_NOMATCH regexec() failed to match
|
||||
REG_BADPAT invalid regular expression
|
||||
REG_ECOLLATE invalid collating element
|
||||
REG_ECTYPE invalid character class
|
||||
REG_EESCAPE \e applied to unescapable character
|
||||
REG_ESUBREG invalid backreference number
|
||||
REG_EBRACK brackets [ ] not balanced
|
||||
REG_EPAREN parentheses ( ) not balanced
|
||||
REG_EBRACE braces { } not balanced
|
||||
REG_BADBR invalid repetition count(s) in { }
|
||||
REG_ERANGE invalid character range in [ ]
|
||||
REG_ESPACE ran out of memory
|
||||
REG_BADRPT ?, *, or + operand invalid
|
||||
REG_EMPTY empty (sub)expression
|
||||
REG_ASSERT ``can't happen''\(emyou found a bug
|
||||
REG_INVARG invalid argument, e.g. negative-length string
|
||||
.fi
|
||||
.SH HISTORY
|
||||
Written by Henry Spencer,
|
||||
henry@zoo.toronto.edu.
|
||||
.SH BUGS
|
||||
This is an alpha release with known defects.
|
||||
Please report problems.
|
||||
.PP
|
||||
There is one known functionality bug.
|
||||
The implementation of internationalization is incomplete:
|
||||
the locale is always assumed to be the default one of 1003.2,
|
||||
and only the collating elements etc. of that locale are available.
|
||||
.PP
|
||||
The back-reference code is subtle and doubts linger about its correctness
|
||||
in complex cases.
|
||||
.PP
|
||||
.I Regexec
|
||||
performance is poor.
|
||||
This will improve with later releases.
|
||||
.I Nmatch
|
||||
exceeding 0 is expensive;
|
||||
.I nmatch
|
||||
exceeding 1 is worse.
|
||||
.I Regexec
|
||||
is largely insensitive to RE complexity \fIexcept\fR that back
|
||||
references are massively expensive.
|
||||
RE length does matter; in particular, there is a strong speed bonus
|
||||
for keeping RE length under about 30 characters,
|
||||
with most special characters counting roughly double.
|
||||
.PP
|
||||
.I Regcomp
|
||||
implements bounded repetitions by macro expansion,
|
||||
which is costly in time and space if counts are large
|
||||
or bounded repetitions are nested.
|
||||
An RE like, say,
|
||||
`((((a{1,100}){1,100}){1,100}){1,100}){1,100}'
|
||||
will (eventually) run almost any existing machine out of swap space.
|
||||
.PP
|
||||
There are suspected problems with response to obscure error conditions.
|
||||
Notably,
|
||||
certain kinds of internal overflow,
|
||||
produced only by truly enormous REs or by multiply nested bounded repetitions,
|
||||
are probably not handled well.
|
||||
.PP
|
||||
Due to a mistake in 1003.2, things like `a)b' are legal REs because `)' is
|
||||
a special character only in the presence of a previous unmatched `('.
|
||||
This can't be fixed until the spec is fixed.
|
||||
.PP
|
||||
The standard's definition of back references is vague.
|
||||
For example, does
|
||||
`a\e(\e(b\e)*\e2\e)*d' match `abbbd'?
|
||||
Until the standard is clarified,
|
||||
behavior in such cases should not be relied on.
|
||||
.PP
|
||||
The implementation of word-boundary matching is a bit of a kludge,
|
||||
and bugs may lurk in combinations of word-boundary matching and anchoring.
|
||||
@@ -1,235 +0,0 @@
|
||||
.TH REGEX 7 "25 Oct 1995"
|
||||
.BY "Henry Spencer"
|
||||
.SH NAME
|
||||
regex \- POSIX 1003.2 regular expressions
|
||||
.SH DESCRIPTION
|
||||
Regular expressions (``RE''s),
|
||||
as defined in POSIX 1003.2, come in two forms:
|
||||
modern REs (roughly those of
|
||||
.IR egrep ;
|
||||
1003.2 calls these ``extended'' REs)
|
||||
and obsolete REs (roughly those of
|
||||
.IR ed ;
|
||||
1003.2 ``basic'' REs).
|
||||
Obsolete REs mostly exist for backward compatibility in some old programs;
|
||||
they will be discussed at the end.
|
||||
1003.2 leaves some aspects of RE syntax and semantics open;
|
||||
`\(dg' marks decisions on these aspects that
|
||||
may not be fully portable to other 1003.2 implementations.
|
||||
.PP
|
||||
A (modern) RE is one\(dg or more non-empty\(dg \fIbranches\fR,
|
||||
separated by `|'.
|
||||
It matches anything that matches one of the branches.
|
||||
.PP
|
||||
A branch is one\(dg or more \fIpieces\fR, concatenated.
|
||||
It matches a match for the first, followed by a match for the second, etc.
|
||||
.PP
|
||||
A piece is an \fIatom\fR possibly followed
|
||||
by a single\(dg `*', `+', `?', or \fIbound\fR.
|
||||
An atom followed by `*' matches a sequence of 0 or more matches of the atom.
|
||||
An atom followed by `+' matches a sequence of 1 or more matches of the atom.
|
||||
An atom followed by `?' matches a sequence of 0 or 1 matches of the atom.
|
||||
.PP
|
||||
A \fIbound\fR is `{' followed by an unsigned decimal integer,
|
||||
possibly followed by `,'
|
||||
possibly followed by another unsigned decimal integer,
|
||||
always followed by `}'.
|
||||
The integers must lie between 0 and RE_DUP_MAX (255\(dg) inclusive,
|
||||
and if there are two of them, the first may not exceed the second.
|
||||
An atom followed by a bound containing one integer \fIi\fR
|
||||
and no comma matches
|
||||
a sequence of exactly \fIi\fR matches of the atom.
|
||||
An atom followed by a bound
|
||||
containing one integer \fIi\fR and a comma matches
|
||||
a sequence of \fIi\fR or more matches of the atom.
|
||||
An atom followed by a bound
|
||||
containing two integers \fIi\fR and \fIj\fR matches
|
||||
a sequence of \fIi\fR through \fIj\fR (inclusive) matches of the atom.
|
||||
.PP
|
||||
An atom is a regular expression enclosed in `()' (matching a match for the
|
||||
regular expression),
|
||||
an empty set of `()' (matching the null string)\(dg,
|
||||
a \fIbracket expression\fR (see below), `.'
|
||||
(matching any single character), `^' (matching the null string at the
|
||||
beginning of a line), `$' (matching the null string at the
|
||||
end of a line), a `\e' followed by one of the characters
|
||||
`^.[$()|*+?{\e'
|
||||
(matching that character taken as an ordinary character),
|
||||
a `\e' followed by any other character\(dg
|
||||
(matching that character taken as an ordinary character,
|
||||
as if the `\e' had not been present\(dg),
|
||||
or a single character with no other significance (matching that character).
|
||||
A `{' followed by a character other than a digit is an ordinary
|
||||
character, not the beginning of a bound\(dg.
|
||||
It is illegal to end an RE with `\e'.
|
||||
.PP
|
||||
A \fIbracket expression\fR is a list of characters enclosed in `[]'.
|
||||
It normally matches any single character from the list (but see below).
|
||||
If the list begins with `^',
|
||||
it matches any single character
|
||||
(but see below) \fInot\fR from the rest of the list.
|
||||
If two characters in the list are separated by `\-', this is shorthand
|
||||
for the full \fIrange\fR of characters between those two (inclusive) in the
|
||||
collating sequence,
|
||||
e.g. `[0\-9]' in ASCII matches any decimal digit.
|
||||
It is illegal\(dg for two ranges to share an
|
||||
endpoint, e.g. `a\-c\-e'.
|
||||
Ranges are very collating-sequence-dependent,
|
||||
and portable programs should avoid relying on them.
|
||||
.PP
|
||||
To include a literal `]' in the list, make it the first character
|
||||
(following a possible `^').
|
||||
To include a literal `\-', make it the first or last character,
|
||||
or the second endpoint of a range.
|
||||
To use a literal `\-' as the first endpoint of a range,
|
||||
enclose it in `[.' and `.]' to make it a collating element (see below).
|
||||
With the exception of these and some combinations using `[' (see next
|
||||
paragraphs), all other special characters, including `\e', lose their
|
||||
special significance within a bracket expression.
|
||||
.PP
|
||||
Within a bracket expression, a collating element (a character,
|
||||
a multi-character sequence that collates as if it were a single character,
|
||||
or a collating-sequence name for either)
|
||||
enclosed in `[.' and `.]' stands for the
|
||||
sequence of characters of that collating element.
|
||||
The sequence is a single element of the bracket expression's list.
|
||||
A bracket expression containing a multi-character collating element
|
||||
can thus match more than one character,
|
||||
e.g. if the collating sequence includes a `ch' collating element,
|
||||
then the RE `[[.ch.]]*c' matches the first five characters
|
||||
of `chchcc'.
|
||||
.PP
|
||||
Within a bracket expression, a collating element enclosed in `[=' and
|
||||
`=]' is an equivalence class, standing for the sequences of characters
|
||||
of all collating elements equivalent to that one, including itself.
|
||||
(If there are no other equivalent collating elements,
|
||||
the treatment is as if the enclosing delimiters were `[.' and `.]'.)
|
||||
For example, if o and \o'o^' are the members of an equivalence class,
|
||||
then `[[=o=]]', `[[=\o'o^'=]]', and `[o\o'o^']' are all synonymous.
|
||||
An equivalence class may not\(dg be an endpoint
|
||||
of a range.
|
||||
.PP
|
||||
Within a bracket expression, the name of a \fIcharacter class\fR enclosed
|
||||
in `[:' and `:]' stands for the list of all characters belonging to that
|
||||
class.
|
||||
Standard character class names are:
|
||||
.PP
|
||||
.RS
|
||||
.nf
|
||||
.ta 3c 6c 9c
|
||||
alnum digit punct
|
||||
alpha graph space
|
||||
blank lower upper
|
||||
cntrl print xdigit
|
||||
.fi
|
||||
.RE
|
||||
.PP
|
||||
These stand for the character classes defined in
|
||||
.IR ctype (3).
|
||||
A locale may provide others.
|
||||
A character class may not be used as an endpoint of a range.
|
||||
.PP
|
||||
There are two special cases\(dg of bracket expressions:
|
||||
the bracket expressions `[[:<:]]' and `[[:>:]]' match the null string at
|
||||
the beginning and end of a word respectively.
|
||||
A word is defined as a sequence of
|
||||
word characters
|
||||
which is neither preceded nor followed by
|
||||
word characters.
|
||||
A word character is an
|
||||
.I alnum
|
||||
character (as defined by
|
||||
.IR ctype (3))
|
||||
or an underscore.
|
||||
This is an extension,
|
||||
compatible with but not specified by POSIX 1003.2,
|
||||
and should be used with
|
||||
caution in software intended to be portable to other systems.
|
||||
.PP
|
||||
In the event that an RE could match more than one substring of a given
|
||||
string,
|
||||
the RE matches the one starting earliest in the string.
|
||||
If the RE could match more than one substring starting at that point,
|
||||
it matches the longest.
|
||||
Subexpressions also match the longest possible substrings, subject to
|
||||
the constraint that the whole match be as long as possible,
|
||||
with subexpressions starting earlier in the RE taking priority over
|
||||
ones starting later.
|
||||
Note that higher-level subexpressions thus take priority over
|
||||
their lower-level component subexpressions.
|
||||
.PP
|
||||
Match lengths are measured in characters, not collating elements.
|
||||
A null string is considered longer than no match at all.
|
||||
For example,
|
||||
`bb*' matches the three middle characters of `abbbc',
|
||||
`(wee|week)(knights|nights)' matches all ten characters of `weeknights',
|
||||
when `(.*).*' is matched against `abc' the parenthesized subexpression
|
||||
matches all three characters, and
|
||||
when `(a*)*' is matched against `bc' both the whole RE and the parenthesized
|
||||
subexpression match the null string.
|
||||
.PP
|
||||
If case-independent matching is specified,
|
||||
the effect is much as if all case distinctions had vanished from the
|
||||
alphabet.
|
||||
When an alphabetic that exists in multiple cases appears as an
|
||||
ordinary character outside a bracket expression, it is effectively
|
||||
transformed into a bracket expression containing both cases,
|
||||
e.g. `x' becomes `[xX]'.
|
||||
When it appears inside a bracket expression, all case counterparts
|
||||
of it are added to the bracket expression, so that (e.g.) `[x]'
|
||||
becomes `[xX]' and `[^x]' becomes `[^xX]'.
|
||||
.PP
|
||||
No particular limit is imposed on the length of REs\(dg.
|
||||
Programs intended to be portable should not employ REs longer
|
||||
than 256 bytes,
|
||||
as an implementation can refuse to accept such REs and remain
|
||||
POSIX-compliant.
|
||||
.PP
|
||||
Obsolete (``basic'') regular expressions differ in several respects.
|
||||
`|', `+', and `?' are ordinary characters and there is no equivalent
|
||||
for their functionality.
|
||||
The delimiters for bounds are `\e{' and `\e}',
|
||||
with `{' and `}' by themselves ordinary characters.
|
||||
The parentheses for nested subexpressions are `\e(' and `\e)',
|
||||
with `(' and `)' by themselves ordinary characters.
|
||||
`^' is an ordinary character except at the beginning of the
|
||||
RE or\(dg the beginning of a parenthesized subexpression,
|
||||
`$' is an ordinary character except at the end of the
|
||||
RE or\(dg the end of a parenthesized subexpression,
|
||||
and `*' is an ordinary character if it appears at the beginning of the
|
||||
RE or the beginning of a parenthesized subexpression
|
||||
(after a possible leading `^').
|
||||
Finally, there is one new type of atom, a \fIback reference\fR:
|
||||
`\e' followed by a non-zero decimal digit \fId\fR
|
||||
matches the same sequence of characters
|
||||
matched by the \fId\fRth parenthesized subexpression
|
||||
(numbering subexpressions by the positions of their opening parentheses,
|
||||
left to right),
|
||||
so that (e.g.) `\e([bc]\e)\e1' matches `bb' or `cc' but not `bc'.
|
||||
.SH SEE ALSO
|
||||
regex(3)
|
||||
.PP
|
||||
POSIX 1003.2, section 2.8 (Regular Expression Notation).
|
||||
.SH HISTORY
|
||||
Written by Henry Spencer, based on the 1003.2 spec.
|
||||
.SH BUGS
|
||||
Having two kinds of REs is a botch.
|
||||
.PP
|
||||
The current 1003.2 spec says that `)' is an ordinary character in
|
||||
the absence of an unmatched `(';
|
||||
this was an unintentional result of a wording error,
|
||||
and change is likely.
|
||||
Avoid relying on it.
|
||||
.PP
|
||||
Back references are a dreadful botch,
|
||||
posing major problems for efficient implementations.
|
||||
They are also somewhat vaguely defined
|
||||
(does
|
||||
`a\e(\e(b\e)*\e2\e)*d' match `abbbd'?).
|
||||
Avoid using them.
|
||||
.PP
|
||||
1003.2's specification of case-independent matching is vague.
|
||||
The ``one case implies all cases'' definition given above
|
||||
is current consensus among implementors as to the right interpretation.
|
||||
.PP
|
||||
The syntax for word boundaries is incredibly ugly.
|
||||
@@ -1,202 +0,0 @@
|
||||
#ifndef _REGEX_H_
|
||||
#define _REGEX_H_ /* never again */
|
||||
/*
|
||||
* regular expressions
|
||||
*
|
||||
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
|
||||
*
|
||||
* Development of this software was funded, in part, by Cray Research Inc.,
|
||||
* UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
|
||||
* Corporation, none of whom are responsible for the results. The author
|
||||
* thanks all of them.
|
||||
*
|
||||
* Redistribution and use in source and binary forms -- with or without
|
||||
* modification -- are permitted for any purpose, provided that
|
||||
* redistributions in source form retain this entire copyright notice and
|
||||
* indicate the origin and nature of any modifications.
|
||||
*
|
||||
* I'd appreciate being given credit for this package in the documentation
|
||||
* of software which uses it, but that is not a requirement.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED ``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
|
||||
* HENRY SPENCER 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.
|
||||
*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
/*
|
||||
* Add your own defines, if needed, here.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifndef wxCHECK_GCC_VERSION
|
||||
#define wxCHECK_GCC_VERSION( major, minor ) \
|
||||
( defined(__GNUC__) && defined(__GNUC_MINOR__) \
|
||||
&& ( ( __GNUC__ > (major) ) \
|
||||
|| ( __GNUC__ == (major) && __GNUC_MINOR__ >= (minor) ) ) )
|
||||
#endif
|
||||
|
||||
#if !wxUSE_UNICODE
|
||||
# define wx_wchar char
|
||||
#else // Unicode
|
||||
#if (defined(__GNUC__) && !wxCHECK_GCC_VERSION(2, 96))
|
||||
# define wx_wchar __WCHAR_TYPE__
|
||||
#else // __WCHAR_TYPE__ and gcc < 2.96
|
||||
// standard case
|
||||
# define wx_wchar wchar_t
|
||||
#endif // __WCHAR_TYPE__
|
||||
#endif // ASCII/Unicode
|
||||
|
||||
/*
|
||||
* interface types etc.
|
||||
*/
|
||||
|
||||
/*
|
||||
* regoff_t has to be large enough to hold either off_t or ssize_t,
|
||||
* and must be signed; it's only a guess that long is suitable.
|
||||
*/
|
||||
typedef long regoff_t;
|
||||
|
||||
/*
|
||||
* other interface types
|
||||
*/
|
||||
|
||||
/* the biggie, a compiled RE (or rather, a front end to same) */
|
||||
typedef struct
|
||||
{
|
||||
int re_magic; /* magic number */
|
||||
size_t re_nsub; /* number of subexpressions */
|
||||
long re_info; /* information about RE */
|
||||
#define REG_UBACKREF 000001
|
||||
#define REG_ULOOKAHEAD 000002
|
||||
#define REG_UBOUNDS 000004
|
||||
#define REG_UBRACES 000010
|
||||
#define REG_UBSALNUM 000020
|
||||
#define REG_UPBOTCH 000040
|
||||
#define REG_UBBS 000100
|
||||
#define REG_UNONPOSIX 000200
|
||||
#define REG_UUNSPEC 000400
|
||||
#define REG_UUNPORT 001000
|
||||
#define REG_ULOCALE 002000
|
||||
#define REG_UEMPTYMATCH 004000
|
||||
#define REG_UIMPOSSIBLE 010000
|
||||
#define REG_USHORTEST 020000
|
||||
int re_csize; /* sizeof(character) */
|
||||
char *re_endp; /* backward compatibility kludge */
|
||||
/* the rest is opaque pointers to hidden innards */
|
||||
char *re_guts; /* `char *' is more portable than `void *' */
|
||||
char *re_fns;
|
||||
} regex_t;
|
||||
|
||||
/* result reporting (may acquire more fields later) */
|
||||
typedef struct
|
||||
{
|
||||
regoff_t rm_so; /* start of substring */
|
||||
regoff_t rm_eo; /* end of substring */
|
||||
} regmatch_t;
|
||||
|
||||
/* supplementary control and reporting */
|
||||
typedef struct
|
||||
{
|
||||
regmatch_t rm_extend; /* see REG_EXPECT */
|
||||
} rm_detail_t;
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* regex compilation flags
|
||||
*/
|
||||
#define REG_BASIC 000000 /* BREs (convenience) */
|
||||
#define REG_EXTENDED 000001 /* EREs */
|
||||
#define REG_ADVF 000002 /* advanced features in EREs */
|
||||
#define REG_ADVANCED 000003 /* AREs (which are also EREs) */
|
||||
#define REG_QUOTE 000004 /* no special characters, none */
|
||||
#define REG_NOSPEC REG_QUOTE /* historical synonym */
|
||||
#define REG_ICASE 000010 /* ignore case */
|
||||
#define REG_NOSUB 000020 /* don't care about subexpressions */
|
||||
#define REG_EXPANDED 000040 /* expanded format, white space & comments */
|
||||
#define REG_NLSTOP 000100 /* \n doesn't match . or [^ ] */
|
||||
#define REG_NLANCH 000200 /* ^ matches after \n, $ before */
|
||||
#define REG_NEWLINE 000300 /* newlines are line terminators */
|
||||
#define REG_PEND 000400 /* ugh -- backward-compatibility hack */
|
||||
#define REG_EXPECT 001000 /* report details on partial/limited
|
||||
* matches */
|
||||
#define REG_BOSONLY 002000 /* temporary kludge for BOS-only matches */
|
||||
#define REG_DUMP 004000 /* none of your business :-) */
|
||||
#define REG_FAKE 010000 /* none of your business :-) */
|
||||
#define REG_PROGRESS 020000 /* none of your business :-) */
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* regex execution flags
|
||||
*/
|
||||
#define REG_NOTBOL 0001 /* BOS is not BOL */
|
||||
#define REG_NOTEOL 0002 /* EOS is not EOL */
|
||||
#define REG_STARTEND 0004 /* backward compatibility kludge */
|
||||
#define REG_FTRACE 0010 /* none of your business */
|
||||
#define REG_MTRACE 0020 /* none of your business */
|
||||
#define REG_SMALL 0040 /* none of your business */
|
||||
|
||||
|
||||
/*
|
||||
* error reporting
|
||||
* Be careful if modifying the list of error codes -- the table used by
|
||||
* regerror() is generated automatically from this file!
|
||||
*/
|
||||
#define REG_OKAY 0 /* no errors detected */
|
||||
#define REG_NOMATCH 1 /* failed to match */
|
||||
#define REG_BADPAT 2 /* invalid regexp */
|
||||
#define REG_ECOLLATE 3 /* invalid collating element */
|
||||
#define REG_ECTYPE 4 /* invalid character class */
|
||||
#define REG_EESCAPE 5 /* invalid escape \ sequence */
|
||||
#define REG_ESUBREG 6 /* invalid backreference number */
|
||||
#define REG_EBRACK 7 /* brackets [] not balanced */
|
||||
#define REG_EPAREN 8 /* parentheses () not balanced */
|
||||
#define REG_EBRACE 9 /* braces {} not balanced */
|
||||
#define REG_BADBR 10 /* invalid repetition count(s) */
|
||||
#define REG_ERANGE 11 /* invalid character range */
|
||||
#define REG_ESPACE 12 /* out of memory */
|
||||
#define REG_BADRPT 13 /* quantifier operand invalid */
|
||||
#define REG_ASSERT 15 /* "can't happen" -- you found a bug */
|
||||
#define REG_INVARG 16 /* invalid argument to regex function */
|
||||
#define REG_MIXED 17 /* character widths of regex and string
|
||||
* differ */
|
||||
#define REG_BADOPT 18 /* invalid embedded option */
|
||||
/* two specials for debugging and testing */
|
||||
#define REG_ATOI 101 /* convert error-code name to number */
|
||||
#define REG_ITOA 102 /* convert error-code number to name */
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* the prototypes for exported functions
|
||||
*/
|
||||
extern int wx_regcomp(regex_t *, const wx_wchar *, size_t, int);
|
||||
extern int regcomp(regex_t *, const wx_wchar *, int);
|
||||
extern int wx_regexec(regex_t *, const wx_wchar *, size_t, rm_detail_t *, size_t, regmatch_t[], int);
|
||||
extern int regexec(regex_t *, const wx_wchar *, size_t, regmatch_t[], int);
|
||||
extern void regfree(regex_t *);
|
||||
extern size_t regerror(int, const regex_t *, char *, size_t);
|
||||
extern void wx_regfree(regex_t *);
|
||||
extern size_t wx_regerror(int, const regex_t *, char *, size_t);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _REGEX_H_ */
|
||||
1038
src/regex/regexec.c
1038
src/regex/regexec.c
File diff suppressed because it is too large
Load Diff
@@ -1,53 +0,0 @@
|
||||
/*
|
||||
* regfree - free an RE
|
||||
*
|
||||
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
|
||||
*
|
||||
* Development of this software was funded, in part, by Cray Research Inc.,
|
||||
* UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
|
||||
* Corporation, none of whom are responsible for the results. The author
|
||||
* thanks all of them.
|
||||
*
|
||||
* Redistribution and use in source and binary forms -- with or without
|
||||
* modification -- are permitted for any purpose, provided that
|
||||
* redistributions in source form retain this entire copyright notice and
|
||||
* indicate the origin and nature of any modifications.
|
||||
*
|
||||
* I'd appreciate being given credit for this package in the documentation
|
||||
* of software which uses it, but that is not a requirement.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED ``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
|
||||
* HENRY SPENCER 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.
|
||||
*
|
||||
*
|
||||
*
|
||||
* You might think that this could be incorporated into regcomp.c, and
|
||||
* that would be a reasonable idea... except that this is a generic
|
||||
* function (with a generic name), applicable to all compiled REs
|
||||
* regardless of the size of their characters, whereas the stuff in
|
||||
* regcomp.c gets compiled once per character size.
|
||||
*/
|
||||
|
||||
#include "regguts.h"
|
||||
|
||||
/*
|
||||
- regfree - free an RE (generic function, punts to RE-specific function)
|
||||
*
|
||||
* Ignoring invocation with NULL is a convenience.
|
||||
*/
|
||||
VOID
|
||||
regfree(re)
|
||||
regex_t *re;
|
||||
{
|
||||
if (re == NULL)
|
||||
return;
|
||||
(*((struct fns *)re->re_fns)->free)(re);
|
||||
}
|
||||
@@ -1,83 +0,0 @@
|
||||
/*
|
||||
* regcomp and regexec - front ends to re_ routines
|
||||
*
|
||||
* Mostly for implementation of backward-compatibility kludges. Note
|
||||
* that these routines exist ONLY in char versions.
|
||||
*
|
||||
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
|
||||
*
|
||||
* Development of this software was funded, in part, by Cray Research Inc.,
|
||||
* UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
|
||||
* Corporation, none of whom are responsible for the results. The author
|
||||
* thanks all of them.
|
||||
*
|
||||
* Redistribution and use in source and binary forms -- with or without
|
||||
* modification -- are permitted for any purpose, provided that
|
||||
* redistributions in source form retain this entire copyright notice and
|
||||
* indicate the origin and nature of any modifications.
|
||||
*
|
||||
* I'd appreciate being given credit for this package in the documentation
|
||||
* of software which uses it, but that is not a requirement.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED ``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
|
||||
* HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
||||
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "regguts.h"
|
||||
|
||||
/*
|
||||
- regcomp - compile regular expression
|
||||
*/
|
||||
int
|
||||
regcomp(re, str, flags)
|
||||
regex_t *re;
|
||||
CONST char *str;
|
||||
int flags;
|
||||
{
|
||||
size_t len;
|
||||
int f = flags;
|
||||
|
||||
if (f®_PEND) {
|
||||
len = re->re_endp - str;
|
||||
f &= ~REG_PEND;
|
||||
} else
|
||||
len = strlen(str);
|
||||
|
||||
return re_comp(re, str, len, f);
|
||||
}
|
||||
|
||||
/*
|
||||
- regexec - execute regular expression
|
||||
*/
|
||||
int
|
||||
regexec(re, str, nmatch, pmatch, flags)
|
||||
regex_t *re;
|
||||
CONST char *str;
|
||||
size_t nmatch;
|
||||
regmatch_t pmatch[];
|
||||
int flags;
|
||||
{
|
||||
CONST char *start;
|
||||
size_t len;
|
||||
int f = flags;
|
||||
|
||||
if (f®_STARTEND) {
|
||||
start = str + pmatch[0].rm_so;
|
||||
len = pmatch[0].rm_eo - pmatch[0].rm_so;
|
||||
f &= ~REG_STARTEND;
|
||||
} else {
|
||||
start = str;
|
||||
len = strlen(str);
|
||||
}
|
||||
|
||||
return re_exec(re, start, len, nmatch, pmatch, f);
|
||||
}
|
||||
@@ -1,417 +0,0 @@
|
||||
/*
|
||||
* Internal interface definitions, etc., for the reg package
|
||||
*
|
||||
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
|
||||
*
|
||||
* Development of this software was funded, in part, by Cray Research Inc.,
|
||||
* UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
|
||||
* Corporation, none of whom are responsible for the results. The author
|
||||
* thanks all of them.
|
||||
*
|
||||
* Redistribution and use in source and binary forms -- with or without
|
||||
* modification -- are permitted for any purpose, provided that
|
||||
* redistributions in source form retain this entire copyright notice and
|
||||
* indicate the origin and nature of any modifications.
|
||||
*
|
||||
* I'd appreciate being given credit for this package in the documentation
|
||||
* of software which uses it, but that is not a requirement.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED ``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
|
||||
* HENRY SPENCER 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.
|
||||
*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Environmental customization. It should not (I hope) be necessary to
|
||||
* alter the file you are now reading -- regcustom.h should handle it all,
|
||||
* given care here and elsewhere.
|
||||
*/
|
||||
#include "regcustom.h"
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Things that regcustom.h might override.
|
||||
*/
|
||||
|
||||
/* assertions */
|
||||
#ifndef assert
|
||||
#ifndef REG_DEBUG
|
||||
# ifndef NDEBUG
|
||||
# define NDEBUG /* no assertions */
|
||||
# endif
|
||||
#endif
|
||||
#include <assert.h>
|
||||
#endif
|
||||
|
||||
/* voids */
|
||||
#ifndef DISCARD
|
||||
#define DISCARD void /* for throwing values away */
|
||||
#endif
|
||||
#ifndef VS
|
||||
#define VS(x) ((void *)(x)) /* cast something to generic ptr */
|
||||
#endif
|
||||
|
||||
/* function-pointer declarator */
|
||||
#ifndef FUNCPTR
|
||||
#define FUNCPTR(name, args) (*name) args
|
||||
#endif
|
||||
|
||||
/* memory allocation */
|
||||
#ifndef MALLOC
|
||||
#define MALLOC(n) malloc(n)
|
||||
#endif
|
||||
#ifndef REALLOC
|
||||
#define REALLOC(p, n) realloc(VS(p), n)
|
||||
#endif
|
||||
#ifndef FREE
|
||||
#define FREE(p) free(VS(p))
|
||||
#endif
|
||||
|
||||
/* want size of a char in bits, and max value in bounded quantifiers */
|
||||
#ifndef CHAR_BIT
|
||||
#include <limits.h>
|
||||
#endif
|
||||
#ifndef _POSIX2_RE_DUP_MAX
|
||||
#define _POSIX2_RE_DUP_MAX 255 /* normally from <limits.h> */
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* misc
|
||||
*/
|
||||
|
||||
#define NOTREACHED 0
|
||||
#define xxx 1
|
||||
|
||||
#define DUPMAX _POSIX2_RE_DUP_MAX
|
||||
#define INFINITY (DUPMAX+1)
|
||||
|
||||
#define REMAGIC 0xfed7 /* magic number for main struct */
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* debugging facilities
|
||||
*/
|
||||
#ifdef REG_DEBUG
|
||||
/* FDEBUG does finite-state tracing */
|
||||
#define FDEBUG(arglist) { if (v->eflags®_FTRACE) printf arglist; }
|
||||
/* MDEBUG does higher-level tracing */
|
||||
#define MDEBUG(arglist) { if (v->eflags®_MTRACE) printf arglist; }
|
||||
#else
|
||||
#define FDEBUG(arglist) {}
|
||||
#define MDEBUG(arglist) {}
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* bitmap manipulation
|
||||
*/
|
||||
#define UBITS (CHAR_BIT * sizeof(unsigned))
|
||||
#define BSET(uv, sn) ((uv)[(sn)/UBITS] |= (unsigned)1 << ((sn)%UBITS))
|
||||
#define ISBSET(uv, sn) ((uv)[(sn)/UBITS] & ((unsigned)1 << ((sn)%UBITS)))
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* We dissect a chr into byts for colormap table indexing. Here we define
|
||||
* a byt, which will be the same as a byte on most machines... The exact
|
||||
* size of a byt is not critical, but about 8 bits is good, and extraction
|
||||
* of 8-bit chunks is sometimes especially fast.
|
||||
*/
|
||||
#ifndef BYTBITS
|
||||
#define BYTBITS 8 /* bits in a byt */
|
||||
#endif
|
||||
#define BYTTAB (1<<BYTBITS) /* size of table with one entry per byt
|
||||
* value */
|
||||
#define BYTMASK (BYTTAB-1) /* bit mask for byt */
|
||||
#define NBYTS ((CHRBITS+BYTBITS-1)/BYTBITS)
|
||||
/* the definition of GETCOLOR(), below, assumes NBYTS <= 4 */
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* As soon as possible, we map chrs into equivalence classes -- "colors" --
|
||||
* which are of much more manageable number.
|
||||
*/
|
||||
typedef short color; /* colors of characters */
|
||||
typedef int pcolor; /* what color promotes to */
|
||||
|
||||
#define COLORLESS (-1) /* impossible color */
|
||||
#define WHITE 0 /* default color, parent of all others */
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* A colormap is a tree -- more precisely, a DAG -- indexed at each level
|
||||
* by a byt of the chr, to map the chr to a color efficiently. Because
|
||||
* lower sections of the tree can be shared, it can exploit the usual
|
||||
* sparseness of such a mapping table. The tree is always NBYTS levels
|
||||
* deep (in the past it was shallower during construction but was "filled"
|
||||
* to full depth at the end of that); areas that are unaltered as yet point
|
||||
* to "fill blocks" which are entirely WHITE in color.
|
||||
*/
|
||||
|
||||
/* the tree itself */
|
||||
struct colors
|
||||
{
|
||||
color ccolor[BYTTAB];
|
||||
};
|
||||
struct ptrs
|
||||
{
|
||||
union tree *pptr[BYTTAB];
|
||||
};
|
||||
union tree
|
||||
{
|
||||
struct colors colors;
|
||||
struct ptrs ptrs;
|
||||
};
|
||||
|
||||
#define tcolor colors.ccolor
|
||||
#define tptr ptrs.pptr
|
||||
|
||||
/* internal per-color structure for the color machinery */
|
||||
struct colordesc
|
||||
{
|
||||
uchr nchrs; /* number of chars of this color */
|
||||
color sub; /* open subcolor (if any); free chain ptr */
|
||||
#define NOSUB COLORLESS
|
||||
struct arc *arcs; /* color chain */
|
||||
int flags;
|
||||
#define FREECOL 01 /* currently free */
|
||||
#define PSEUDO 02 /* pseudocolor, no real chars */
|
||||
#define UNUSEDCOLOR(cd) ((cd)->flags&FREECOL)
|
||||
union tree *block; /* block of solid color, if any */
|
||||
};
|
||||
|
||||
/* the color map itself */
|
||||
struct colormap
|
||||
{
|
||||
int magic;
|
||||
#define CMMAGIC 0x876
|
||||
struct vars *v; /* for compile error reporting */
|
||||
size_t ncds; /* number of colordescs */
|
||||
size_t max; /* highest in use */
|
||||
color free; /* beginning of free chain (if non-0) */
|
||||
struct colordesc *cd;
|
||||
#define CDEND(cm) (&(cm)->cd[(cm)->max + 1])
|
||||
#define NINLINECDS ((size_t)10)
|
||||
struct colordesc cdspace[NINLINECDS];
|
||||
union tree tree[NBYTS]; /* tree top, plus fill blocks */
|
||||
};
|
||||
|
||||
/* optimization magic to do fast chr->color mapping */
|
||||
#define B0(c) ((c) & BYTMASK)
|
||||
#define B1(c) (((c)>>BYTBITS) & BYTMASK)
|
||||
#define B2(c) (((c)>>(2*BYTBITS)) & BYTMASK)
|
||||
#define B3(c) (((c)>>(3*BYTBITS)) & BYTMASK)
|
||||
#if NBYTS == 1
|
||||
#define GETCOLOR(cm, c) ((cm)->tree->tcolor[B0(c)])
|
||||
#endif
|
||||
/* beware, for NBYTS>1, GETCOLOR() is unsafe -- 2nd arg used repeatedly */
|
||||
#if NBYTS == 2
|
||||
#define GETCOLOR(cm, c) ((cm)->tree->tptr[B1(c)]->tcolor[B0(c)])
|
||||
#endif
|
||||
#if NBYTS == 4
|
||||
#define GETCOLOR(cm, c) ((cm)->tree->tptr[B3(c)]->tptr[B2(c)]->tptr[B1(c)]->tcolor[B0(c)])
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Interface definitions for locale-interface functions in locale.c.
|
||||
* Multi-character collating elements (MCCEs) cause most of the trouble.
|
||||
*/
|
||||
struct cvec
|
||||
{
|
||||
int nchrs; /* number of chrs */
|
||||
int chrspace; /* number of chrs possible */
|
||||
chr *chrs; /* pointer to vector of chrs */
|
||||
int nranges; /* number of ranges (chr pairs) */
|
||||
int rangespace; /* number of chrs possible */
|
||||
chr *ranges; /* pointer to vector of chr pairs */
|
||||
int nmcces; /* number of MCCEs */
|
||||
int mccespace; /* number of MCCEs possible */
|
||||
int nmccechrs; /* number of chrs used for MCCEs */
|
||||
chr *mcces[1]; /* pointers to 0-terminated MCCEs */
|
||||
/* and both batches of chrs are on the end */
|
||||
};
|
||||
|
||||
/* caution: this value cannot be changed easily */
|
||||
#define MAXMCCE 2 /* length of longest MCCE */
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* definitions for NFA internal representation
|
||||
*
|
||||
* Having a "from" pointer within each arc may seem redundant, but it
|
||||
* saves a lot of hassle.
|
||||
*/
|
||||
struct state;
|
||||
|
||||
struct arc
|
||||
{
|
||||
int type;
|
||||
#define ARCFREE '\0'
|
||||
color co;
|
||||
struct state *from; /* where it's from (and contained within) */
|
||||
struct state *to; /* where it's to */
|
||||
struct arc *outchain; /* *from's outs chain or free chain */
|
||||
#define freechain outchain
|
||||
struct arc *inchain; /* *to's ins chain */
|
||||
struct arc *colorchain; /* color's arc chain */
|
||||
};
|
||||
|
||||
struct arcbatch
|
||||
{ /* for bulk allocation of arcs */
|
||||
struct arcbatch *next;
|
||||
#define ABSIZE 10
|
||||
struct arc a[ABSIZE];
|
||||
};
|
||||
|
||||
struct state
|
||||
{
|
||||
int no;
|
||||
#define FREESTATE (-1)
|
||||
char flag; /* marks special states */
|
||||
int nins; /* number of inarcs */
|
||||
struct arc *ins; /* chain of inarcs */
|
||||
int nouts; /* number of outarcs */
|
||||
struct arc *outs; /* chain of outarcs */
|
||||
struct arc *free; /* chain of free arcs */
|
||||
struct state *tmp; /* temporary for traversal algorithms */
|
||||
struct state *next; /* chain for traversing all */
|
||||
struct state *prev; /* back chain */
|
||||
struct arcbatch oas; /* first arcbatch, avoid malloc in easy
|
||||
* case */
|
||||
int noas; /* number of arcs used in first arcbatch */
|
||||
};
|
||||
|
||||
struct nfa
|
||||
{
|
||||
struct state *pre; /* pre-initial state */
|
||||
struct state *init; /* initial state */
|
||||
struct state *final; /* final state */
|
||||
struct state *post; /* post-final state */
|
||||
int nstates; /* for numbering states */
|
||||
struct state *states; /* state-chain header */
|
||||
struct state *slast; /* tail of the chain */
|
||||
struct state *free; /* free list */
|
||||
struct colormap *cm; /* the color map */
|
||||
color bos[2]; /* colors, if any, assigned to BOS and BOL */
|
||||
color eos[2]; /* colors, if any, assigned to EOS and EOL */
|
||||
struct vars *v; /* simplifies compile error reporting */
|
||||
struct nfa *parent; /* parent NFA, if any */
|
||||
};
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* definitions for compacted NFA
|
||||
*/
|
||||
struct carc
|
||||
{
|
||||
color co; /* COLORLESS is list terminator */
|
||||
int to; /* state number */
|
||||
};
|
||||
|
||||
struct cnfa
|
||||
{
|
||||
int nstates; /* number of states */
|
||||
int ncolors; /* number of colors */
|
||||
int flags;
|
||||
#define HASLACONS 01 /* uses lookahead constraints */
|
||||
int pre; /* setup state number */
|
||||
int post; /* teardown state number */
|
||||
color bos[2]; /* colors, if any, assigned to BOS and BOL */
|
||||
color eos[2]; /* colors, if any, assigned to EOS and EOL */
|
||||
struct carc **states; /* vector of pointers to outarc lists */
|
||||
struct carc *arcs; /* the area for the lists */
|
||||
};
|
||||
|
||||
#define ZAPCNFA(cnfa) ((cnfa).nstates = 0)
|
||||
#define NULLCNFA(cnfa) ((cnfa).nstates == 0)
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* subexpression tree
|
||||
*/
|
||||
struct subre
|
||||
{
|
||||
char op; /* '|', '.' (concat), 'b' (backref), '(',
|
||||
* '=' */
|
||||
char flags;
|
||||
#define LONGER 01 /* prefers longer match */
|
||||
#define SHORTER 02 /* prefers shorter match */
|
||||
#define MIXED 04 /* mixed preference below */
|
||||
#define CAP 010 /* capturing parens below */
|
||||
#define BACKR 020 /* back reference below */
|
||||
#define INUSE 0100 /* in use in final tree */
|
||||
#define LOCAL 03 /* bits which may not propagate up */
|
||||
#define LMIX(f) ((f)<<2) /* LONGER -> MIXED */
|
||||
#define SMIX(f) ((f)<<1) /* SHORTER -> MIXED */
|
||||
#define UP(f) (((f)&~LOCAL) | (LMIX(f) & SMIX(f) & MIXED))
|
||||
#define MESSY(f) ((f)&(MIXED|CAP|BACKR))
|
||||
#define PREF(f) ((f)&LOCAL)
|
||||
#define PREF2(f1, f2) ((PREF(f1) != 0) ? PREF(f1) : PREF(f2))
|
||||
#define COMBINE(f1, f2) (UP((f1)|(f2)) | PREF2(f1, f2))
|
||||
short retry; /* index into retry memory */
|
||||
int subno; /* subexpression number (for 'b' and '(') */
|
||||
short min; /* min repetitions, for backref only */
|
||||
short max; /* max repetitions, for backref only */
|
||||
struct subre *left; /* left child, if any (also freelist
|
||||
* chain) */
|
||||
struct subre *right; /* right child, if any */
|
||||
struct state *begin; /* outarcs from here... */
|
||||
struct state *end; /* ...ending in inarcs here */
|
||||
struct cnfa cnfa; /* compacted NFA, if any */
|
||||
struct subre *chain; /* for bookkeeping and error cleanup */
|
||||
};
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* table of function pointers for generic manipulation functions
|
||||
* A regex_t's re_fns points to one of these.
|
||||
*/
|
||||
struct fns
|
||||
{
|
||||
void FUNCPTR(free, (regex_t *));
|
||||
};
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* the insides of a regex_t, hidden behind a void *
|
||||
*/
|
||||
struct guts
|
||||
{
|
||||
int magic;
|
||||
#define GUTSMAGIC 0xfed9
|
||||
int cflags; /* copy of compile flags */
|
||||
long info; /* copy of re_info */
|
||||
size_t nsub; /* copy of re_nsub */
|
||||
struct subre *tree;
|
||||
struct cnfa search; /* for fast preliminary search */
|
||||
int ntree;
|
||||
struct colormap cmap;
|
||||
int FUNCPTR(compare, (const chr *, const chr *, size_t));
|
||||
struct subre *lacons; /* lookahead-constraint vector */
|
||||
int nlacons; /* size of lacons */
|
||||
};
|
||||
@@ -1,904 +0,0 @@
|
||||
/*
|
||||
* tclUniData.c --
|
||||
*
|
||||
* Declarations of Unicode character information tables. This file is
|
||||
* automatically generated by the tools/uniParse.tcl script. Do not
|
||||
* modify this file by hand.
|
||||
*
|
||||
* Copyright (c) 1998 by Scriptics Corporation.
|
||||
* All rights reserved.
|
||||
*
|
||||
* RCS: @(#) $Id$
|
||||
*/
|
||||
|
||||
/*
|
||||
* A 16-bit Unicode character is split into two parts in order to index
|
||||
* into the following tables. The lower OFFSET_BITS comprise an offset
|
||||
* into a page of characters. The upper bits comprise the page number.
|
||||
*/
|
||||
|
||||
#define OFFSET_BITS 5
|
||||
|
||||
/*
|
||||
* The pageMap is indexed by page number and returns an alternate page number
|
||||
* that identifies a unique page of characters. Many Unicode characters map
|
||||
* to the same alternate page number.
|
||||
*/
|
||||
|
||||
static unsigned char pageMap[] = {
|
||||
0, 1, 2, 3, 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 7, 15, 16, 17,
|
||||
18, 19, 20, 21, 22, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 7, 32,
|
||||
7, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 47,
|
||||
48, 49, 50, 51, 52, 35, 47, 53, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
|
||||
58, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 80, 81,
|
||||
84, 85, 80, 86, 87, 88, 89, 90, 91, 92, 35, 93, 94, 95, 35, 96, 97,
|
||||
98, 99, 100, 101, 102, 35, 47, 103, 104, 35, 35, 105, 106, 107, 47,
|
||||
47, 108, 47, 47, 109, 47, 110, 111, 47, 112, 47, 113, 114, 115, 116,
|
||||
114, 47, 117, 118, 35, 47, 47, 119, 90, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 120, 121, 47, 47, 122,
|
||||
35, 35, 35, 35, 47, 123, 124, 125, 126, 47, 127, 128, 47, 129, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 7, 7, 7, 7, 130, 7, 7, 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, 156, 156, 156, 156, 156, 156,
|
||||
157, 158, 159, 160, 161, 162, 35, 35, 35, 160, 163, 164, 165, 166,
|
||||
167, 168, 169, 160, 160, 160, 160, 170, 171, 172, 173, 174, 160, 160,
|
||||
175, 35, 35, 35, 35, 176, 177, 178, 179, 180, 181, 35, 35, 160, 160,
|
||||
160, 160, 160, 160, 160, 160, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
182, 160, 160, 155, 160, 160, 160, 160, 160, 160, 170, 183, 184, 185,
|
||||
90, 47, 186, 90, 47, 187, 188, 189, 47, 47, 190, 128, 35, 35, 191,
|
||||
192, 193, 194, 192, 195, 196, 197, 160, 160, 160, 198, 160, 160, 199,
|
||||
197, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 200, 35, 35, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 201, 35, 35, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
202, 203, 204, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 205, 35, 35, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206,
|
||||
206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206,
|
||||
206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206,
|
||||
206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206,
|
||||
206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 206, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 47, 47, 47, 47, 47, 47, 47, 47, 47, 208, 35, 35, 35, 35,
|
||||
35, 35, 209, 210, 211, 47, 47, 212, 213, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 214, 215, 47, 216, 47, 217, 218, 35, 219, 220, 221, 47,
|
||||
47, 47, 222, 223, 2, 224, 225, 226, 227, 228, 229, 230, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 231, 35, 232, 233,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
|
||||
47, 208, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 47, 234, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 235, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207, 207,
|
||||
207, 207, 207, 236, 207, 207, 207, 207, 207, 207, 207, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
|
||||
35, 35, 35, 35, 35
|
||||
};
|
||||
|
||||
/*
|
||||
* The groupMap is indexed by combining the alternate page number with
|
||||
* the page offset and returns a group number that identifies a unique
|
||||
* set of character attributes.
|
||||
*/
|
||||
|
||||
static unsigned char groupMap[] = {
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
||||
1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 3, 3, 4, 3, 3, 3, 5, 6, 3, 7, 3, 8,
|
||||
3, 3, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 3, 7, 7, 7, 3, 3, 10, 10, 10,
|
||||
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
|
||||
10, 10, 10, 10, 10, 10, 5, 3, 6, 11, 12, 11, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 5, 7, 6, 7, 1, 2, 3, 4, 4, 4, 4, 14, 14, 11, 14, 15, 16,
|
||||
7, 8, 14, 11, 14, 7, 17, 17, 11, 18, 14, 3, 11, 17, 15, 19, 17, 17,
|
||||
17, 3, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
|
||||
10, 10, 10, 10, 10, 10, 10, 10, 7, 10, 10, 10, 10, 10, 10, 10, 15,
|
||||
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 13, 7, 13, 13, 13, 13, 13, 13, 13, 20, 21, 22,
|
||||
21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21,
|
||||
22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22,
|
||||
21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 23, 24, 21, 22, 21,
|
||||
22, 21, 22, 15, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21,
|
||||
22, 21, 22, 15, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21,
|
||||
22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22,
|
||||
21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 25,
|
||||
21, 22, 21, 22, 21, 22, 26, 15, 27, 21, 22, 21, 22, 28, 21, 22, 29,
|
||||
29, 21, 22, 15, 30, 31, 32, 21, 22, 29, 33, 34, 35, 36, 21, 22, 15,
|
||||
15, 35, 37, 15, 38, 21, 22, 21, 22, 21, 22, 39, 21, 22, 39, 15, 15,
|
||||
21, 22, 39, 21, 22, 40, 40, 21, 22, 21, 22, 41, 21, 22, 15, 42, 21,
|
||||
22, 15, 43, 42, 42, 42, 42, 44, 45, 46, 44, 45, 46, 44, 45, 46, 21,
|
||||
22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 47, 21,
|
||||
22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22,
|
||||
15, 44, 45, 46, 21, 22, 48, 49, 21, 22, 21, 22, 21, 22, 21, 22, 0,
|
||||
0, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22,
|
||||
21, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 50, 51, 15, 52, 52, 15, 53, 15,
|
||||
54, 15, 15, 15, 15, 52, 15, 15, 55, 15, 15, 15, 15, 56, 57, 15, 15,
|
||||
15, 15, 15, 57, 15, 15, 58, 15, 15, 59, 15, 15, 15, 15, 15, 15, 15,
|
||||
15, 15, 15, 60, 15, 15, 60, 15, 15, 15, 15, 60, 15, 61, 61, 15, 15,
|
||||
15, 15, 15, 15, 62, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
|
||||
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 63,
|
||||
63, 63, 63, 63, 63, 63, 63, 63, 11, 11, 63, 63, 63, 63, 63, 63, 63,
|
||||
11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 63, 63, 11,
|
||||
11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 63, 63, 63, 63,
|
||||
63, 11, 11, 11, 11, 11, 11, 11, 11, 11, 63, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
|
||||
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
|
||||
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 65, 64, 64, 64, 64, 64, 64,
|
||||
64, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64,
|
||||
64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11,
|
||||
0, 0, 0, 0, 63, 0, 0, 0, 3, 0, 0, 0, 0, 0, 11, 11, 66, 3, 67, 67, 67,
|
||||
0, 68, 0, 69, 69, 15, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
|
||||
10, 10, 10, 10, 10, 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 70, 71,
|
||||
71, 71, 15, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 72, 13, 13, 13, 13, 13, 13, 13, 13, 13, 73, 74, 74, 0,
|
||||
75, 76, 77, 77, 77, 78, 79, 15, 0, 0, 21, 22, 21, 22, 21, 22, 21, 22,
|
||||
21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 80, 81, 47,
|
||||
15, 82, 83, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 84, 84, 84, 84, 84, 84, 84,
|
||||
84, 84, 84, 84, 84, 84, 84, 84, 84, 10, 10, 10, 10, 10, 10, 10, 10,
|
||||
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
|
||||
10, 10, 10, 10, 10, 10, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81,
|
||||
81, 81, 81, 81, 21, 22, 14, 64, 64, 64, 64, 0, 85, 85, 0, 0, 21, 22,
|
||||
21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21,
|
||||
22, 77, 21, 22, 21, 22, 0, 0, 21, 22, 0, 0, 21, 22, 0, 0, 0, 21, 22,
|
||||
21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21,
|
||||
22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22,
|
||||
21, 22, 0, 0, 21, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 86, 86, 86, 86,
|
||||
86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
|
||||
86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
|
||||
0, 0, 63, 3, 3, 3, 3, 3, 3, 0, 87, 87, 87, 87, 87, 87, 87, 87, 87,
|
||||
87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
|
||||
87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 87, 15, 0, 3, 8, 0, 0,
|
||||
0, 0, 0, 0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
|
||||
64, 64, 64, 0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
|
||||
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 64, 64, 64, 3, 64, 3, 64,
|
||||
64, 3, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 0, 0, 0, 0, 0, 42, 42, 42, 3, 3, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 0, 0, 0, 0, 0, 63, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 3, 3, 3, 0, 0, 64, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 3, 42, 64,
|
||||
64, 64, 64, 64, 64, 64, 85, 85, 64, 64, 64, 64, 64, 64, 63, 63, 64,
|
||||
64, 14, 64, 64, 64, 64, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 42, 42,
|
||||
42, 14, 14, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 88, 42,
|
||||
64, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 64, 64, 64, 64,
|
||||
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
|
||||
64, 64, 64, 64, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 64, 64, 64, 64, 64, 64, 64,
|
||||
64, 64, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64,
|
||||
64, 89, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 0, 0, 64, 42, 89, 89, 89, 64, 64, 64, 64, 64, 64,
|
||||
64, 64, 89, 89, 89, 89, 64, 0, 0, 42, 64, 64, 64, 64, 0, 0, 0, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 64, 64, 3, 3, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64,
|
||||
89, 89, 0, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 42, 42, 0, 0, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 0, 42, 0, 0, 0, 42,
|
||||
42, 42, 42, 0, 0, 64, 0, 89, 89, 89, 64, 64, 64, 64, 0, 0, 89, 89,
|
||||
0, 0, 89, 89, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 89, 0, 0, 0, 0, 42, 42,
|
||||
0, 42, 42, 42, 64, 64, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 42, 42,
|
||||
4, 4, 17, 17, 17, 17, 17, 17, 14, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 42,
|
||||
42, 42, 42, 42, 42, 0, 0, 0, 0, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0,
|
||||
42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 0, 42, 42, 0, 42, 42, 0, 0,
|
||||
64, 0, 89, 89, 89, 64, 64, 0, 0, 0, 0, 64, 64, 0, 0, 64, 64, 64, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 0, 42, 0, 0, 0, 0, 0,
|
||||
0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 64, 64, 42, 42, 42, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 64, 64, 89, 0, 42, 42, 42, 42, 42, 42, 42,
|
||||
0, 42, 0, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42,
|
||||
42, 42, 0, 42, 42, 0, 42, 42, 42, 42, 42, 0, 0, 64, 42, 89, 89, 89,
|
||||
64, 64, 64, 64, 64, 0, 64, 64, 89, 0, 89, 89, 64, 0, 0, 42, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 0, 0, 0, 0, 0, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 0, 42,
|
||||
42, 0, 0, 42, 42, 42, 42, 0, 0, 64, 42, 89, 64, 89, 64, 64, 64, 0,
|
||||
0, 0, 89, 89, 0, 0, 89, 89, 64, 0, 0, 0, 0, 0, 0, 0, 0, 64, 89, 0,
|
||||
0, 0, 0, 42, 42, 0, 42, 42, 42, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 89,
|
||||
0, 42, 42, 42, 42, 42, 42, 0, 0, 0, 42, 42, 42, 0, 42, 42, 42, 42,
|
||||
0, 0, 0, 42, 42, 0, 42, 0, 42, 42, 0, 0, 0, 42, 42, 0, 0, 0, 42, 42,
|
||||
42, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 0, 0, 0,
|
||||
0, 89, 89, 64, 89, 89, 0, 0, 0, 89, 89, 89, 0, 89, 89, 89, 64, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 89, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 17, 17, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 89, 89, 89, 0, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42,
|
||||
42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 0, 42, 42, 42, 42, 42, 0, 0, 0, 0, 64, 64, 64, 89, 89,
|
||||
89, 89, 0, 64, 64, 64, 0, 64, 64, 64, 64, 0, 0, 0, 0, 0, 0, 0, 64,
|
||||
64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 89,
|
||||
89, 0, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 0, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42,
|
||||
42, 42, 0, 0, 0, 0, 89, 64, 89, 89, 89, 89, 89, 0, 64, 89, 89, 0, 89,
|
||||
89, 64, 64, 0, 0, 0, 0, 0, 0, 0, 89, 89, 0, 0, 0, 0, 0, 0, 0, 42, 0,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 89, 89, 89, 64, 64,
|
||||
64, 0, 0, 89, 89, 89, 0, 89, 89, 89, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
89, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 89, 89, 0, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 0, 0,
|
||||
42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 64, 0, 0, 0, 0, 89, 89, 89, 64,
|
||||
64, 64, 0, 64, 0, 89, 89, 89, 89, 89, 89, 89, 89, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 89, 89, 3, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 64, 42, 42, 64, 64, 64, 64, 64, 64, 64, 0, 0, 0, 0, 4, 42, 42,
|
||||
42, 42, 42, 42, 63, 64, 64, 64, 64, 64, 64, 64, 64, 3, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 3, 3, 0, 0, 0, 0, 0, 42, 42, 0, 42, 0, 0, 42, 42,
|
||||
0, 42, 0, 0, 42, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 0, 42, 42, 42, 42,
|
||||
42, 42, 42, 0, 42, 42, 42, 0, 42, 0, 42, 0, 0, 42, 42, 0, 42, 42, 42,
|
||||
42, 64, 42, 42, 64, 64, 64, 64, 64, 64, 0, 64, 64, 42, 0, 0, 42, 42,
|
||||
42, 42, 42, 0, 63, 0, 64, 64, 64, 64, 64, 64, 0, 0, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 0, 0, 42, 42, 0, 0, 42, 14, 14, 14, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 14, 14, 14, 14, 14, 64, 64, 14, 14, 14,
|
||||
14, 14, 14, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 17, 17, 17, 17, 17, 17, 17,
|
||||
17, 17, 17, 14, 64, 14, 64, 14, 64, 5, 6, 5, 6, 89, 89, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 64, 64, 64, 64, 64, 64, 64,
|
||||
64, 64, 64, 64, 64, 64, 64, 89, 64, 64, 64, 64, 64, 3, 64, 64, 42,
|
||||
42, 42, 42, 0, 0, 0, 0, 64, 64, 64, 64, 64, 64, 64, 64, 0, 64, 64,
|
||||
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
|
||||
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
|
||||
0, 14, 14, 14, 14, 14, 14, 14, 14, 64, 14, 14, 14, 14, 14, 14, 0, 0,
|
||||
14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 0, 42,
|
||||
42, 42, 42, 42, 0, 42, 42, 0, 89, 64, 64, 64, 64, 89, 64, 0, 0, 0,
|
||||
64, 64, 89, 64, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3,
|
||||
3, 3, 3, 3, 3, 42, 42, 42, 42, 42, 42, 89, 89, 64, 64, 0, 0, 0, 0,
|
||||
0, 0, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
|
||||
77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
|
||||
77, 77, 77, 77, 77, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
0, 0, 0, 0, 3, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0,
|
||||
0, 0, 0, 0, 42, 42, 42, 42, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 42, 42, 42,
|
||||
42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 0, 42, 0, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 42,
|
||||
0, 42, 0, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 42, 0, 42,
|
||||
0, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 0, 42, 0, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42,
|
||||
42, 0, 42, 0, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 42, 0,
|
||||
42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 9, 9, 9, 9, 9, 9, 9, 9, 9, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
|
||||
17, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 3, 3, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 5, 6, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
3, 3, 3, 90, 90, 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 89, 89, 89, 64, 64, 64, 64, 64, 64, 64, 89, 89, 89, 89, 89,
|
||||
89, 89, 89, 64, 89, 89, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
|
||||
3, 3, 3, 3, 3, 3, 3, 4, 3, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3,
|
||||
3, 3, 3, 3, 8, 3, 3, 3, 3, 88, 88, 88, 88, 0, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 0, 0, 0, 0, 0, 0, 42, 42, 42, 63, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 64, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 22, 21, 22, 21, 22, 21,
|
||||
22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 15, 15,
|
||||
15, 15, 15, 91, 0, 0, 0, 0, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22,
|
||||
21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 21, 22, 0,
|
||||
0, 0, 0, 0, 0, 92, 92, 92, 92, 92, 92, 92, 92, 93, 93, 93, 93, 93,
|
||||
93, 93, 93, 92, 92, 92, 92, 92, 92, 0, 0, 93, 93, 93, 93, 93, 93, 0,
|
||||
0, 92, 92, 92, 92, 92, 92, 92, 92, 93, 93, 93, 93, 93, 93, 93, 93,
|
||||
92, 92, 92, 92, 92, 92, 92, 92, 93, 93, 93, 93, 93, 93, 93, 93, 92,
|
||||
92, 92, 92, 92, 92, 0, 0, 93, 93, 93, 93, 93, 93, 0, 0, 15, 92, 15,
|
||||
92, 15, 92, 15, 92, 0, 93, 0, 93, 0, 93, 0, 93, 92, 92, 92, 92, 92,
|
||||
92, 92, 92, 93, 93, 93, 93, 93, 93, 93, 93, 94, 94, 95, 95, 95, 95,
|
||||
96, 96, 97, 97, 98, 98, 99, 99, 0, 0, 92, 92, 92, 92, 92, 92, 92, 92,
|
||||
100, 100, 100, 100, 100, 100, 100, 100, 92, 92, 92, 92, 92, 92, 92,
|
||||
92, 100, 100, 100, 100, 100, 100, 100, 100, 92, 92, 92, 92, 92, 92,
|
||||
92, 92, 100, 100, 100, 100, 100, 100, 100, 100, 92, 92, 15, 101, 15,
|
||||
0, 15, 15, 93, 93, 102, 102, 103, 11, 104, 11, 11, 11, 15, 101, 15,
|
||||
0, 15, 15, 105, 105, 105, 105, 103, 11, 11, 11, 92, 92, 15, 15, 0,
|
||||
0, 15, 15, 93, 93, 106, 106, 0, 11, 11, 11, 92, 92, 15, 15, 15, 107,
|
||||
15, 15, 93, 93, 108, 108, 109, 11, 11, 11, 0, 0, 15, 101, 15, 0, 15,
|
||||
15, 110, 110, 111, 111, 103, 11, 11, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 88, 88, 88, 88, 8, 8, 8, 8, 8, 8, 3, 3, 16, 19, 5, 16, 16,
|
||||
19, 5, 16, 3, 3, 3, 3, 3, 3, 3, 3, 112, 113, 88, 88, 88, 88, 88, 2,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 16, 19, 3, 3, 3, 3, 12, 12, 3, 3, 3, 7,
|
||||
5, 6, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, 88, 88, 88, 88, 88, 17,
|
||||
0, 0, 0, 17, 17, 17, 17, 17, 17, 7, 7, 7, 5, 6, 15, 17, 17, 17, 17,
|
||||
17, 17, 17, 17, 17, 17, 7, 7, 7, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
|
||||
64, 64, 64, 85, 85, 85, 85, 64, 85, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 77,
|
||||
14, 14, 14, 14, 77, 14, 14, 15, 77, 77, 77, 15, 15, 77, 77, 77, 15,
|
||||
14, 77, 14, 14, 14, 77, 77, 77, 77, 77, 14, 14, 14, 14, 14, 14, 77,
|
||||
14, 114, 14, 77, 14, 115, 116, 77, 77, 14, 15, 77, 77, 14, 77, 15,
|
||||
42, 42, 42, 42, 15, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
|
||||
17, 17, 17, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117, 117,
|
||||
117, 117, 117, 117, 117, 118, 118, 118, 118, 118, 118, 118, 118, 118,
|
||||
118, 118, 118, 118, 118, 118, 118, 90, 90, 90, 90, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 7, 7, 7, 7, 7, 14, 14, 14, 14, 14, 7, 7, 14, 14,
|
||||
14, 14, 7, 14, 14, 7, 14, 14, 7, 14, 14, 14, 14, 14, 14, 14, 7, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 7, 14, 14, 7,
|
||||
14, 7, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 7, 7, 7, 7, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 7, 7, 14, 14, 14, 14, 14, 14, 14, 5, 6, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 17, 17, 17, 17, 17, 17, 17,
|
||||
17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
|
||||
17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
|
||||
17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
|
||||
17, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 119, 119, 119, 119, 119, 119,
|
||||
119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119,
|
||||
119, 119, 119, 119, 119, 119, 120, 120, 120, 120, 120, 120, 120, 120,
|
||||
120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120,
|
||||
120, 120, 120, 120, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 7, 14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 7, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14,
|
||||
14, 14, 14, 0, 14, 14, 14, 14, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 0, 14, 0, 14, 14, 14, 14, 0, 0, 0, 14, 0, 14, 14,
|
||||
14, 14, 14, 14, 14, 0, 0, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
|
||||
17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
|
||||
17, 17, 17, 14, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 0, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0,
|
||||
0, 0, 0, 2, 3, 3, 3, 14, 63, 42, 90, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6,
|
||||
14, 14, 5, 6, 5, 6, 5, 6, 5, 6, 8, 5, 6, 6, 14, 90, 90, 90, 90, 90,
|
||||
90, 90, 90, 90, 64, 64, 64, 64, 64, 64, 8, 63, 63, 63, 63, 63, 14,
|
||||
14, 90, 90, 90, 0, 0, 0, 14, 14, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 64, 64,
|
||||
11, 11, 63, 63, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 12, 63,
|
||||
63, 63, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 14, 14, 17, 17, 17,
|
||||
17, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 0, 0, 0, 17, 17, 17, 17, 17, 17, 17, 17, 17,
|
||||
17, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 0, 14, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
42, 42, 42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 121, 121, 121, 121, 121, 121, 121,
|
||||
121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
|
||||
121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 122, 122, 122,
|
||||
122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
|
||||
122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
|
||||
122, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15,
|
||||
15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 0,
|
||||
0, 0, 0, 0, 42, 64, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 7, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 42, 42, 42, 42,
|
||||
42, 0, 42, 0, 42, 42, 0, 42, 42, 0, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0, 0, 64, 64, 64, 64,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 8, 8, 12, 12, 5, 6, 5, 6, 5,
|
||||
6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 0, 0, 3, 3, 3, 3, 12, 12, 12,
|
||||
3, 3, 3, 0, 3, 3, 3, 3, 8, 5, 6, 5, 6, 5, 6, 3, 3, 3, 7, 8, 7, 7, 7,
|
||||
0, 3, 4, 3, 3, 0, 0, 0, 0, 42, 42, 42, 0, 42, 0, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
0, 0, 88, 0, 3, 3, 3, 4, 3, 3, 3, 5, 6, 3, 7, 3, 8, 3, 3, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9, 3, 3, 7, 7, 7, 3, 11, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 5, 7, 6, 7, 0, 0, 3, 5, 6, 3, 12, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 63, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 63,
|
||||
63, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
|
||||
42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 0, 0,
|
||||
42, 42, 42, 42, 42, 42, 0, 0, 42, 42, 42, 42, 42, 42, 0, 0, 42, 42,
|
||||
42, 42, 42, 42, 0, 0, 42, 42, 42, 0, 0, 0, 4, 4, 7, 11, 14, 4, 4, 0,
|
||||
14, 7, 7, 7, 7, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 88, 88, 88, 14,
|
||||
14, 42, 17, 42, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 123, 123, 123,
|
||||
126, 126, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 89, 64, 14, 14, 14,
|
||||
14, 14, 0, 0, 77, 77, 15, 15, 77, 15, 15, 77, 77, 15, 77, 77, 15, 77,
|
||||
77, 15, 15, 77, 15, 15, 77, 77, 15, 77, 77, 15, 77, 77, 15, 15, 77,
|
||||
15, 15, 77, 77, 15, 77, 77, 15, 77, 77, 15, 15, 77, 77, 15, 15, 77,
|
||||
15, 15, 77, 77, 15, 15, 77, 15, 15, 77, 77, 15, 15, 9, 9, 9, 42, 42,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 88, 0, 88, 88, 88, 88, 88, 88, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 122,
|
||||
122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
|
||||
122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
|
||||
122
|
||||
};
|
||||
|
||||
/*
|
||||
* Each group represents a unique set of character attributes. The attributes
|
||||
* are encoded into a 32-bit value as follows:
|
||||
*
|
||||
* Bits 0-4 Character category: see the constants listed below.
|
||||
*
|
||||
* Bits 5-7 Case delta type: 000 = identity
|
||||
* 010 = add delta for lower
|
||||
* 011 = add delta for lower, add 1 for title
|
||||
* 100 = sutract delta for title/upper
|
||||
* 101 = sub delta for upper, sub 1 for title
|
||||
* 110 = sub delta for upper, add delta for lower
|
||||
*
|
||||
* Bits 8-21 Reserved for future use.
|
||||
*
|
||||
* Bits 22-31 Case delta: delta for case conversions. This should be the
|
||||
* highest field so we can easily sign extend.
|
||||
*/
|
||||
|
||||
static int groups[] = {
|
||||
0, 15, 12, 25, 27, 21, 22, 26, 20, 9, 134217793, 28, 19, 134217858,
|
||||
29, 2, 23, 11, 1178599554, 24, -507510654, 4194369, 4194434, -834666431,
|
||||
973078658, -507510719, 1258291330, 880803905, 864026689, 859832385,
|
||||
331350081, 847249473, 851443777, 868220993, -406847358, 884998209,
|
||||
876609601, 893386817, 897581121, 914358337, 910164033, 918552641,
|
||||
5, -234880894, 8388705, 4194499, 8388770, 331350146, -406847423,
|
||||
-234880959, 880803970, 864026754, 859832450, 847249538, 851443842,
|
||||
868221058, 876609666, 884998274, 893386882, 897581186, 914358402,
|
||||
910164098, 918552706, 4, 6, -352321402, 159383617, 155189313,
|
||||
268435521, 264241217, 159383682, 155189378, 130023554, 268435586,
|
||||
264241282, 260046978, 239075458, 1, 197132418, 226492546, 360710274,
|
||||
335544450, -251658175, 402653314, 335544385, 7, 201326657, 201326722,
|
||||
16, 8, 10, 247464066, -33554302, -33554367, -310378366, -360710014,
|
||||
-419430270, -536870782, -469761918, -528482174, -33554365, -37748606,
|
||||
-310378431, -37748669, 155189378, -360710079, -419430335, -29359998,
|
||||
-469761983, -29360063, -536870847, -528482239, 13, 14, -1463812031,
|
||||
-801111999, -293601215, 67108938, 67109002, 109051997, 109052061,
|
||||
18, 17, 8388673, 12582977, 8388738, 12583042
|
||||
};
|
||||
|
||||
/*
|
||||
* The following constants are used to determine the category of a
|
||||
* Unicode character.
|
||||
*/
|
||||
|
||||
#define UNICODE_CATEGORY_MASK 0X1F
|
||||
|
||||
enum {
|
||||
UNASSIGNED,
|
||||
UPPERCASE_LETTER,
|
||||
LOWERCASE_LETTER,
|
||||
TITLECASE_LETTER,
|
||||
MODIFIER_LETTER,
|
||||
OTHER_LETTER,
|
||||
NON_SPACING_MARK,
|
||||
ENCLOSING_MARK,
|
||||
COMBINING_SPACING_MARK,
|
||||
DECIMAL_DIGIT_NUMBER,
|
||||
LETTER_NUMBER,
|
||||
OTHER_NUMBER,
|
||||
SPACE_SEPARATOR,
|
||||
LINE_SEPARATOR,
|
||||
PARAGRAPH_SEPARATOR,
|
||||
CONTROL,
|
||||
FORMAT,
|
||||
PRIVATE_USE,
|
||||
SURROGATE,
|
||||
CONNECTOR_PUNCTUATION,
|
||||
DASH_PUNCTUATION,
|
||||
OPEN_PUNCTUATION,
|
||||
CLOSE_PUNCTUATION,
|
||||
INITIAL_QUOTE_PUNCTUATION,
|
||||
FINAL_QUOTE_PUNCTUATION,
|
||||
OTHER_PUNCTUATION,
|
||||
MATH_SYMBOL,
|
||||
CURRENCY_SYMBOL,
|
||||
MODIFIER_SYMBOL,
|
||||
OTHER_SYMBOL
|
||||
};
|
||||
|
||||
/*
|
||||
* The following macros extract the fields of the character info. The
|
||||
* GetDelta() macro is complicated because we can't rely on the C compiler
|
||||
* to do sign extension on right shifts.
|
||||
*/
|
||||
|
||||
#define GetCaseType(info) (((info) & 0xE0) >> 5)
|
||||
#define GetCategory(info) ((info) & 0x1F)
|
||||
#define GetDelta(info) (((info) > 0) ? ((info) >> 22) : (~(~((info)) >> 22)))
|
||||
|
||||
/*
|
||||
* This macro extracts the information about a character from the
|
||||
* Unicode character tables.
|
||||
*/
|
||||
|
||||
#define GetUniCharInfo(ch) (groups[groupMap[(pageMap[(((int)(ch)) & 0xffff) >> OFFSET_BITS] << OFFSET_BITS) | ((ch) & ((1 << OFFSET_BITS)-1))]])
|
||||
|
||||
477
src/regex/tests
477
src/regex/tests
@@ -1,477 +0,0 @@
|
||||
# regular expression test set
|
||||
# Lines are at least three fields, separated by one or more tabs. "" stands
|
||||
# for an empty field. First field is an RE. Second field is flags. If
|
||||
# C flag given, regcomp() is expected to fail, and the third field is the
|
||||
# error name (minus the leading REG_).
|
||||
#
|
||||
# Otherwise it is expected to succeed, and the third field is the string to
|
||||
# try matching it against. If there is no fourth field, the match is
|
||||
# expected to fail. If there is a fourth field, it is the substring that
|
||||
# the RE is expected to match. If there is a fifth field, it is a comma-
|
||||
# separated list of what the subexpressions should match, with - indicating
|
||||
# no match for that one. In both the fourth and fifth fields, a (sub)field
|
||||
# starting with @ indicates that the (sub)expression is expected to match
|
||||
# a null string followed by the stuff after the @; this provides a way to
|
||||
# test where null strings match. The character `N' in REs and strings
|
||||
# is newline, `S' is space, `T' is tab, `Z' is NUL.
|
||||
#
|
||||
# The full list of flags:
|
||||
# - placeholder, does nothing
|
||||
# b RE is a BRE, not an ERE
|
||||
# & try it as both an ERE and a BRE
|
||||
# C regcomp() error expected, third field is error name
|
||||
# i REG_ICASE
|
||||
# m ("mundane") REG_NOSPEC
|
||||
# s REG_NOSUB (not really testable)
|
||||
# n REG_NEWLINE
|
||||
# ^ REG_NOTBOL
|
||||
# $ REG_NOTEOL
|
||||
# # REG_STARTEND (see below)
|
||||
# p REG_PEND
|
||||
#
|
||||
# For REG_STARTEND, the start/end offsets are those of the substring
|
||||
# enclosed in ().
|
||||
|
||||
# basics
|
||||
a & a a
|
||||
abc & abc abc
|
||||
abc|de - abc abc
|
||||
a|b|c - abc a
|
||||
|
||||
# parentheses and perversions thereof
|
||||
a(b)c - abc abc
|
||||
a\(b\)c b abc abc
|
||||
a( C EPAREN
|
||||
a( b a( a(
|
||||
a\( - a( a(
|
||||
a\( bC EPAREN
|
||||
a\(b bC EPAREN
|
||||
a(b C EPAREN
|
||||
a(b b a(b a(b
|
||||
# gag me with a right parenthesis -- 1003.2 goofed here (my fault, partly)
|
||||
a) - a) a)
|
||||
) - ) )
|
||||
# end gagging (in a just world, those *should* give EPAREN)
|
||||
a) b a) a)
|
||||
a\) bC EPAREN
|
||||
\) bC EPAREN
|
||||
a()b - ab ab
|
||||
a\(\)b b ab ab
|
||||
|
||||
# anchoring and REG_NEWLINE
|
||||
^abc$ & abc abc
|
||||
a^b - a^b
|
||||
a^b b a^b a^b
|
||||
a$b - a$b
|
||||
a$b b a$b a$b
|
||||
^ & abc @abc
|
||||
$ & abc @
|
||||
^$ & "" @
|
||||
$^ - "" @
|
||||
\($\)\(^\) b "" @
|
||||
# stop retching, those are legitimate (although disgusting)
|
||||
^^ - "" @
|
||||
$$ - "" @
|
||||
b$ & abNc
|
||||
b$ &n abNc b
|
||||
^b$ & aNbNc
|
||||
^b$ &n aNbNc b
|
||||
^$ &n aNNb @Nb
|
||||
^$ n abc
|
||||
^$ n abcN @
|
||||
$^ n aNNb @Nb
|
||||
\($\)\(^\) bn aNNb @Nb
|
||||
^^ n^ aNNb @Nb
|
||||
$$ n aNNb @NN
|
||||
^a ^ a
|
||||
a$ $ a
|
||||
^a ^n aNb
|
||||
^b ^n aNb b
|
||||
a$ $n bNa
|
||||
b$ $n bNa b
|
||||
a*(^b$)c* - b b
|
||||
a*\(^b$\)c* b b b
|
||||
|
||||
# certain syntax errors and non-errors
|
||||
| C EMPTY
|
||||
| b | |
|
||||
* C BADRPT
|
||||
* b * *
|
||||
+ C BADRPT
|
||||
? C BADRPT
|
||||
"" &C EMPTY
|
||||
() - abc @abc
|
||||
\(\) b abc @abc
|
||||
a||b C EMPTY
|
||||
|ab C EMPTY
|
||||
ab| C EMPTY
|
||||
(|a)b C EMPTY
|
||||
(a|)b C EMPTY
|
||||
(*a) C BADRPT
|
||||
(+a) C BADRPT
|
||||
(?a) C BADRPT
|
||||
({1}a) C BADRPT
|
||||
\(\{1\}a\) bC BADRPT
|
||||
(a|*b) C BADRPT
|
||||
(a|+b) C BADRPT
|
||||
(a|?b) C BADRPT
|
||||
(a|{1}b) C BADRPT
|
||||
^* C BADRPT
|
||||
^* b * *
|
||||
^+ C BADRPT
|
||||
^? C BADRPT
|
||||
^{1} C BADRPT
|
||||
^\{1\} bC BADRPT
|
||||
|
||||
# metacharacters, backslashes
|
||||
a.c & abc abc
|
||||
a[bc]d & abd abd
|
||||
a\*c & a*c a*c
|
||||
a\\b & a\b a\b
|
||||
a\\\*b & a\*b a\*b
|
||||
a\bc & abc abc
|
||||
a\ &C EESCAPE
|
||||
a\\bc & a\bc a\bc
|
||||
\{ bC BADRPT
|
||||
a\[b & a[b a[b
|
||||
a[b &C EBRACK
|
||||
# trailing $ is a peculiar special case for the BRE code
|
||||
a$ & a a
|
||||
a$ & a$
|
||||
a\$ & a
|
||||
a\$ & a$ a$
|
||||
a\\$ & a
|
||||
a\\$ & a$
|
||||
a\\$ & a\$
|
||||
a\\$ & a\ a\
|
||||
|
||||
# back references, ugh
|
||||
a\(b\)\2c bC ESUBREG
|
||||
a\(b\1\)c bC ESUBREG
|
||||
a\(b*\)c\1d b abbcbbd abbcbbd bb
|
||||
a\(b*\)c\1d b abbcbd
|
||||
a\(b*\)c\1d b abbcbbbd
|
||||
^\(.\)\1 b abc
|
||||
a\([bc]\)\1d b abcdabbd abbd b
|
||||
a\(\([bc]\)\2\)*d b abbccd abbccd
|
||||
a\(\([bc]\)\2\)*d b abbcbd
|
||||
# actually, this next one probably ought to fail, but the spec is unclear
|
||||
a\(\(b\)*\2\)*d b abbbd abbbd
|
||||
# here is a case that no NFA implementation does right
|
||||
\(ab*\)[ab]*\1 b ababaaa ababaaa a
|
||||
# check out normal matching in the presence of back refs
|
||||
\(a\)\1bcd b aabcd aabcd
|
||||
\(a\)\1bc*d b aabcd aabcd
|
||||
\(a\)\1bc*d b aabd aabd
|
||||
\(a\)\1bc*d b aabcccd aabcccd
|
||||
\(a\)\1bc*[ce]d b aabcccd aabcccd
|
||||
^\(a\)\1b\(c\)*cd$ b aabcccd aabcccd
|
||||
|
||||
# ordinary repetitions
|
||||
ab*c & abc abc
|
||||
ab+c - abc abc
|
||||
ab?c - abc abc
|
||||
a\(*\)b b a*b a*b
|
||||
a\(**\)b b ab ab
|
||||
a\(***\)b bC BADRPT
|
||||
*a b *a *a
|
||||
**a b a a
|
||||
***a bC BADRPT
|
||||
|
||||
# the dreaded bounded repetitions
|
||||
{ & { {
|
||||
{abc & {abc {abc
|
||||
{1 C BADRPT
|
||||
{1} C BADRPT
|
||||
a{b & a{b a{b
|
||||
a{1}b - ab ab
|
||||
a\{1\}b b ab ab
|
||||
a{1,}b - ab ab
|
||||
a\{1,\}b b ab ab
|
||||
a{1,2}b - aab aab
|
||||
a\{1,2\}b b aab aab
|
||||
a{1 C EBRACE
|
||||
a\{1 bC EBRACE
|
||||
a{1a C EBRACE
|
||||
a\{1a bC EBRACE
|
||||
a{1a} C BADBR
|
||||
a\{1a\} bC BADBR
|
||||
a{,2} - a{,2} a{,2}
|
||||
a\{,2\} bC BADBR
|
||||
a{,} - a{,} a{,}
|
||||
a\{,\} bC BADBR
|
||||
a{1,x} C BADBR
|
||||
a\{1,x\} bC BADBR
|
||||
a{1,x C EBRACE
|
||||
a\{1,x bC EBRACE
|
||||
a{300} C BADBR
|
||||
a\{300\} bC BADBR
|
||||
a{1,0} C BADBR
|
||||
a\{1,0\} bC BADBR
|
||||
ab{0,0}c - abcac ac
|
||||
ab\{0,0\}c b abcac ac
|
||||
ab{0,1}c - abcac abc
|
||||
ab\{0,1\}c b abcac abc
|
||||
ab{0,3}c - abbcac abbc
|
||||
ab\{0,3\}c b abbcac abbc
|
||||
ab{1,1}c - acabc abc
|
||||
ab\{1,1\}c b acabc abc
|
||||
ab{1,3}c - acabc abc
|
||||
ab\{1,3\}c b acabc abc
|
||||
ab{2,2}c - abcabbc abbc
|
||||
ab\{2,2\}c b abcabbc abbc
|
||||
ab{2,4}c - abcabbc abbc
|
||||
ab\{2,4\}c b abcabbc abbc
|
||||
((a{1,10}){1,10}){1,10} - a a a,a
|
||||
|
||||
# multiple repetitions
|
||||
a** &C BADRPT
|
||||
a++ C BADRPT
|
||||
a?? C BADRPT
|
||||
a*+ C BADRPT
|
||||
a*? C BADRPT
|
||||
a+* C BADRPT
|
||||
a+? C BADRPT
|
||||
a?* C BADRPT
|
||||
a?+ C BADRPT
|
||||
a{1}{1} C BADRPT
|
||||
a*{1} C BADRPT
|
||||
a+{1} C BADRPT
|
||||
a?{1} C BADRPT
|
||||
a{1}* C BADRPT
|
||||
a{1}+ C BADRPT
|
||||
a{1}? C BADRPT
|
||||
a*{b} - a{b} a{b}
|
||||
a\{1\}\{1\} bC BADRPT
|
||||
a*\{1\} bC BADRPT
|
||||
a\{1\}* bC BADRPT
|
||||
|
||||
# brackets, and numerous perversions thereof
|
||||
a[b]c & abc abc
|
||||
a[ab]c & abc abc
|
||||
a[^ab]c & adc adc
|
||||
a[]b]c & a]c a]c
|
||||
a[[b]c & a[c a[c
|
||||
a[-b]c & a-c a-c
|
||||
a[^]b]c & adc adc
|
||||
a[^-b]c & adc adc
|
||||
a[b-]c & a-c a-c
|
||||
a[b &C EBRACK
|
||||
a[] &C EBRACK
|
||||
a[1-3]c & a2c a2c
|
||||
a[3-1]c &C ERANGE
|
||||
a[1-3-5]c &C ERANGE
|
||||
a[[.-.]--]c & a-c a-c
|
||||
a[1- &C ERANGE
|
||||
a[[. &C EBRACK
|
||||
a[[.x &C EBRACK
|
||||
a[[.x. &C EBRACK
|
||||
a[[.x.] &C EBRACK
|
||||
a[[.x.]] & ax ax
|
||||
a[[.x,.]] &C ECOLLATE
|
||||
a[[.one.]]b & a1b a1b
|
||||
a[[.notdef.]]b &C ECOLLATE
|
||||
a[[.].]]b & a]b a]b
|
||||
a[[:alpha:]]c & abc abc
|
||||
a[[:notdef:]]c &C ECTYPE
|
||||
a[[: &C EBRACK
|
||||
a[[:alpha &C EBRACK
|
||||
a[[:alpha:] &C EBRACK
|
||||
a[[:alpha,:] &C ECTYPE
|
||||
a[[:]:]]b &C ECTYPE
|
||||
a[[:-:]]b &C ECTYPE
|
||||
a[[:alph:]] &C ECTYPE
|
||||
a[[:alphabet:]] &C ECTYPE
|
||||
[[:alnum:]]+ - -%@a0X- a0X
|
||||
[[:alpha:]]+ - -%@aX0- aX
|
||||
[[:blank:]]+ - aSSTb SST
|
||||
[[:cntrl:]]+ - aNTb NT
|
||||
[[:digit:]]+ - a019b 019
|
||||
[[:graph:]]+ - Sa%bS a%b
|
||||
[[:lower:]]+ - AabC ab
|
||||
[[:print:]]+ - NaSbN aSb
|
||||
[[:punct:]]+ - S%-&T %-&
|
||||
[[:space:]]+ - aSNTb SNT
|
||||
[[:upper:]]+ - aBCd BC
|
||||
[[:xdigit:]]+ - p0f3Cq 0f3C
|
||||
a[[=b=]]c & abc abc
|
||||
a[[= &C EBRACK
|
||||
a[[=b &C EBRACK
|
||||
a[[=b= &C EBRACK
|
||||
a[[=b=] &C EBRACK
|
||||
a[[=b,=]] &C ECOLLATE
|
||||
a[[=one=]]b & a1b a1b
|
||||
|
||||
# complexities
|
||||
a(((b)))c - abc abc
|
||||
a(b|(c))d - abd abd
|
||||
a(b*|c)d - abbd abbd
|
||||
# just gotta have one DFA-buster, of course
|
||||
a[ab]{20} - aaaaabaaaabaaaabaaaab aaaaabaaaabaaaabaaaab
|
||||
# and an inline expansion in case somebody gets tricky
|
||||
a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab] - aaaaabaaaabaaaabaaaab aaaaabaaaabaaaabaaaab
|
||||
# and in case somebody just slips in an NFA...
|
||||
a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab](wee|week)(knights|night) - aaaaabaaaabaaaabaaaabweeknights aaaaabaaaabaaaabaaaabweeknights
|
||||
# fish for anomalies as the number of states passes 32
|
||||
12345678901234567890123456789 - a12345678901234567890123456789b 12345678901234567890123456789
|
||||
123456789012345678901234567890 - a123456789012345678901234567890b 123456789012345678901234567890
|
||||
1234567890123456789012345678901 - a1234567890123456789012345678901b 1234567890123456789012345678901
|
||||
12345678901234567890123456789012 - a12345678901234567890123456789012b 12345678901234567890123456789012
|
||||
123456789012345678901234567890123 - a123456789012345678901234567890123b 123456789012345678901234567890123
|
||||
# and one really big one, beyond any plausible word width
|
||||
1234567890123456789012345678901234567890123456789012345678901234567890 - a1234567890123456789012345678901234567890123456789012345678901234567890b 1234567890123456789012345678901234567890123456789012345678901234567890
|
||||
# fish for problems as brackets go past 8
|
||||
[ab][cd][ef][gh][ij][kl][mn] - xacegikmoq acegikm
|
||||
[ab][cd][ef][gh][ij][kl][mn][op] - xacegikmoq acegikmo
|
||||
[ab][cd][ef][gh][ij][kl][mn][op][qr] - xacegikmoqy acegikmoq
|
||||
[ab][cd][ef][gh][ij][kl][mn][op][q] - xacegikmoqy acegikmoq
|
||||
|
||||
# subtleties of matching
|
||||
abc & xabcy abc
|
||||
a\(b\)?c\1d b acd
|
||||
aBc i Abc Abc
|
||||
a[Bc]*d i abBCcd abBCcd
|
||||
0[[:upper:]]1 &i 0a1 0a1
|
||||
0[[:lower:]]1 &i 0A1 0A1
|
||||
a[^b]c &i abc
|
||||
a[^b]c &i aBc
|
||||
a[^b]c &i adc adc
|
||||
[a]b[c] - abc abc
|
||||
[a]b[a] - aba aba
|
||||
[abc]b[abc] - abc abc
|
||||
[abc]b[abd] - abd abd
|
||||
a(b?c)+d - accd accd
|
||||
(wee|week)(knights|night) - weeknights weeknights
|
||||
(we|wee|week|frob)(knights|night|day) - weeknights weeknights
|
||||
a[bc]d - xyzaaabcaababdacd abd
|
||||
a[ab]c - aaabc abc
|
||||
abc s abc abc
|
||||
a* & b @b
|
||||
|
||||
# Let's have some fun -- try to match a C comment.
|
||||
# first the obvious, which looks okay at first glance...
|
||||
/\*.*\*/ - /*x*/ /*x*/
|
||||
# but...
|
||||
/\*.*\*/ - /*x*/y/*z*/ /*x*/y/*z*/
|
||||
# okay, we must not match */ inside; try to do that...
|
||||
/\*([^*]|\*[^/])*\*/ - /*x*/ /*x*/
|
||||
/\*([^*]|\*[^/])*\*/ - /*x*/y/*z*/ /*x*/
|
||||
# but...
|
||||
/\*([^*]|\*[^/])*\*/ - /*x**/y/*z*/ /*x**/y/*z*/
|
||||
# and a still fancier version, which does it right (I think)...
|
||||
/\*([^*]|\*+[^*/])*\*+/ - /*x*/ /*x*/
|
||||
/\*([^*]|\*+[^*/])*\*+/ - /*x*/y/*z*/ /*x*/
|
||||
/\*([^*]|\*+[^*/])*\*+/ - /*x**/y/*z*/ /*x**/
|
||||
/\*([^*]|\*+[^*/])*\*+/ - /*x****/y/*z*/ /*x****/
|
||||
/\*([^*]|\*+[^*/])*\*+/ - /*x**x*/y/*z*/ /*x**x*/
|
||||
/\*([^*]|\*+[^*/])*\*+/ - /*x***x/y/*z*/ /*x***x/y/*z*/
|
||||
|
||||
# subexpressions
|
||||
.* - abc abc -
|
||||
a(b)(c)d - abcd abcd b,c
|
||||
a(((b)))c - abc abc b,b,b
|
||||
a(b|(c))d - abd abd b,-
|
||||
a(b*|c|e)d - abbd abbd bb
|
||||
a(b*|c|e)d - acd acd c
|
||||
a(b*|c|e)d - ad ad @d
|
||||
a(b?)c - abc abc b
|
||||
a(b?)c - ac ac @c
|
||||
a(b+)c - abc abc b
|
||||
a(b+)c - abbbc abbbc bbb
|
||||
a(b*)c - ac ac @c
|
||||
(a|ab)(bc([de]+)f|cde) - abcdef abcdef a,bcdef,de
|
||||
# the regression tester only asks for 9 subexpressions
|
||||
a(b)(c)(d)(e)(f)(g)(h)(i)(j)k - abcdefghijk abcdefghijk b,c,d,e,f,g,h,i,j
|
||||
a(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)l - abcdefghijkl abcdefghijkl b,c,d,e,f,g,h,i,j,k
|
||||
a([bc]?)c - abc abc b
|
||||
a([bc]?)c - ac ac @c
|
||||
a([bc]+)c - abc abc b
|
||||
a([bc]+)c - abcc abcc bc
|
||||
a([bc]+)bc - abcbc abcbc bc
|
||||
a(bb+|b)b - abb abb b
|
||||
a(bbb+|bb+|b)b - abb abb b
|
||||
a(bbb+|bb+|b)b - abbb abbb bb
|
||||
a(bbb+|bb+|b)bb - abbb abbb b
|
||||
(.*).* - abcdef abcdef abcdef
|
||||
(a*)* - bc @b @b
|
||||
|
||||
# do we get the right subexpression when it is used more than once?
|
||||
a(b|c)*d - ad ad -
|
||||
a(b|c)*d - abcd abcd c
|
||||
a(b|c)+d - abd abd b
|
||||
a(b|c)+d - abcd abcd c
|
||||
a(b|c?)+d - ad ad @d
|
||||
a(b|c?)+d - abcd abcd @d
|
||||
a(b|c){0,0}d - ad ad -
|
||||
a(b|c){0,1}d - ad ad -
|
||||
a(b|c){0,1}d - abd abd b
|
||||
a(b|c){0,2}d - ad ad -
|
||||
a(b|c){0,2}d - abcd abcd c
|
||||
a(b|c){0,}d - ad ad -
|
||||
a(b|c){0,}d - abcd abcd c
|
||||
a(b|c){1,1}d - abd abd b
|
||||
a(b|c){1,1}d - acd acd c
|
||||
a(b|c){1,2}d - abd abd b
|
||||
a(b|c){1,2}d - abcd abcd c
|
||||
a(b|c){1,}d - abd abd b
|
||||
a(b|c){1,}d - abcd abcd c
|
||||
a(b|c){2,2}d - acbd acbd b
|
||||
a(b|c){2,2}d - abcd abcd c
|
||||
a(b|c){2,4}d - abcd abcd c
|
||||
a(b|c){2,4}d - abcbd abcbd b
|
||||
a(b|c){2,4}d - abcbcd abcbcd c
|
||||
a(b|c){2,}d - abcd abcd c
|
||||
a(b|c){2,}d - abcbd abcbd b
|
||||
a(b+|((c)*))+d - abd abd @d,@d,-
|
||||
a(b+|((c)*))+d - abcd abcd @d,@d,-
|
||||
|
||||
# check out the STARTEND option
|
||||
[abc] &# a(b)c b
|
||||
[abc] &# a(d)c
|
||||
[abc] &# a(bc)d b
|
||||
[abc] &# a(dc)d c
|
||||
. &# a()c
|
||||
b.*c &# b(bc)c bc
|
||||
b.* &# b(bc)c bc
|
||||
.*c &# b(bc)c bc
|
||||
|
||||
# plain strings, with the NOSPEC flag
|
||||
abc m abc abc
|
||||
abc m xabcy abc
|
||||
abc m xyz
|
||||
a*b m aba*b a*b
|
||||
a*b m ab
|
||||
"" mC EMPTY
|
||||
|
||||
# cases involving NULs
|
||||
aZb & a a
|
||||
aZb &p a
|
||||
aZb &p# (aZb) aZb
|
||||
aZ*b &p# (ab) ab
|
||||
a.b &# (aZb) aZb
|
||||
a.* &# (aZb)c aZb
|
||||
|
||||
# word boundaries (ick)
|
||||
[[:<:]]a & a a
|
||||
[[:<:]]a & ba
|
||||
[[:<:]]a & -a a
|
||||
a[[:>:]] & a a
|
||||
a[[:>:]] & ab
|
||||
a[[:>:]] & a- a
|
||||
[[:<:]]a.c[[:>:]] & axcd-dayc-dazce-abc abc
|
||||
[[:<:]]a.c[[:>:]] & axcd-dayc-dazce-abc-q abc
|
||||
[[:<:]]a.c[[:>:]] & axc-dayc-dazce-abc axc
|
||||
[[:<:]]b.c[[:>:]] & a_bxc-byc_d-bzc-q bzc
|
||||
[[:<:]].x..[[:>:]] & y_xa_-_xb_y-_xc_-axdc _xc_
|
||||
[[:<:]]a_b[[:>:]] & x_a_b
|
||||
|
||||
# past problems, and suspected problems
|
||||
(A[1])|(A[2])|(A[3])|(A[4])|(A[5])|(A[6])|(A[7])|(A[8])|(A[9])|(A[A]) - A1 A1
|
||||
abcdefghijklmnop i abcdefghijklmnop abcdefghijklmnop
|
||||
abcdefghijklmnopqrstuv i abcdefghijklmnopqrstuv abcdefghijklmnopqrstuv
|
||||
(ALAK)|(ALT[AB])|(CC[123]1)|(CM[123]1)|(GAMC)|(LC[23][EO ])|(SEM[1234])|(SL[ES][12])|(SLWW)|(SLF )|(SLDT)|(VWH[12])|(WH[34][EW])|(WP1[ESN]) - CC11 CC11
|
||||
CC[13]1|a{21}[23][EO][123][Es][12]a{15}aa[34][EW]aaaaaaa[X]a - CC11 CC11
|
||||
Char \([a-z0-9_]*\)\[.* b Char xyz[k Char xyz[k xyz
|
||||
a?b - ab ab
|
||||
-\{0,1\}[0-9]*$ b -5 -5
|
||||
a*a*a*a*a*a*a* & aaaaaa aaaaaa
|
||||
422
src/unix/net.cpp
422
src/unix/net.cpp
@@ -1,422 +0,0 @@
|
||||
// -*- c++ -*- ///////////////////////////////////////////////////////////////
|
||||
// Name: unix/net.cpp
|
||||
// Purpose: Network related wxWindows classes and functions
|
||||
// Author: Karsten Ball<6C>der
|
||||
// Modified by:
|
||||
// Created: 03.10.99
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Karsten Ball<6C>der
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "wx/setup.h"
|
||||
|
||||
#if wxUSE_DIALUP_MANAGER
|
||||
|
||||
#ifndef WX_PRECOMP
|
||||
# include "wx/defs.h"
|
||||
#endif // !PCH
|
||||
|
||||
#include "wx/string.h"
|
||||
#include "wx/event.h"
|
||||
#include "wx/net.h"
|
||||
#include "wx/timer.h"
|
||||
#include "wx/filefn.h"
|
||||
#include "wx/utils.h"
|
||||
#include "wx/log.h"
|
||||
#include "wx/file.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <signal.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
#define __STRICT_ANSI__
|
||||
#include <sys/socket.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <netdb.h>
|
||||
#include <netinet/in.h>
|
||||
#include <arpa/inet.h>
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// A class which groups functions dealing with connecting to the network from a
|
||||
// workstation using dial-up access to the net. There is at most one instance
|
||||
// of this class in the program accessed via GetDialUpManager().
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
/* TODO
|
||||
*
|
||||
* 1. more configurability for Unix: i.e. how to initiate the connection, how
|
||||
* to check for online status, &c.
|
||||
* 2. add a "long Dial(long connectionId = -1)" function which asks the user
|
||||
* about which connection to dial (this may be done using native dialogs
|
||||
* under NT, need generic dialogs for all others) and returns the identifier
|
||||
* of the selected connection (it's opaque to the application) - it may be
|
||||
* reused later to dial the same connection later (or use strings instead of
|
||||
* longs may be?)
|
||||
* 3. add an async version of dialing functions which notify the caller about
|
||||
* the progress (or may be even start another thread to monitor it)
|
||||
* 4. the static creation/accessor functions are not MT-safe - but is this
|
||||
* really crucial? I think we may suppose they're always called from the
|
||||
* main thread?
|
||||
*/
|
||||
|
||||
class WXDLLEXPORT wxDialUpManagerImpl : public wxDialUpManager
|
||||
{
|
||||
public:
|
||||
wxDialUpManagerImpl()
|
||||
{
|
||||
m_IsOnline = -1; // unknown
|
||||
m_timer = NULL;
|
||||
m_CanUseIfconfig = -1; // unknown
|
||||
m_BeaconHost = WXDIALUP_MANAGER_DEFAULT_BEACONHOST;
|
||||
m_BeaconPort = 80;
|
||||
}
|
||||
|
||||
/** Could the dialup manager be initialized correctly? If this function
|
||||
returns FALSE, no other functions will work neither, so it's a good idea
|
||||
to call this function and check its result before calling any other
|
||||
wxDialUpManager methods.
|
||||
*/
|
||||
virtual bool IsOk() const
|
||||
{ return TRUE; }
|
||||
|
||||
/** The simplest way to initiate a dial up: this function dials the given
|
||||
ISP (exact meaning of the parameter depends on the platform), returns
|
||||
TRUE on success or FALSE on failure and logs the appropriate error
|
||||
message in the latter case.
|
||||
@param nameOfISP optional paramater for dial program
|
||||
@param username unused
|
||||
@param password unused
|
||||
*/
|
||||
virtual bool Dial(const wxString& nameOfISP,
|
||||
const wxString& WXUNUSED(username),
|
||||
const wxString& WXUNUSED(password));
|
||||
|
||||
/// Hang up the currently active dial up connection.
|
||||
virtual bool HangUp();
|
||||
|
||||
// returns TRUE if the computer is connected to the network: under Windows,
|
||||
// this just means that a RAS connection exists, under Unix we check that
|
||||
// the "well-known host" (as specified by SetWellKnownHost) is reachable
|
||||
virtual bool IsOnline() const
|
||||
{
|
||||
if( (! m_timer) // we are not polling, so test now:
|
||||
|| m_IsOnline == -1
|
||||
)
|
||||
CheckStatus();
|
||||
return m_IsOnline != 0;
|
||||
}
|
||||
|
||||
// sometimes the built-in logic for determining the online status may fail,
|
||||
// so, in general, the user should be allowed to override it. This function
|
||||
// allows to forcefully set the online status - whatever our internal
|
||||
// algorithm may think about it.
|
||||
virtual void SetOnlineStatus(bool isOnline = TRUE)
|
||||
{ m_IsOnline = isOnline; }
|
||||
|
||||
// set misc wxDialUpManager options
|
||||
// --------------------------------
|
||||
|
||||
// enable automatical checks for the connection status and sending of
|
||||
// wxEVT_DIALUP_CONNECTED/wxEVT_DIALUP_DISCONNECTED events. The interval
|
||||
// parameter is only for Unix where we do the check manually: under
|
||||
// Windows, the notification about the change of connection status is
|
||||
// instantenous.
|
||||
//
|
||||
// Returns FALSE if couldn't set up automatic check for online status.
|
||||
virtual bool EnableAutoCheckOnlineStatus(size_t nSeconds);
|
||||
|
||||
// disable automatic check for connection status change - notice that the
|
||||
// wxEVT_DIALUP_XXX events won't be sent any more neither.
|
||||
virtual void DisableAutoCheckOnlineStatus();
|
||||
|
||||
// under Unix, the value of well-known host is used to check whether we're
|
||||
// connected to the internet. It's unused under Windows, but this function
|
||||
// is always safe to call. The default value is www.yahoo.com.
|
||||
virtual void SetWellKnownHost(const wxString& hostname,
|
||||
int portno = 80);
|
||||
/** Sets the commands to start up the network and to hang up
|
||||
again. Used by the Unix implementations only.
|
||||
*/
|
||||
virtual void SetConnectCommand(const wxString &command, const wxString &hupcmd)
|
||||
{ m_ConnectCommand = command; m_HangUpCommand = hupcmd; }
|
||||
|
||||
private:
|
||||
/// -1: don<6F>t know, 0 = no, 1 = yes
|
||||
int m_IsOnline;
|
||||
|
||||
/// Can we use ifconfig to list active devices?
|
||||
int m_CanUseIfconfig;
|
||||
/// The path to ifconfig
|
||||
wxString m_IfconfigPath;
|
||||
|
||||
/// beacon host:
|
||||
wxString m_BeaconHost;
|
||||
/// beacon host portnumber for connect:
|
||||
int m_BeaconPort;
|
||||
|
||||
/// command to connect to network
|
||||
wxString m_ConnectCommand;
|
||||
/// command to hang up
|
||||
wxString m_HangUpCommand;
|
||||
/// name of ISP
|
||||
wxString m_ISPname;
|
||||
/// a timer for regular testing
|
||||
class AutoCheckTimer *m_timer;
|
||||
|
||||
friend class AutoCheckTimer;
|
||||
/// determine status
|
||||
void CheckStatus(void) const;
|
||||
|
||||
/// real status check
|
||||
void CheckStatusInternal(void);
|
||||
};
|
||||
|
||||
|
||||
class AutoCheckTimer : public wxTimer
|
||||
{
|
||||
public:
|
||||
AutoCheckTimer(wxDialUpManagerImpl *dupman)
|
||||
{
|
||||
m_dupman = dupman;
|
||||
m_started = FALSE;
|
||||
}
|
||||
|
||||
virtual bool Start( int millisecs = -1 )
|
||||
{ m_started = TRUE; return wxTimer::Start(millisecs, FALSE); }
|
||||
|
||||
virtual void Notify()
|
||||
{ wxLogTrace("Checking dial up network status."); m_dupman->CheckStatus(); }
|
||||
|
||||
virtual void Stop()
|
||||
{ if ( m_started ) wxTimer::Stop(); }
|
||||
public:
|
||||
bool m_started;
|
||||
wxDialUpManagerImpl *m_dupman;
|
||||
};
|
||||
|
||||
bool
|
||||
wxDialUpManagerImpl::Dial(const wxString &isp,
|
||||
const wxString & WXUNUSED(username),
|
||||
const wxString & WXUNUSED(password))
|
||||
{
|
||||
if(m_IsOnline == 1)
|
||||
return FALSE;
|
||||
m_IsOnline = -1;
|
||||
m_ISPname = isp;
|
||||
wxString cmd;
|
||||
if(m_ConnectCommand.Find("%s"))
|
||||
cmd.Printf(m_ConnectCommand,m_ISPname.c_str());
|
||||
else
|
||||
cmd = m_ConnectCommand;
|
||||
return wxExecute(cmd, /* sync */ TRUE) == 0;
|
||||
}
|
||||
|
||||
bool
|
||||
wxDialUpManagerImpl::HangUp(void)
|
||||
{
|
||||
if(m_IsOnline == 0)
|
||||
return FALSE;
|
||||
m_IsOnline = -1;
|
||||
wxString cmd;
|
||||
if(m_HangUpCommand.Find("%s"))
|
||||
cmd.Printf(m_HangUpCommand,m_ISPname.c_str());
|
||||
else
|
||||
cmd = m_HangUpCommand;
|
||||
return wxExecute(cmd, /* sync */ TRUE) == 0;
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
wxDialUpManagerImpl::EnableAutoCheckOnlineStatus(size_t nSeconds)
|
||||
{
|
||||
wxASSERT(m_timer == NULL);
|
||||
m_timer = new AutoCheckTimer(this);
|
||||
bool rc = m_timer->Start(nSeconds*1000);
|
||||
if(! rc)
|
||||
{
|
||||
delete m_timer;
|
||||
m_timer = NULL;
|
||||
}
|
||||
return rc;
|
||||
}
|
||||
|
||||
void
|
||||
wxDialUpManagerImpl::DisableAutoCheckOnlineStatus()
|
||||
{
|
||||
wxASSERT(m_timer != NULL);
|
||||
m_timer->Stop();
|
||||
delete m_timer;
|
||||
m_timer = NULL;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
wxDialUpManagerImpl::SetWellKnownHost(const wxString& hostname, int portno)
|
||||
{
|
||||
/// does hostname contain a port number?
|
||||
wxString port = hostname.After(':');
|
||||
if(port.Length())
|
||||
{
|
||||
m_BeaconHost = hostname.Before(':');
|
||||
m_BeaconPort = atoi(port);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_BeaconHost = hostname;
|
||||
m_BeaconPort = portno;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
wxDialUpManagerImpl::CheckStatus(void) const
|
||||
{
|
||||
// This function calls the CheckStatusInternal() helper function
|
||||
// which is OS - specific and then sends the events.
|
||||
|
||||
int oldIsOnline = m_IsOnline;
|
||||
( /* non-const */ (wxDialUpManagerImpl *)this)->CheckStatusInternal();
|
||||
|
||||
// now send the events as appropriate:
|
||||
if(m_IsOnline != oldIsOnline)
|
||||
{
|
||||
if(m_IsOnline)
|
||||
; // send ev
|
||||
else
|
||||
; // send ev
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
We have three methods that we can use:
|
||||
|
||||
1. test via /sbin/ifconfig and grep for "sl", "ppp", "pl"
|
||||
--> should be fast enough for regular polling
|
||||
2. test if we can reach the well known beacon host
|
||||
--> too slow for polling
|
||||
3. check /proc/net/dev on linux??
|
||||
This method should be preferred, if possible. Need to do more
|
||||
testing.
|
||||
|
||||
*/
|
||||
|
||||
void
|
||||
wxDialUpManagerImpl::CheckStatusInternal(void)
|
||||
{
|
||||
m_IsOnline = -1;
|
||||
|
||||
// First time check for ifconfig location. We only use the variant
|
||||
// which does not take arguments, a la GNU.
|
||||
if(m_CanUseIfconfig == -1) // unknown
|
||||
{
|
||||
if(wxFileExists("/sbin/ifconfig"))
|
||||
m_IfconfigPath = "/sbin/ifconfig";
|
||||
else if(wxFileExists("/usr/sbin/ifconfig"))
|
||||
m_IfconfigPath = "/usr/sbin/ifconfig";
|
||||
}
|
||||
|
||||
wxLogNull ln; // suppress all error messages
|
||||
// Let<65>s try the ifconfig method first, should be fastest:
|
||||
if(m_CanUseIfconfig != 0) // unknown or yes
|
||||
{
|
||||
wxASSERT(m_IfconfigPath.length());
|
||||
|
||||
wxString tmpfile = wxGetTempFileName("_wxdialuptest");
|
||||
wxString cmd = "/bin/sh -c \'";
|
||||
cmd << m_IfconfigPath << " >" << tmpfile << '\'';
|
||||
/* I tried to add an option to wxExecute() to not close stdout,
|
||||
so we could let ifconfig write directly to the tmpfile, but
|
||||
this does not work. That should be faster, as it doesn<73>t call
|
||||
the shell first. I have no idea why. :-( (KB) */
|
||||
#if 0
|
||||
// temporarily redirect stdout/stderr:
|
||||
int
|
||||
new_stdout = dup(STDOUT_FILENO),
|
||||
new_stderr = dup(STDERR_FILENO);
|
||||
close(STDOUT_FILENO);
|
||||
close(STDERR_FILENO);
|
||||
|
||||
int
|
||||
// new stdout:
|
||||
output_fd = open(tmpfile, O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR),
|
||||
// new stderr:
|
||||
null_fd = open("/dev/null", O_CREAT, S_IRUSR|S_IWUSR);
|
||||
// verify well behaved unix behaviour:
|
||||
wxASSERT(output_fd == STDOUT_FILENO);
|
||||
wxASSERT(null_fd == STDERR_FILENO);
|
||||
int rc = wxExecute(m_IfconfigPath,TRUE /* sync */,NULL ,wxEXECUTE_DONT_CLOSE_FDS);
|
||||
close(null_fd); close(output_fd);
|
||||
// restore old stdout, stderr:
|
||||
int test;
|
||||
test = dup(new_stdout); close(new_stdout); wxASSERT(test == STDOUT_FILENO);
|
||||
test = dup(new_stderr); close(new_stderr); wxASSERT(test == STDERR_FILENO);
|
||||
if(rc == 0)
|
||||
#endif
|
||||
if(wxExecute(cmd,TRUE /* sync */) == 0)
|
||||
{
|
||||
m_CanUseIfconfig = 1;
|
||||
wxFile file;
|
||||
if( file.Open(tmpfile) )
|
||||
{
|
||||
char *output = new char [file.Length()+1];
|
||||
output[file.Length()] = '\0';
|
||||
if(file.Read(output,file.Length()) == file.Length())
|
||||
{
|
||||
if(strstr(output,"ppp") // ppp
|
||||
|| strstr(output,"sl") // slip
|
||||
|| strstr(output,"pl") // plip
|
||||
)
|
||||
m_IsOnline = 1;
|
||||
else
|
||||
m_IsOnline = 0;
|
||||
}
|
||||
file.Close();
|
||||
delete [] output;
|
||||
}
|
||||
// else m_IsOnline remains -1 as we don't know for sure
|
||||
}
|
||||
else // could not run ifconfig correctly
|
||||
m_CanUseIfconfig = 0; // don<6F>t try again
|
||||
(void) wxRemoveFile(tmpfile);
|
||||
if(m_IsOnline != -1) // we are done
|
||||
return;
|
||||
}
|
||||
|
||||
// second method: try to connect to well known host:
|
||||
// This can be used under Win 9x, too!
|
||||
struct hostent *hp;
|
||||
struct sockaddr_in serv_addr;
|
||||
int sockfd;
|
||||
|
||||
m_IsOnline = 0; // assume false
|
||||
if((hp = gethostbyname(m_BeaconHost)) == NULL)
|
||||
return; // no DNS no net
|
||||
|
||||
serv_addr.sin_family = hp->h_addrtype;
|
||||
memcpy(&serv_addr.sin_addr,hp->h_addr, hp->h_length);
|
||||
serv_addr.sin_port = htons(m_BeaconPort);
|
||||
if( ( sockfd = socket(hp->h_addrtype, SOCK_STREAM, 0)) < 0)
|
||||
{
|
||||
// sys_error("cannot create socket for gw");
|
||||
return;
|
||||
}
|
||||
if( connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
|
||||
{
|
||||
//sys_error("cannot connect to server");
|
||||
return;
|
||||
}
|
||||
//connected!
|
||||
close(sockfd);
|
||||
}
|
||||
|
||||
|
||||
/* static */
|
||||
wxDialUpManager *
|
||||
wxDialUpManager::wxDialUpManager::Create(void)
|
||||
{
|
||||
return new wxDialUpManagerImpl;
|
||||
}
|
||||
|
||||
#endif // wxUSE_DIALUP_MANAGER
|
||||
@@ -1,339 +0,0 @@
|
||||
#----------------------------------------------------------------------------
|
||||
# Name: makefile.nt
|
||||
# Purpose: Win32, VC++ 5 makefile for wxPython
|
||||
#
|
||||
# Author: Robin Dunn
|
||||
#
|
||||
# Created: 3/27/97
|
||||
# RCS-ID: $Id$
|
||||
# Copyright: (c) 1998 by Total Control Software
|
||||
# Licence: wxWindows license
|
||||
#----------------------------------------------------------------------------
|
||||
VERSION=0.5.4
|
||||
|
||||
# Set WXDIR to the root wxWindows directory for your system
|
||||
WXDIR = $(WXWIN)
|
||||
|
||||
# Set this to the root of the Python installation
|
||||
PYTHONDIR=d:\Python
|
||||
|
||||
# Set this to 1 for a non-debug, optimised compile
|
||||
FINAL=0
|
||||
|
||||
# Set this to where you want the stuff installed at. It should
|
||||
# be a directory contained in a PYTHONPATH directory, and should be
|
||||
# named wxPython
|
||||
TARGETDIR=..
|
||||
|
||||
# Set this to 1 for make to pre-compile the Python modules, 0 to
|
||||
# just copy the sources and let Python compile them at the first
|
||||
# runtime.
|
||||
COMPILEPY=0
|
||||
|
||||
SEPARATE=0
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
WXUSINGDLL=0
|
||||
NOPCH=1
|
||||
THISDIR=$(WXDIR)\utils\wxPython
|
||||
|
||||
EXTRALIBS=$(PYTHONDIR)\libs\python15.lib
|
||||
EXTRAINC=-I$(PYTHONDIR)\include -I.
|
||||
EXTRAFLAGS=/Fpwxp.pch /YXhelpers.h -DSWIG_GLOBAL -DHAVE_CONFIG_H
|
||||
OVERRIDEFLAGS=/GX-
|
||||
|
||||
|
||||
SWIGFLAGS=-c++ -shadow -python -dnone -D__WXMSW__
|
||||
GENCODEDIR=msw
|
||||
|
||||
|
||||
!include $(WXDIR)\src\ntwxwin.mak
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
TARGET = wxc
|
||||
|
||||
OBJECTS = wx.obj helpers.obj windows.obj events.obj \
|
||||
misc.obj gdi.obj mdi.obj controls.obj \
|
||||
controls2.obj windows2.obj cmndlgs.obj stattool.obj \
|
||||
frames.obj windows3.obj \
|
||||
!if "$(SEPARATE)" == "0"
|
||||
utils.obj
|
||||
!else
|
||||
|
||||
TARGET2 = utilsc
|
||||
OBJECTS2 = utils.obj
|
||||
target2=$(TARGETDIR)\$(TARGET2).pyd
|
||||
!endif
|
||||
|
||||
PYMODULES = $(TARGETDIR)\wx.py $(TARGETDIR)\events.py \
|
||||
$(TARGETDIR)\windows.py $(TARGETDIR)\misc.py \
|
||||
$(TARGETDIR)\gdi.py $(TARGETDIR)\mdi.py \
|
||||
$(TARGETDIR)\controls.py $(TARGETDIR)\controls2.py \
|
||||
$(TARGETDIR)\windows2.py $(TARGETDIR)\cmndlgs.py \
|
||||
$(TARGETDIR)\stattool.py $(TARGETDIR)\frames.py \
|
||||
$(TARGETDIR)\utils.py $(TARGETDIR)\windows3.py \
|
||||
$(TARGETDIR)\__init__.py
|
||||
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
!if "$(FINAL)" == "0"
|
||||
DEBUGLFLAGS = /DEBUG /INCREMENTAL:YES
|
||||
!else
|
||||
DEBUGLFLAGS = /INCREMENTAL:NO
|
||||
!endif
|
||||
|
||||
LFLAGS= $(DEBUGLFLAGS) /DLL /def:$(TARGET).def /subsystem:windows,3.50 \
|
||||
/machine:I386 /implib:./$(TARGET).lib /nologo
|
||||
|
||||
LFLAGS2=$(DEBUGLFLAGS) /DLL /def:$(TARGET2).def /subsystem:windows,3.50 \
|
||||
/machine:I386 /implib:./$(TARGET2).lib /nologo
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
default: $(TARGETDIR)\$(TARGET).pyd $(target2) pycfiles
|
||||
|
||||
all: wx $(TARGET) $(TARGET2)
|
||||
|
||||
wx:
|
||||
cd $(WXDIR)\src\msw
|
||||
nmake -f makefile.nt FINAL=$(FINAL)
|
||||
cd $(THISDIR)
|
||||
|
||||
wxclean:
|
||||
cd $(WXDIR)\src\msw
|
||||
nmake -f makefile.nt clean
|
||||
cd $(THISDIR)
|
||||
|
||||
|
||||
pycfiles : $(PYMODULES)
|
||||
!if "$(COMPILEPY)" == "1"
|
||||
$(PYTHONDIR)\python $(PYTHONDIR)\Lib\compileall.py -l $(TARGETDIR)
|
||||
$(PYTHONDIR)\python -O $(PYTHONDIR)\Lib\compileall.py -l $(TARGETDIR)
|
||||
!endif
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
$(TARGETDIR)\$(TARGET).pyd : $(DUMMYOBJ) $(WXLIB) $(OBJECTS) $(TARGET).res
|
||||
$(link) @<<
|
||||
/out:$@ /dll
|
||||
$(LFLAGS)
|
||||
$(DUMMYOBJ) $(OBJECTS) $(TARGET).res
|
||||
$(LIBS)
|
||||
<<
|
||||
|
||||
$(TARGETDIR)\$(TARGET2).pyd : $(DUMMYOBJ) $(WXLIB) $(OBJECTS2)
|
||||
$(link) @<<
|
||||
/out:$@ /dll
|
||||
$(LFLAGS2)
|
||||
$(DUMMYOBJ) $(OBJECTS2)
|
||||
$(LIBS)
|
||||
<<
|
||||
|
||||
|
||||
$(TARGET).res : $(TARGET).rc $(WXDIR)\include\wx\msw\wx.rc
|
||||
$(rc) -r /i$(WXDIR)\include -fo$@ $(TARGET).rc
|
||||
|
||||
|
||||
|
||||
# implicit rule for compiling .cpp files
|
||||
{}.cpp{}.obj:
|
||||
$(cc) @<<
|
||||
$(CPPFLAGS) /c /Tp $<
|
||||
<<
|
||||
|
||||
{$(GENCODEDIR)}.cpp{}.obj:
|
||||
$(cc) @<<
|
||||
$(CPPFLAGS) /c /Tp $<
|
||||
<<
|
||||
|
||||
|
||||
clean:
|
||||
-erase *.obj
|
||||
-erase *.exe
|
||||
-erase *.res
|
||||
-erase *.map
|
||||
-erase *.sbr
|
||||
-erase *.pdb
|
||||
-erase *.pch
|
||||
-erase $(TARGET).exp
|
||||
-erase $(TARGET).lib
|
||||
-erase $(TARGETDIR)\$(TARGET).*
|
||||
!if "$(SEPARATE)" != "0"
|
||||
-erase $(TARGET2).exp
|
||||
-erase $(TARGET2).lib
|
||||
-erase $(TARGETDIR)\$(TARGET2).*
|
||||
!endif
|
||||
-erase $(TARGETDIR)\$(TARGET).pyd
|
||||
-erase $(TARGETDIR)\*.py
|
||||
-erase $(TARGETDIR)\*.pyc
|
||||
-erase $(TARGETDIR)\*.pyo
|
||||
|
||||
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
|
||||
.SUFFIXES : .i .py
|
||||
|
||||
# Implicit rules to run SWIG
|
||||
{}.i{$(GENCODEDIR)}.cpp:
|
||||
swig $(SWIGFLAGS) -c -o $@ $<
|
||||
|
||||
{}.i{$(GENCODEDIR)}.py:
|
||||
swig $(SWIGFLAGS) -c -o $@ $<
|
||||
|
||||
|
||||
{$(GENCODEDIR)}.py{$(TARGETDIR)}.py:
|
||||
copy $< $@
|
||||
|
||||
{}.py{$(TARGETDIR)}.py:
|
||||
copy $< $@
|
||||
|
||||
#{}.py{$(TARGETDIR)}.$(PYEXT):
|
||||
# $(PYTHON) -c "import py_compile; py_compile.compile('$<', '$@')"
|
||||
|
||||
|
||||
|
||||
|
||||
# This one must leave out the -c flag so we define the whole rule
|
||||
$(GENCODEDIR)\wx.cpp $(GENCODEDIR)\wx.py : wx.i my_typemaps.i _defs.i _extras.py
|
||||
swig $(SWIGFLAGS) -o $(GENCODEDIR)/wx.cpp wx.i
|
||||
|
||||
|
||||
# Define some dependencies. These MUST use forward slashes so SWIG
|
||||
# will write the shadow file to the right directory.
|
||||
$(GENCODEDIR)/windows.cpp $(GENCODEDIR)/windows.py : windows.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/windows2.cpp $(GENCODEDIR)/windows2.py : windows2.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/windows3.cpp $(GENCODEDIR)/windows3.py : windows3.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/events.cpp $(GENCODEDIR)/events.py : events.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/misc.cpp $(GENCODEDIR)/misc.py : misc.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/gdi.cpp $(GENCODEDIR)/gdi.py : gdi.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/mdi.cpp $(GENCODEDIR)/mdi.py : mdi.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/controls.cpp $(GENCODEDIR)/controls.py : controls.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/controls2.cpp $(GENCODEDIR)/controls2.py : controls2.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/cmndlgs.cpp $(GENCODEDIR)/cmndlgs.py : cmndlgs.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/stattool.cpp $(GENCODEDIR)/stattool.py : stattool.i my_typemaps.i _defs.i
|
||||
$(GENCODEDIR)/frames.cpp $(GENCODEDIR)/frames.py : frames.i my_typemaps.i _defs.i
|
||||
|
||||
!if "$(SEPARATE)" == "1"
|
||||
$(GENCODEDIR)\utils.cpp $(GENCODEDIR)\utils.py : utils.i my_typemaps.i
|
||||
swig $(SWIGFLAGS) -o $(GENCODEDIR)/utils.cpp utils.i
|
||||
!else
|
||||
$(GENCODEDIR)/utils.cpp $(GENCODEDIR)/utils.py : utils.i my_typemaps.i _defs.i
|
||||
!endif
|
||||
|
||||
|
||||
$(TARGETDIR)\wx.py : $(GENCODEDIR)\wx.py
|
||||
$(TARGETDIR)\windows.py : $(GENCODEDIR)\windows.py
|
||||
$(TARGETDIR)\windows2.py : $(GENCODEDIR)\windows2.py
|
||||
$(TARGETDIR)\windows3.py : $(GENCODEDIR)\windows3.py
|
||||
$(TARGETDIR)\events.py : $(GENCODEDIR)\events.py
|
||||
$(TARGETDIR)\misc.py : $(GENCODEDIR)\misc.py
|
||||
$(TARGETDIR)\gdi.py : $(GENCODEDIR)\gdi.py
|
||||
$(TARGETDIR)\mdi.py : $(GENCODEDIR)\mdi.py
|
||||
$(TARGETDIR)\controls.py : $(GENCODEDIR)\controls.py
|
||||
$(TARGETDIR)\controls2.py : $(GENCODEDIR)\controls2.py
|
||||
$(TARGETDIR)\cmndlgs.py : $(GENCODEDIR)\cmndlgs.py
|
||||
$(TARGETDIR)\frames.py : $(GENCODEDIR)\frames.py
|
||||
$(TARGETDIR)\stattool.py : $(GENCODEDIR)\stattool.py
|
||||
$(TARGETDIR)\utils.py : $(GENCODEDIR)\utils.py
|
||||
$(TARGETDIR)\__init__.py : __init__.py
|
||||
|
||||
|
||||
SOURCES = $(GENCODEDIR)\wx.cpp $(GENCODEDIR)\wx.py \
|
||||
$(GENCODEDIR)/windows.cpp $(GENCODEDIR)/windows.py \
|
||||
$(GENCODEDIR)/windows2.cpp $(GENCODEDIR)/windows2.py \
|
||||
$(GENCODEDIR)/windows3.cpp $(GENCODEDIR)/windows3.py \
|
||||
$(GENCODEDIR)/events.cpp $(GENCODEDIR)/events.py \
|
||||
$(GENCODEDIR)/misc.cpp $(GENCODEDIR)/misc.py \
|
||||
$(GENCODEDIR)/gdi.cpp $(GENCODEDIR)/gdi.py \
|
||||
$(GENCODEDIR)/mdi.cpp $(GENCODEDIR)/mdi.py \
|
||||
$(GENCODEDIR)/controls.cpp $(GENCODEDIR)/controls.py \
|
||||
$(GENCODEDIR)/controls2.cpp $(GENCODEDIR)/controls2.py\
|
||||
$(GENCODEDIR)/cmndlgs.cpp $(GENCODEDIR)/cmndlgs.py \
|
||||
$(GENCODEDIR)/stattool.cpp $(GENCODEDIR)/stattool.py \
|
||||
$(GENCODEDIR)/frames.cpp $(GENCODEDIR)/frames.py \
|
||||
$(GENCODEDIR)/utils.cpp $(GENCODEDIR)/utils.py \
|
||||
|
||||
|
||||
sources : $(SOURCES)
|
||||
|
||||
|
||||
dist:
|
||||
cd ..\..
|
||||
wxPython\distrib\zipit.bat $(VERSION)
|
||||
|
||||
#------------------------------------------------------------------------
|
||||
#
|
||||
# $Log$
|
||||
# Revision 1.12 1999/06/28 21:39:47 VZ
|
||||
# 1. wxStaticLine implemented (generic (ugly) and MSW versions)
|
||||
# 2. wxTextDialog looks fine under MSW again
|
||||
# 3. startup tips added: code, sample, docs
|
||||
# 4. read-only text controls don't participate in TAB traversal
|
||||
#
|
||||
# Revision 1.11 1999/02/06 23:47:02 RD
|
||||
#
|
||||
# Changing makefile.nt to makefile.vc as in rest of wxWindows
|
||||
#
|
||||
# Revision 1.10 1999/02/01 00:10:40 RD
|
||||
#
|
||||
# Added the missing EVT_LIST_ITEM_SELECTED and friends.
|
||||
#
|
||||
# Revision 1.9 1999/01/30 07:30:13 RD
|
||||
#
|
||||
# Added wxSashWindow, wxSashEvent, wxLayoutAlgorithm, etc.
|
||||
#
|
||||
# Various cleanup, tweaks, minor additions, etc. to maintain
|
||||
# compatibility with the current wxWindows.
|
||||
#
|
||||
# Revision 1.8 1998/12/21 19:58:06 RD
|
||||
#
|
||||
# Now compiles with /GX- on MSW.
|
||||
#
|
||||
# Revision 1.7 1998/12/15 20:41:20 RD
|
||||
# Changed the import semantics from "from wxPython import *" to "from
|
||||
# wxPython.wx import *" This is for people who are worried about
|
||||
# namespace pollution, they can use "from wxPython import wx" and then
|
||||
# prefix all the wxPython identifiers with "wx."
|
||||
#
|
||||
# Added wxTaskbarIcon for wxMSW.
|
||||
#
|
||||
# Made the events work for wxGrid.
|
||||
#
|
||||
# Added wxConfig.
|
||||
#
|
||||
# Added wxMiniFrame for wxGTK, (untested.)
|
||||
#
|
||||
# Changed many of the args and return values that were pointers to gdi
|
||||
# objects to references to reflect changes in the wxWindows API.
|
||||
#
|
||||
# Other assorted fixes and additions.
|
||||
#
|
||||
# Revision 1.6 1998/10/02 06:40:41 RD
|
||||
#
|
||||
# Version 0.4 of wxPython for MSW.
|
||||
#
|
||||
# Revision 1.5 1998/08/19 00:38:23 RD
|
||||
#
|
||||
# A few tweaks
|
||||
#
|
||||
# Revision 1.4 1998/08/18 21:55:10 RD
|
||||
#
|
||||
# New build directory structure
|
||||
#
|
||||
# Revision 1.3 1998/08/15 07:36:37 RD
|
||||
# - Moved the header in the .i files out of the code that gets put into
|
||||
# the .cpp files. It caused CVS conflicts because of the RCS ID being
|
||||
# different each time.
|
||||
#
|
||||
# - A few minor fixes.
|
||||
#
|
||||
# Revision 1.2 1998/08/14 03:34:23 RD
|
||||
# made pre-compiling the python files optional
|
||||
#
|
||||
# Revision 1.1 1998/08/09 08:25:51 RD
|
||||
# Initial version
|
||||
#
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user