Compare commits
21 Commits
OLD_DATE_A
...
TCL_8_4_5
Author | SHA1 | Date | |
---|---|---|---|
|
fa4a6afa3c | ||
|
4891a37694 | ||
|
7b43e63a7b | ||
|
4f4987da94 | ||
|
b174bc9ec6 | ||
|
b80c893495 | ||
|
efda8edb48 | ||
|
5493918356 | ||
|
9c0d89b17b | ||
|
9505c96c85 | ||
|
b52f47092c | ||
|
269149e603 | ||
|
9e0b898ade | ||
|
bcdf529fe2 | ||
|
a6c3a78d25 | ||
|
9bd536df18 | ||
|
2e792cdea3 | ||
|
376c9a9ab8 | ||
|
671adc5087 | ||
|
d8709b9458 | ||
|
9181b01d13 |
@@ -1,146 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: date.h
|
||||
// Purpose: wxDate class
|
||||
// Author: Julian Smart, Steve Marcus, Eric Simon, Chris Hill,
|
||||
// Charles D. Price
|
||||
// Modified by:
|
||||
// Created: 01/02/97
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c)
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_DATE_H_
|
||||
#define _WX_DATE_H_
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "date.h"
|
||||
#endif
|
||||
|
||||
#include "wx/object.h"
|
||||
#include "wx/string.h"
|
||||
|
||||
#if wxUSE_TIMEDATE
|
||||
// These lines necessary to stop VC++ 6 being confused about namespaces
|
||||
class WXDLLEXPORT wxDate;
|
||||
bool WXDLLEXPORT operator<(const wxDate &dt1, const wxDate &dt2);
|
||||
bool WXDLLEXPORT operator<(const wxDate &dt1, const wxDate &dt2);
|
||||
bool WXDLLEXPORT operator <= (const wxDate &dt1, const wxDate &dt2);
|
||||
bool WXDLLEXPORT operator > (const wxDate &dt1, const wxDate &dt2);
|
||||
bool WXDLLEXPORT operator >= (const wxDate &dt1, const wxDate &dt2);
|
||||
bool WXDLLEXPORT operator == (const wxDate &dt1, const wxDate &dt2);
|
||||
bool WXDLLEXPORT operator != (const wxDate &dt1, const wxDate &dt2);
|
||||
|
||||
enum wxdate_format_type {wxMDY, wxDAY, wxMONTH, wxFULL, wxEUROPEAN};
|
||||
|
||||
#define wxNO_CENTURY 0x02
|
||||
#define wxDATE_ABBR 0x04
|
||||
|
||||
class WXDLLEXPORT wxDate : public wxObject
|
||||
{
|
||||
DECLARE_DYNAMIC_CLASS(wxDate)
|
||||
|
||||
protected:
|
||||
unsigned long julian; // see julDate(); days since 1/1/4713 B.C.
|
||||
int month; // see NMonth()
|
||||
int day; // see Day()
|
||||
int year; // see NYear4()
|
||||
int day_of_week; // see NDOW(); 1 = Sunday, ... 7 = Saturday
|
||||
|
||||
private:
|
||||
int DisplayFormat;
|
||||
unsigned char DisplayOptions;
|
||||
|
||||
void julian_to_mdy (); // convert julian day to mdy
|
||||
void julian_to_wday (); // convert julian day to day_of_week
|
||||
void mdy_to_julian (); // convert mdy to julian day
|
||||
|
||||
public:
|
||||
wxDate ();
|
||||
wxDate (long j);
|
||||
wxDate (int m, int d, int y);
|
||||
wxDate (const wxString& dat);
|
||||
wxDate (const wxDate &dt);
|
||||
|
||||
#ifndef __SALFORDC__
|
||||
operator wxString (void);
|
||||
#endif
|
||||
|
||||
void operator = (const wxDate& date);
|
||||
void operator = (const wxString& date);
|
||||
|
||||
wxDate operator + (long i);
|
||||
wxDate operator + (int i);
|
||||
|
||||
wxDate operator - (long i);
|
||||
wxDate operator - (int i);
|
||||
|
||||
long operator - (const wxDate &dt);
|
||||
|
||||
wxDate &operator += (long i);
|
||||
wxDate &operator -= (long i);
|
||||
|
||||
wxDate &operator ++ (); // Prefix increment
|
||||
wxDate &operator ++ (int); // Postfix increment
|
||||
wxDate &operator -- (); // Prefix decrement
|
||||
wxDate &operator -- (int); // Postfix decrement
|
||||
|
||||
friend bool WXDLLEXPORT operator < (const wxDate &dt1, const wxDate &dt2);
|
||||
friend bool WXDLLEXPORT operator <= (const wxDate &dt1, const wxDate &dt2);
|
||||
friend bool WXDLLEXPORT operator > (const wxDate &dt1, const wxDate &dt2);
|
||||
friend bool WXDLLEXPORT operator >= (const wxDate &dt1, const wxDate &dt2);
|
||||
friend bool WXDLLEXPORT operator == (const wxDate &dt1, const wxDate &dt2);
|
||||
friend bool WXDLLEXPORT operator != (const wxDate &dt1, const wxDate &dt2);
|
||||
|
||||
#if wxUSE_STD_IOSTREAM
|
||||
friend ostream WXDLLEXPORT & operator << (ostream &os, const wxDate &dt);
|
||||
#endif
|
||||
|
||||
wxString FormatDate (int type=-1) const;
|
||||
void SetFormat (int format);
|
||||
int SetOption (int option, bool enable=TRUE);
|
||||
|
||||
long GetJulianDate() const; // returns julian date
|
||||
int GetDayOfYear() const; // returns relative date since Jan. 1
|
||||
bool IsLeapYear() const; // returns TRUE if leap year, FALSE if not
|
||||
|
||||
// Version 4.0 Extension to Public Interface - CDP
|
||||
|
||||
// These 'Set's modify the date object and actually SET it
|
||||
// They all return a reference to self (*this)
|
||||
|
||||
wxDate &Set(); // Sets to current system date
|
||||
wxDate &Set(long lJulian);
|
||||
wxDate &Set(int nMonth, int nDay, int nYear);
|
||||
|
||||
wxDate &AddWeeks(int nCount = 1); //
|
||||
wxDate &AddMonths(int nCount = 1); // May also pass neg# to decrement
|
||||
wxDate &AddYears(int nCount = 1); //
|
||||
|
||||
int GetDay() const; // Numeric Day of date object
|
||||
int GetDaysInMonth(); // Number of days in month (1..31)
|
||||
int GetFirstDayOfMonth() const; // First Day Of Month (1..7)
|
||||
|
||||
wxString GetDayOfWeekName(); // Character Day Of Week ('Sunday'..'Saturday')
|
||||
int GetDayOfWeek() const; // (1..7)
|
||||
|
||||
int GetWeekOfMonth(); // Numeric Week Of Month (1..6)
|
||||
int GetWeekOfYear(); // Numeric Week Of Year (1..52)
|
||||
|
||||
wxString GetMonthName(); // Character Month name
|
||||
int GetMonth() const; // Month Number (1..12)
|
||||
wxDate GetMonthStart(); // First Date Of Month
|
||||
wxDate GetMonthEnd(); // Last Date Of Month
|
||||
|
||||
int GetYear() const; // eg. 1992
|
||||
wxDate GetYearStart(); // First Date Of Year
|
||||
wxDate GetYearEnd(); // Last Date Of Year
|
||||
|
||||
bool IsBetween(const wxDate& first, const wxDate& second) const;
|
||||
|
||||
wxDate Previous(int dayOfWeek) const;
|
||||
};
|
||||
|
||||
#endif // wxUSE_TIMEDATE
|
||||
#endif
|
||||
// _WX_DATE_H_
|
@@ -1,112 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: time.h
|
||||
// Purpose: wxTime class, from NIHCL
|
||||
// Author: Julian Smart, after K. E. Gorlen
|
||||
// Modified by:
|
||||
// Created: 01/02/97
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Julian Smart and Markus Holzem
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef _WX_TIMEH__
|
||||
#define _WX_TIMEH__
|
||||
|
||||
#include "wx/object.h"
|
||||
|
||||
#if wxUSE_TIMEDATE
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "time.h"
|
||||
#endif
|
||||
|
||||
class WXDLLEXPORT wxDate;
|
||||
|
||||
typedef unsigned short hourTy;
|
||||
typedef unsigned short minuteTy;
|
||||
typedef unsigned short secondTy;
|
||||
typedef unsigned long clockTy;
|
||||
|
||||
class WXDLLEXPORT wxTime: public wxObject
|
||||
{
|
||||
DECLARE_DYNAMIC_CLASS(wxTime)
|
||||
|
||||
public: // type definitions
|
||||
enum tFormat { wx12h, wx24h };
|
||||
enum tPrecision { wxStdMinSec, wxStdMin };
|
||||
private:
|
||||
static tFormat Format;
|
||||
static tPrecision Precision;
|
||||
|
||||
clockTy sec; /* seconds since 1/1/1901 */
|
||||
|
||||
bool IsDST() const;
|
||||
wxTime GetLocalTime() const;
|
||||
private: // static member functions
|
||||
static wxTime GetLocalTime(const wxDate& date, hourTy h=0, minuteTy m=0, secondTy s=0);
|
||||
static wxTime GetBeginDST(unsigned year);
|
||||
static wxTime GetEndDST(unsigned year);
|
||||
public:
|
||||
wxTime(); // current time
|
||||
wxTime(clockTy s) { sec = s; }
|
||||
void operator=(const wxTime& t) { sec = t.sec; } // Ordering required for some compilers
|
||||
wxTime(const wxTime& t) { (*this) = t ; }
|
||||
wxTime(hourTy h, minuteTy m, secondTy s =0, bool dst =FALSE);
|
||||
wxTime(const wxDate&, hourTy h =0, minuteTy m =0, secondTy s=0, bool dst =FALSE);
|
||||
|
||||
// Convert to string
|
||||
#ifndef __SALFORDC__
|
||||
operator wxChar * (void);
|
||||
operator wxDate() const;
|
||||
#endif
|
||||
|
||||
bool operator<(const wxTime& t) const { return sec < t.sec; }
|
||||
bool operator<=(const wxTime& t) const { return sec <= t.sec; }
|
||||
bool operator>(const wxTime& t) const { return sec > t.sec; }
|
||||
bool operator>=(const wxTime& t) const { return sec >= t.sec; }
|
||||
bool operator==(const wxTime& t) const { return sec == t.sec; }
|
||||
bool operator!=(const wxTime& t) const { return sec != t.sec; }
|
||||
friend wxTime operator+(const wxTime& t, long s) { return wxTime(t.sec+s); }
|
||||
friend wxTime operator+(long s, const wxTime& t) { return wxTime(t.sec+s); }
|
||||
long operator-(const wxTime& t) const { return sec - t.sec; }
|
||||
wxTime operator-(long s) const { return wxTime(sec-s); }
|
||||
void operator+=(long s) { sec += s; }
|
||||
void operator-=(long s) { sec -= s; }
|
||||
bool IsBetween(const wxTime& a, const wxTime& b) const;
|
||||
|
||||
/// Get day
|
||||
int GetDay() const;
|
||||
/// Get month
|
||||
int GetMonth() const;
|
||||
/// Get year
|
||||
int GetYear() const;
|
||||
/// Get day of week (0=Sunday 6=Saturday)
|
||||
int GetDayOfWeek() const;
|
||||
|
||||
hourTy GetHour() const; // hour in local time
|
||||
hourTy GetHourGMT() const; // hour in GMT
|
||||
minuteTy GetMinute() const; // minute in local time
|
||||
minuteTy GetMinuteGMT() const; // minute in GMT
|
||||
secondTy GetSecond() const; // second in local time or GMT
|
||||
clockTy GetSeconds() const { return sec; }
|
||||
secondTy GetSecondGMT() const ;
|
||||
wxTime Max(const wxTime&) const;
|
||||
wxTime Min(const wxTime&) const;
|
||||
static void SetFormat(const tFormat lFormat = wx12h,
|
||||
const tPrecision lPrecision = wxStdMinSec);
|
||||
wxChar *FormatTime() const;
|
||||
/*
|
||||
virtual int compare(const Object&) const;
|
||||
virtual void deepenShallowCopy(); // {}
|
||||
virtual unsigned hash() const;
|
||||
virtual bool isEqual(const Object&) const;
|
||||
virtual void printOn(ostream& strm =cout) const;
|
||||
virtual const Class* species() const;
|
||||
*/
|
||||
};
|
||||
|
||||
#endif
|
||||
// wxUSE_TIMEDATE
|
||||
#endif
|
||||
// _WX_TIMEH__
|
||||
|
@@ -1,656 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: date.cpp
|
||||
// Purpose: wxDate class
|
||||
// Author:
|
||||
// Originally inspired by Steve Marcus (CIS 72007,1233) 6/16/91
|
||||
// Enhanced by Eric Simon (CIS 70540,1522) 6/29/91
|
||||
// Further Enhanced by Chris Hill (CIS 72030,2606) 7/11/91
|
||||
// Still Further Enhanced by Hill & Simon v3.10 8/05/91
|
||||
// Version 4 by Charles D. Price 6/27/92
|
||||
// Integrated into wxWindows by Julian Smart 9th July 1995
|
||||
// Modified by:
|
||||
// Created: 01/02/97
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Julian Smart and Markus Holzem
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation "date.h"
|
||||
#endif
|
||||
|
||||
// For compilers that support precompilation, includes "wx.h".
|
||||
#include "wx/wxprec.h"
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma hdrstop
|
||||
#endif
|
||||
|
||||
#if wxUSE_TIMEDATE
|
||||
|
||||
#include "wx/date.h"
|
||||
#include "wx/intl.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "wx/ioswrap.h"
|
||||
|
||||
#include <time.h>
|
||||
#include <string.h>
|
||||
|
||||
#define ABBR_LENGTH 3
|
||||
|
||||
static const wxChar *dayname[] = {
|
||||
wxT("Sunday"), wxT("Monday"), wxT("Tuesday"), wxT("Wednesday"),
|
||||
wxT("Thursday"), wxT("Friday"), wxT("Saturday")
|
||||
};
|
||||
|
||||
static const wxChar *mname[] = {
|
||||
wxT("January"), wxT("February"), wxT("March"), wxT("April"), wxT("May"), wxT("June"),
|
||||
wxT("July"), wxT("August"), wxT("September"), wxT("October"), wxT("November"), wxT("December")
|
||||
};
|
||||
|
||||
static int GauDays[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
|
||||
|
||||
IMPLEMENT_DYNAMIC_CLASS(wxDate, wxObject)
|
||||
|
||||
////////////////////////////////////////////////////////////
|
||||
// Constructors
|
||||
////////////////////////////////////////////////////////////
|
||||
|
||||
wxDate::wxDate()
|
||||
{
|
||||
DisplayFormat=wxMDY;
|
||||
DisplayOptions='\0';
|
||||
month = day = year = day_of_week = 0;
|
||||
julian = 0;
|
||||
}
|
||||
|
||||
wxDate::wxDate (long j) : julian(j)
|
||||
{
|
||||
DisplayFormat=wxMDY;
|
||||
DisplayOptions='\0';
|
||||
julian_to_mdy ();
|
||||
}
|
||||
|
||||
wxDate::wxDate (int m, int d, int y) : month(m), day(d), year(y)
|
||||
{
|
||||
DisplayFormat=wxMDY;
|
||||
DisplayOptions='\0';
|
||||
mdy_to_julian ();
|
||||
}
|
||||
|
||||
wxDate::wxDate (const wxString& dat)
|
||||
{
|
||||
DisplayFormat=wxMDY;
|
||||
DisplayOptions='\0';
|
||||
if (wxStrcmp(dat, wxT("TODAY")) == 0 || wxStrcmp(dat, wxT("today")) == 0)
|
||||
{
|
||||
// Sets the current date
|
||||
Set();
|
||||
}
|
||||
else
|
||||
{
|
||||
wxChar buf[100];
|
||||
wxStrcpy(buf, dat);
|
||||
|
||||
wxChar *save_ptr, *token = wxStrtok(buf,wxT("/-"),&save_ptr);
|
||||
month = wxAtoi(token);
|
||||
day = wxAtoi(wxStrtok((wxChar *) NULL,wxT("/-"),&save_ptr));
|
||||
year = wxAtoi(wxStrtok((wxChar *) NULL,wxT(" "),&save_ptr));
|
||||
}
|
||||
|
||||
mdy_to_julian ();
|
||||
}
|
||||
|
||||
wxDate::wxDate (const wxDate &dt)
|
||||
{
|
||||
DisplayFormat=dt.DisplayFormat;
|
||||
DisplayOptions=dt.DisplayOptions;
|
||||
month = dt.month;
|
||||
day = dt.day;
|
||||
year = dt.year;
|
||||
mdy_to_julian ();
|
||||
}
|
||||
|
||||
void wxDate::operator = (const wxDate &dt)
|
||||
{
|
||||
DisplayFormat=dt.DisplayFormat;
|
||||
DisplayOptions=dt.DisplayOptions;
|
||||
month = dt.month;
|
||||
day = dt.day;
|
||||
year = dt.year;
|
||||
mdy_to_julian (); // wxUSE_TIMEDATE
|
||||
}
|
||||
|
||||
void wxDate::operator = (const wxString& dat)
|
||||
{
|
||||
DisplayFormat=wxMDY;
|
||||
DisplayOptions='\0';
|
||||
if (wxStrcmp(dat, wxT("TODAY")) == 0 || wxStrcmp(dat, wxT("today")) == 0)
|
||||
{
|
||||
// Sets the current date
|
||||
Set();
|
||||
}
|
||||
else
|
||||
{
|
||||
wxChar buf[100];
|
||||
wxStrcpy(buf, dat);
|
||||
|
||||
wxChar *save_ptr, *token = wxStrtok(buf,wxT("/-"),&save_ptr);
|
||||
month = wxAtoi(token);
|
||||
day = wxAtoi(wxStrtok((wxChar *) NULL,wxT("/-"),&save_ptr));
|
||||
year = wxAtoi(wxStrtok((wxChar *) NULL,wxT(" "),&save_ptr));
|
||||
}
|
||||
|
||||
mdy_to_julian ();
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
// Conversion operations
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef __SALFORDC__
|
||||
wxDate::operator wxString( void )
|
||||
{
|
||||
return FormatDate();
|
||||
}
|
||||
#endif
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
// Date Arithmetic
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
wxDate wxDate::operator + (long i)
|
||||
{
|
||||
wxDate dp(julian + i);
|
||||
return dp;
|
||||
}
|
||||
|
||||
wxDate wxDate::operator + (int i)
|
||||
{
|
||||
wxDate dp(julian + (long)i);
|
||||
return dp;
|
||||
}
|
||||
|
||||
wxDate wxDate::operator - (long i)
|
||||
{
|
||||
wxDate dp(julian - i);
|
||||
return dp;
|
||||
}
|
||||
|
||||
wxDate wxDate::operator - (int i)
|
||||
{
|
||||
wxDate dp(julian - (long)i);
|
||||
return dp;
|
||||
}
|
||||
|
||||
long wxDate::operator - (const wxDate &dt)
|
||||
{
|
||||
return ( julian - dt.julian );
|
||||
}
|
||||
|
||||
wxDate &wxDate::operator += (long i)
|
||||
{
|
||||
julian += i;
|
||||
julian_to_mdy();
|
||||
return *this;
|
||||
}
|
||||
|
||||
wxDate &wxDate::operator -= (long i)
|
||||
{
|
||||
julian -= i;
|
||||
julian_to_mdy();
|
||||
return *this;
|
||||
}
|
||||
|
||||
wxDate &wxDate::operator ++()
|
||||
{
|
||||
julian++;
|
||||
julian_to_mdy();
|
||||
return *this;
|
||||
}
|
||||
|
||||
wxDate &wxDate::operator ++(int)
|
||||
{
|
||||
julian++;
|
||||
julian_to_mdy();
|
||||
return *this;
|
||||
}
|
||||
|
||||
wxDate &wxDate::operator --()
|
||||
{
|
||||
julian--;
|
||||
julian_to_mdy();
|
||||
return *this;
|
||||
}
|
||||
|
||||
wxDate &wxDate::operator --(int)
|
||||
{
|
||||
julian--;
|
||||
julian_to_mdy();
|
||||
return *this;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
// Date comparison
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
bool WXDLLEXPORT operator < (const wxDate &dt1, const wxDate &dt2)
|
||||
{
|
||||
return ( dt1.julian < dt2.julian );
|
||||
}
|
||||
|
||||
bool WXDLLEXPORT operator <= (const wxDate &dt1, const wxDate &dt2)
|
||||
{
|
||||
return ( (dt1.julian == dt2.julian) || (dt1.julian < dt2.julian) );
|
||||
}
|
||||
|
||||
bool WXDLLEXPORT operator > (const wxDate &dt1, const wxDate &dt2)
|
||||
{
|
||||
return ( dt1.julian > dt2.julian );
|
||||
}
|
||||
|
||||
bool WXDLLEXPORT operator >= (const wxDate &dt1, const wxDate &dt2)
|
||||
{
|
||||
return ( (dt1.julian == dt2.julian) || (dt1.julian > dt2.julian) );
|
||||
}
|
||||
|
||||
bool WXDLLEXPORT operator == (const wxDate &dt1, const wxDate &dt2)
|
||||
{
|
||||
return ( dt1.julian == dt2.julian );
|
||||
}
|
||||
|
||||
bool WXDLLEXPORT operator != (const wxDate &dt1, const wxDate &dt2)
|
||||
{
|
||||
return ( dt1.julian != dt2.julian );
|
||||
}
|
||||
|
||||
|
||||
#if wxUSE_STD_IOSTREAM
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
// Ostream operations
|
||||
////////////////////////////////////////////////////////////////
|
||||
|
||||
ostream WXDLLEXPORT & operator << (ostream &os, const wxDate &dt)
|
||||
{
|
||||
return os << dt.FormatDate().mb_str();
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
// Conversion routines
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
void wxDate::julian_to_wday (void)
|
||||
{
|
||||
// Correction by Peter Stadel <peters@jetcity.com>
|
||||
day_of_week = (int)((julian - 2) % 7L);
|
||||
/*
|
||||
day_of_week = (int) ((julian + 2) % 7 + 1);
|
||||
*/
|
||||
}
|
||||
|
||||
void wxDate::julian_to_mdy ()
|
||||
{
|
||||
long a,b,c,d,e,z,alpha;
|
||||
z = julian+1;
|
||||
// dealing with Gregorian calendar reform
|
||||
if (z < 2299161L)
|
||||
a = z;
|
||||
else {
|
||||
alpha = (long) ((z-1867216.25) / 36524.25);
|
||||
a = z + 1 + alpha - alpha/4;
|
||||
}
|
||||
b = ( a > 1721423 ? a + 1524 : a + 1158 );
|
||||
c = (long) ((b - 122.1) / 365.25);
|
||||
d = (long) (365.25 * c);
|
||||
e = (long) ((b - d) / 30.6001);
|
||||
day = (int)(b - d - (long)(30.6001 * e));
|
||||
month = (int)((e < 13.5) ? e - 1 : e - 13);
|
||||
year = (int)((month > 2.5 ) ? (c - 4716) : c - 4715);
|
||||
julian_to_wday ();
|
||||
}
|
||||
|
||||
void wxDate::mdy_to_julian (void)
|
||||
{
|
||||
int a,b=0;
|
||||
int work_month=month, work_day=day, work_year=year;
|
||||
// correct for negative year
|
||||
if (work_year < 0)
|
||||
work_year++;
|
||||
if (work_month <= 2)
|
||||
{ work_year--; work_month +=12; }
|
||||
|
||||
// deal with Gregorian calendar
|
||||
if (work_year*10000. + work_month*100. + work_day >= 15821015.)
|
||||
{
|
||||
a = (int)(work_year/100.);
|
||||
b = 2 - a + a/4;
|
||||
}
|
||||
julian = (long) (365.25*work_year) +
|
||||
(long) (30.6001 * (work_month+1)) + work_day + 1720994L + b;
|
||||
julian_to_wday ();
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
// Format routine
|
||||
////////////////////////////////////////////////////////////////
|
||||
|
||||
wxString wxDate::FormatDate (int type) const
|
||||
{
|
||||
int actualType = type;
|
||||
if (actualType == -1)
|
||||
actualType = DisplayFormat;
|
||||
|
||||
wxChar buf[40];
|
||||
|
||||
memset( buf, '\0', sizeof(buf) );
|
||||
switch ( actualType )
|
||||
{
|
||||
case wxDAY:
|
||||
if ( (day_of_week < 1) || (day_of_week > 7) )
|
||||
wxStrcpy(buf, _("invalid day"));
|
||||
else
|
||||
wxStrncpy( buf, wxGetTranslation(dayname[day_of_week-1]),
|
||||
(DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
|
||||
return wxString(buf);
|
||||
|
||||
case wxMONTH:
|
||||
if ( (month < 1) || (month > 12) )
|
||||
wxStrcpy(buf, _("invalid month"));
|
||||
else
|
||||
wxStrncpy( buf, wxGetTranslation(mname[month-1]),
|
||||
(DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
|
||||
return wxString(buf);
|
||||
|
||||
case wxFULL:
|
||||
if ( (month < 1) || (month > 12) || (day_of_week < 0) ||
|
||||
(day_of_week > 7) )
|
||||
{
|
||||
wxStrcpy(buf, _("invalid date"));
|
||||
return wxString(buf);
|
||||
}
|
||||
wxStrncpy( buf, wxGetTranslation(dayname[day_of_week-1]),
|
||||
(DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
|
||||
wxStrcat( buf, wxT(", "));
|
||||
wxStrncat( buf, wxGetTranslation(mname[month-1]),
|
||||
(DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
|
||||
wxStrcat( buf, wxT(" "));
|
||||
wxSprintf( buf+wxStrlen(buf), wxT("%d, %d"), day, abs(year) );
|
||||
if (year < 0)
|
||||
wxStrcat(buf,_(" B.C."));
|
||||
return wxString(buf);
|
||||
|
||||
case wxEUROPEAN:
|
||||
if ( (month < 1) || (month > 12) || (day_of_week < 0) ||
|
||||
(day_of_week > 7) )
|
||||
{
|
||||
wxStrcpy(buf, _("invalid date"));
|
||||
return wxString(buf);
|
||||
}
|
||||
wxSprintf(buf,wxT("%d "), day);
|
||||
wxStrncat(buf, wxGetTranslation(mname[month-1]),
|
||||
(DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
|
||||
wxSprintf( buf+wxStrlen(buf), wxT(" %d"), abs(year) );
|
||||
if (year < 0)
|
||||
wxStrcat(buf, _(" B.C."));
|
||||
return wxString(buf);
|
||||
|
||||
case wxMDY:
|
||||
default:
|
||||
if (day==0 || month==0 || year==0)
|
||||
wxStrcpy(buf, _("invalid date"));
|
||||
else
|
||||
wxSprintf( buf+wxStrlen(buf), wxT("%1d/%1d/%02d"), month, day,
|
||||
(DisplayOptions & wxNO_CENTURY) && (abs(year) > 1899)
|
||||
? (abs(year) - (abs(year) / 100 * 100))
|
||||
: (abs(year)) );
|
||||
return wxString(buf);
|
||||
}
|
||||
}
|
||||
|
||||
void wxDate::SetFormat( int format )
|
||||
{
|
||||
DisplayFormat = format;
|
||||
}
|
||||
|
||||
int wxDate::SetOption( int option, bool action )
|
||||
{
|
||||
switch ( option )
|
||||
{
|
||||
case wxNO_CENTURY:
|
||||
if ( action )
|
||||
DisplayOptions |= wxNO_CENTURY;
|
||||
else
|
||||
{
|
||||
DisplayOptions &= (~wxNO_CENTURY);
|
||||
}
|
||||
return 1;
|
||||
case wxDATE_ABBR:
|
||||
if ( action )
|
||||
DisplayOptions |= wxDATE_ABBR;
|
||||
else
|
||||
{
|
||||
DisplayOptions &= (~wxDATE_ABBR);
|
||||
}
|
||||
return 1;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////
|
||||
// Miscellaneous Routines
|
||||
///////////////////////////////////////////////////////////////
|
||||
|
||||
long wxDate::GetJulianDate( void ) const
|
||||
{
|
||||
return julian;
|
||||
}
|
||||
|
||||
int wxDate::GetDayOfYear( void ) const
|
||||
{
|
||||
wxDate temp( 1, 1, year );
|
||||
|
||||
return (int) (julian - temp.julian + 1);
|
||||
}
|
||||
|
||||
|
||||
bool wxDate::IsLeapYear( void ) const
|
||||
{
|
||||
return ( (year >= 1582) ?
|
||||
(year % 4 == 0 && year % 100 != 0 || year % 400 == 0 ):
|
||||
(year % 4 == 0) );
|
||||
}
|
||||
|
||||
// Version 4.0 Extension to Public Interface - CDP
|
||||
|
||||
wxDate& wxDate::Set()
|
||||
{
|
||||
//#ifdef __WXMSW__
|
||||
#if 0
|
||||
struct _dosdate_t sDate;
|
||||
_dos_getdate(&sDate);
|
||||
|
||||
month = sDate.month;
|
||||
day = sDate.day;
|
||||
year = sDate.year;
|
||||
|
||||
mdy_to_julian();
|
||||
#else
|
||||
time_t now = time((time_t *) NULL);
|
||||
struct tm *localTime = localtime(&now);
|
||||
|
||||
month = localTime->tm_mon + 1;
|
||||
day = localTime->tm_mday;
|
||||
year = localTime->tm_year + 1900;
|
||||
|
||||
mdy_to_julian ();
|
||||
#endif
|
||||
return *this;
|
||||
}
|
||||
|
||||
wxDate& wxDate::Set(
|
||||
int nMonth,
|
||||
int nDay,
|
||||
int nYear)
|
||||
{
|
||||
month = nMonth;
|
||||
year = nYear < 0 ? 9999 : nYear;
|
||||
year = nYear > 9999 ? 0 : nYear;
|
||||
day = nDay < GetDaysInMonth() ? nDay : GetDaysInMonth();
|
||||
|
||||
mdy_to_julian();
|
||||
return *this;
|
||||
}
|
||||
|
||||
wxDate &
|
||||
wxDate::Set(long j)
|
||||
{
|
||||
julian = j;
|
||||
|
||||
julian_to_mdy();
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
int wxDate::GetDaysInMonth()
|
||||
{
|
||||
return GauDays[month-1] + (month==2 && IsLeapYear());
|
||||
}
|
||||
|
||||
int wxDate::GetFirstDayOfMonth() const
|
||||
{
|
||||
return wxDate(month, 1, year).GetDayOfWeek();
|
||||
}
|
||||
|
||||
int wxDate::GetDay() const
|
||||
{
|
||||
return day;
|
||||
}
|
||||
|
||||
int wxDate::GetDayOfWeek() const
|
||||
{
|
||||
return day_of_week;
|
||||
}
|
||||
|
||||
int wxDate::GetYear() const
|
||||
{
|
||||
return year;
|
||||
}
|
||||
|
||||
int wxDate::GetMonth() const
|
||||
{
|
||||
return month;
|
||||
}
|
||||
|
||||
wxDate& wxDate::AddWeeks(int nCount)
|
||||
{
|
||||
Set(julian + (long)nCount*7);
|
||||
return *this;
|
||||
}
|
||||
|
||||
wxDate& wxDate::AddMonths(int nCount)
|
||||
{
|
||||
month += nCount;
|
||||
|
||||
if (month < 1) {
|
||||
month = 12;
|
||||
year--;
|
||||
}
|
||||
|
||||
if (month > 12) {
|
||||
month = 1;
|
||||
year++;
|
||||
}
|
||||
mdy_to_julian();
|
||||
return *this;
|
||||
}
|
||||
|
||||
wxDate& wxDate::AddYears(int nCount)
|
||||
{
|
||||
year += nCount;
|
||||
mdy_to_julian();
|
||||
return *this;
|
||||
}
|
||||
|
||||
int wxDate::GetWeekOfMonth()
|
||||
{
|
||||
// Abs day includes the days from previous month that fills up
|
||||
// the begin. of the week.
|
||||
int nAbsDay = day + GetFirstDayOfMonth()-1;
|
||||
return (nAbsDay-GetDayOfWeek())/7 + 1;
|
||||
}
|
||||
|
||||
int wxDate::GetWeekOfYear()
|
||||
{
|
||||
wxDate doTemp(1, 1, year);
|
||||
return (int)(((julian - doTemp.julian+1)/7) + 1);
|
||||
}
|
||||
|
||||
wxDate wxDate::GetMonthStart()
|
||||
{
|
||||
return(wxDate(month, 1, year));
|
||||
}
|
||||
|
||||
wxDate wxDate::GetMonthEnd()
|
||||
{
|
||||
return(wxDate(month+1, 1, year)-1);
|
||||
}
|
||||
|
||||
wxDate wxDate::GetYearStart()
|
||||
{
|
||||
return(wxDate(1, 1, year));
|
||||
}
|
||||
|
||||
wxDate wxDate::GetYearEnd()
|
||||
{
|
||||
return(wxDate(1, 1, year+1)-1);
|
||||
}
|
||||
|
||||
wxString wxDate::GetMonthName()
|
||||
{
|
||||
return(FormatDate(wxMONTH));
|
||||
}
|
||||
|
||||
wxString wxDate::GetDayOfWeekName()
|
||||
{
|
||||
return(FormatDate(wxDAY));
|
||||
}
|
||||
|
||||
bool wxDate::IsBetween(const wxDate& first, const wxDate& second) const
|
||||
{
|
||||
return (julian >= first.julian && julian <= second.julian);
|
||||
}
|
||||
|
||||
// This function is from NIHCL
|
||||
wxDate wxDate::Previous(int dayOfWeek) const
|
||||
{
|
||||
int this_day_Of_Week, desired_day_Of_Week;
|
||||
long j;
|
||||
|
||||
// Set the desired and current day of week to start at 0 (Monday)
|
||||
// and end at 6 (Sunday).
|
||||
|
||||
desired_day_Of_Week = dayOfWeek - 1; // These functions return a value
|
||||
this_day_Of_Week = GetDayOfWeek() - 1; // from 1-7. Subtract 1 for 0-6.
|
||||
j = julian;
|
||||
|
||||
// Have to determine how many days difference from current day back to
|
||||
// desired, if any. Special calculation under the 'if' statement to
|
||||
// effect the wraparound counting from Monday (0) back to Sunday (6).
|
||||
|
||||
if (desired_day_Of_Week > this_day_Of_Week)
|
||||
this_day_Of_Week += 7 - desired_day_Of_Week;
|
||||
else
|
||||
this_day_Of_Week -= desired_day_Of_Week;
|
||||
j -= this_day_Of_Week; // Adjust j to set it at the desired day of week.
|
||||
return wxDate(j);
|
||||
}
|
||||
|
||||
#endif
|
@@ -1,447 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: time.cpp
|
||||
// Purpose: wxTime class, from NIHCL
|
||||
// Author: Julian Smart, after K. E. Gorlen
|
||||
// Modified by:
|
||||
// Created: 04/01/98
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Julian Smart and Markus Holzem
|
||||
// Licence: wxWindows license
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation "time.h"
|
||||
#endif
|
||||
|
||||
/*
|
||||
Provides an object that represents a Time, stored as the number of
|
||||
seconds since January 1, 1901, GMT.
|
||||
*/
|
||||
|
||||
// For compilers that support precompilation, includes "wx.h".
|
||||
#include "wx/wxprec.h"
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma hdrstop
|
||||
#endif
|
||||
|
||||
#include "wx/setup.h"
|
||||
|
||||
#if wxUSE_TIMEDATE
|
||||
|
||||
#include "wx/time.h"
|
||||
#include "wx/date.h"
|
||||
#include "wx/utils.h"
|
||||
#include "wx/intl.h"
|
||||
|
||||
#if wxUSE_STD_IOSTREAM
|
||||
#include "wx/ioswrap.h"
|
||||
#if wxUSE_IOSTREAMH
|
||||
#include <iomanip.h>
|
||||
#else
|
||||
#include <iomanip>
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
|
||||
IMPLEMENT_DYNAMIC_CLASS(wxTime, wxObject)
|
||||
|
||||
|
||||
#ifndef WX_TIMEZONE
|
||||
#define WX_TIMEZONE _timezone
|
||||
#endif
|
||||
|
||||
extern long wxGetUTCTime(void);
|
||||
bool wxGetTZandDST(long *timeZone, int *dstObserved)
|
||||
{
|
||||
time_t now;
|
||||
struct tm *tm;
|
||||
|
||||
now = time((time_t *) NULL);
|
||||
|
||||
if (now != (time_t)-1)
|
||||
{
|
||||
tm = localtime(&now);
|
||||
|
||||
if ((tm) && (tm->tm_isdst > 0))
|
||||
*dstObserved = 1;
|
||||
}
|
||||
*timeZone = WX_TIMEZONE;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
static long TIME_ZONE; /* seconds west of GMT */
|
||||
static int DST_OBSERVED; /* flags U.S. daylight saving time observed */
|
||||
|
||||
static bool wxTimeInitialized = FALSE;
|
||||
|
||||
wxTime::tFormat wxTime::Format = wxTime::wx12h;
|
||||
wxTime::tPrecision wxTime::Precision = wxTime::wxStdMinSec;
|
||||
|
||||
static const unsigned long seconds_in_day = 24*60*60L;
|
||||
static const wxDate refDate(1,1,1901);
|
||||
// static const wxDate maxDate(49709L); /* ((2**32)-1)/seconds_in_day -1 */
|
||||
|
||||
wxTime wxTime::GetLocalTime(const wxDate& date, hourTy h, minuteTy m, secondTy s)
|
||||
/*
|
||||
Return a local wxTime for the specified Standard Time date, hour, minute,
|
||||
and second.
|
||||
*/
|
||||
{
|
||||
if (!wxTimeInitialized)
|
||||
{
|
||||
wxGetTZandDST(&TIME_ZONE, &DST_OBSERVED);
|
||||
wxTimeInitialized = TRUE;
|
||||
}
|
||||
/*
|
||||
if (!date.IsBetween(refDate,maxDate))
|
||||
setError(NIHCL_DATERANGE,DEFAULT,
|
||||
date.dayOfMonth(),date.nameOfMonth(),date.year());
|
||||
*/
|
||||
// The following line causes an error in GCC 2.1
|
||||
// long daysBetween = date-refDate;
|
||||
// ... but this seems to get round it.
|
||||
wxDate tmp1(date);
|
||||
wxDate tmp2(refDate);
|
||||
long daysBetween = tmp1 - tmp2;
|
||||
|
||||
return wxTime(seconds_in_day*daysBetween + 60*60L*h + 60*m + s);
|
||||
}
|
||||
|
||||
wxTime::wxTime()
|
||||
/*
|
||||
Construct a wxTime for this instant.
|
||||
*/
|
||||
{
|
||||
if (!wxTimeInitialized)
|
||||
{
|
||||
wxGetTZandDST(&TIME_ZONE, &DST_OBSERVED);
|
||||
wxTimeInitialized = TRUE;
|
||||
}
|
||||
sec = wxGetUTCTime();
|
||||
#ifdef __SALFORDC__
|
||||
sec += (unsigned long) 2177452800; /* seconds from 1/1/01 to 1/1/70 */
|
||||
#else
|
||||
sec += 2177452800UL; /* seconds from 1/1/01 to 1/1/70 */
|
||||
#endif
|
||||
}
|
||||
|
||||
wxTime::wxTime(hourTy h, minuteTy m, secondTy s, bool dst)
|
||||
/*
|
||||
Construct a wxTime for today at the specified (local) hour, minute, and
|
||||
second.
|
||||
*/
|
||||
{
|
||||
if (!wxTimeInitialized)
|
||||
{
|
||||
wxGetTZandDST(&TIME_ZONE, &DST_OBSERVED);
|
||||
wxTimeInitialized = TRUE;
|
||||
}
|
||||
|
||||
sec = wxTime(wxDate(),h,m,s,dst).sec;
|
||||
}
|
||||
|
||||
|
||||
wxTime::wxTime(const wxDate& date, hourTy h, minuteTy m, secondTy s, bool dst)
|
||||
/*
|
||||
Construct a wxTime for the specified (local) Date, hour, minute, and
|
||||
second.
|
||||
*/
|
||||
{
|
||||
if (!wxTimeInitialized)
|
||||
{
|
||||
wxGetTZandDST(&TIME_ZONE, &DST_OBSERVED);
|
||||
wxTimeInitialized = TRUE;
|
||||
}
|
||||
sec = GetLocalTime(date,h,m,s).sec-3600;
|
||||
if (IsDST())
|
||||
{
|
||||
sec += 3600;
|
||||
if (IsDST() || dst) sec -= 3600;
|
||||
}
|
||||
else
|
||||
{
|
||||
sec += 3600;
|
||||
/*
|
||||
if (IsDST()) setError(NIHCL_BADTIME,DEFAULT,
|
||||
date.dayOfMonth(),date.nameOfMonth(),date.year(),
|
||||
h,m,s,(dst?_("DST"):""));
|
||||
*/
|
||||
}
|
||||
sec += TIME_ZONE; // adjust to GMT
|
||||
}
|
||||
|
||||
#ifndef __SALFORDC__
|
||||
wxTime::operator wxDate() const
|
||||
/*
|
||||
Convert a wxTime to a local wxDate
|
||||
*/
|
||||
{
|
||||
// return wxDate((int)(GetLocalTime().sec/seconds_in_day)); 4.2 cc bug
|
||||
long daycount = (long)(GetLocalTime().sec/seconds_in_day);
|
||||
|
||||
wxDate date(1,1,1901);
|
||||
date += daycount;
|
||||
return date;
|
||||
}
|
||||
#endif
|
||||
|
||||
bool wxTime::IsBetween(const wxTime& a, const wxTime& b) const
|
||||
{
|
||||
return *this >= a && *this <= b;
|
||||
}
|
||||
|
||||
hourTy wxTime::GetHour() const
|
||||
/*
|
||||
Return the hour of this wxTime in local time; i.e., adjust for
|
||||
time zone and Daylight Savings Time.
|
||||
*/
|
||||
{
|
||||
return GetLocalTime().GetHourGMT();
|
||||
}
|
||||
|
||||
hourTy wxTime::GetHourGMT() const
|
||||
/*
|
||||
Return the hour of this Time in GMT.
|
||||
*/
|
||||
{
|
||||
return (hourTy)((sec % 86400) / 3600);
|
||||
}
|
||||
|
||||
wxTime wxTime::GetBeginDST(unsigned year)
|
||||
/*
|
||||
Return the local Standard Time at which Daylight Savings Time
|
||||
begins in the specified year.
|
||||
*/
|
||||
{
|
||||
// Previous Sunday
|
||||
wxTime DSTtime(GetLocalTime(wxDate(3,31,year).Previous(1)+7,2));
|
||||
if (year<=1986) {
|
||||
// Previous Sunday
|
||||
DSTtime = GetLocalTime(wxDate(4,30,year).Previous(1),2);
|
||||
if (year==1974) DSTtime = GetLocalTime(wxDate(1,6,1974),2);
|
||||
if (year==1975) DSTtime = GetLocalTime(wxDate(2,23,1975),2);
|
||||
}
|
||||
return DSTtime;
|
||||
}
|
||||
|
||||
wxTime wxTime::GetEndDST(unsigned year)
|
||||
/*
|
||||
Return the local Standard Time at which Daylight Savings Time
|
||||
ends in the specified year.
|
||||
*/
|
||||
{
|
||||
wxTime STDtime(GetLocalTime(wxDate(10,31,year).Previous(1),2-1));
|
||||
return STDtime;
|
||||
}
|
||||
|
||||
bool wxTime::IsDST() const
|
||||
/*
|
||||
Return TRUE if this local Standard Time should be adjusted
|
||||
for Daylight Savings Time.
|
||||
*/
|
||||
{
|
||||
long daycount = (long)(sec/seconds_in_day);
|
||||
|
||||
// At this point, daycount is the number of days from 1/1/1901.
|
||||
// Need to convert to julian date (which starts at 1/1/4713 B.C.)
|
||||
wxDate date(1,1,1901);
|
||||
date += daycount;
|
||||
|
||||
unsigned year = date.GetYear();
|
||||
if (DST_OBSERVED)
|
||||
{
|
||||
if (*this >= GetBeginDST(year))
|
||||
if (*this < GetEndDST(year)) return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
wxTime wxTime::GetLocalTime() const
|
||||
/*
|
||||
Adjusts this GM Time for local time zone and Daylight Savings Time.
|
||||
*/
|
||||
{
|
||||
wxTime local_time(sec-TIME_ZONE);
|
||||
if (local_time.IsDST()) local_time.sec += 3600;
|
||||
return local_time;
|
||||
}
|
||||
|
||||
minuteTy wxTime::GetMinute() const
|
||||
/*
|
||||
Return the minute of this wxTime in local time; i.e., adjust
|
||||
for time zone and Daylight Savings Time.
|
||||
*/
|
||||
{
|
||||
return GetLocalTime().GetMinuteGMT();
|
||||
}
|
||||
|
||||
minuteTy wxTime::GetMinuteGMT() const
|
||||
/*
|
||||
Return the minute of this wxTime in GMT.
|
||||
*/
|
||||
{
|
||||
return (minuteTy)(((sec % 86400) % 3600) / 60);
|
||||
}
|
||||
|
||||
secondTy wxTime::GetSecond() const
|
||||
/*
|
||||
Return the second of this wxTime.
|
||||
*/
|
||||
{
|
||||
return (secondTy)(((sec % 86400) % 3600) % 60);
|
||||
}
|
||||
|
||||
secondTy wxTime::GetSecondGMT() const
|
||||
/*
|
||||
Return the minute of this wxTime in GMT.
|
||||
*/
|
||||
{
|
||||
return (secondTy)(((sec % 86400) % 3600) % 60);
|
||||
}
|
||||
|
||||
int wxTime::GetDay() const
|
||||
{
|
||||
wxDate da((wxDate) *this);
|
||||
return da.GetDay();
|
||||
}
|
||||
|
||||
int wxTime::GetDayOfWeek() const
|
||||
{
|
||||
wxDate da((wxDate) *this);
|
||||
return da.GetDayOfWeek();
|
||||
}
|
||||
|
||||
int wxTime::GetMonth() const
|
||||
{
|
||||
wxDate da((wxDate) *this);
|
||||
return da.GetMonth();
|
||||
}
|
||||
|
||||
int wxTime::GetYear() const
|
||||
{
|
||||
wxDate da((wxDate) *this);
|
||||
return da.GetYear();
|
||||
}
|
||||
|
||||
wxTime wxTime::Max(const wxTime& t) const
|
||||
{
|
||||
if (t < *this) return *this;
|
||||
return t;
|
||||
}
|
||||
|
||||
wxTime wxTime::Min(const wxTime& t) const
|
||||
{
|
||||
if (t > *this) return *this;
|
||||
return t;
|
||||
}
|
||||
|
||||
#ifndef __SALFORDC__
|
||||
wxTime::operator wxChar *(void)
|
||||
{
|
||||
return FormatTime();
|
||||
}
|
||||
#endif
|
||||
|
||||
void wxTime::SetFormat(const wxTime::tFormat lFormat,
|
||||
const wxTime::tPrecision lPrecision) {
|
||||
|
||||
wxTime::Format = lFormat;
|
||||
wxTime::Precision = lPrecision;
|
||||
}
|
||||
|
||||
wxChar *wxTime::FormatTime() const {
|
||||
static wxChar timeBuf[30];
|
||||
unsigned hh(GetHour());
|
||||
|
||||
switch (Format) {
|
||||
case wx12h:
|
||||
hh -= 12;
|
||||
break;
|
||||
case wx24h:
|
||||
break;
|
||||
}
|
||||
|
||||
switch (Precision) {
|
||||
case wxStdMinSec:
|
||||
wxSprintf(timeBuf,wxT("%2d:%02d:%02d"),hh,GetMinute(),GetSecond());
|
||||
break;
|
||||
case wxStdMin:
|
||||
wxSprintf(timeBuf,wxT("%2d:%02d"),hh,GetMinute());
|
||||
break;
|
||||
}
|
||||
|
||||
if (Format == wx12h)
|
||||
if (GetHour() <= 12)
|
||||
wxStrcat(timeBuf,_("am"));
|
||||
else
|
||||
wxStrcat(timeBuf,_("pm"));
|
||||
|
||||
return timeBuf;
|
||||
}
|
||||
|
||||
/*
|
||||
int wxTime::compare(const Object& ob) const
|
||||
{
|
||||
assertArgSpecies(ob,classDesc,"compare");
|
||||
register clockTy t = castdown(ob).sec;
|
||||
if (sec < t) return -1;
|
||||
if (sec > t) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void wxTime::deepenShallowCopy() {}
|
||||
|
||||
unsigned wxTime::hash() const { return sec; }
|
||||
|
||||
bool wxTime::isEqual(const Object& ob) const
|
||||
{
|
||||
return ob.isSpecies(classDesc) && *this==castdown(ob);
|
||||
}
|
||||
|
||||
const Class* wxTime::species() const { return &classDesc; }
|
||||
|
||||
void wxTime::printOn(ostream& strm) const
|
||||
{
|
||||
register unsigned hh = GetHour();
|
||||
wxDate(*this).printOn(strm);
|
||||
strm << ' ' << ((hh <= 12) ? hh : hh-12) << ':'
|
||||
<< setfill('0') << setw(2) << GetMinute() << ':'
|
||||
<< setfill('0') << setw(2) << GetSecond() << ' ';
|
||||
if (hh < 12) strm << _("am");
|
||||
else strm << _("pm");
|
||||
}
|
||||
|
||||
wxTime::wxTime(OIOin& strm)
|
||||
: BASE(strm)
|
||||
{
|
||||
unsigned long usec;
|
||||
strm >> sec >> usec;
|
||||
}
|
||||
|
||||
void wxTime::storer(OIOout& strm) const
|
||||
{
|
||||
BASE::storer(strm);
|
||||
strm << sec << 0l;
|
||||
}
|
||||
|
||||
|
||||
wxTime::wxTime(OIOifd& fd)
|
||||
: BASE(fd)
|
||||
{
|
||||
unsigned long usec;
|
||||
fd >> sec >> usec;
|
||||
}
|
||||
|
||||
void wxTime::storer(OIOofd& fd) const
|
||||
{
|
||||
BASE::storer(fd);
|
||||
fd << sec << 0l;
|
||||
}
|
||||
*/
|
||||
|
||||
#endif
|
778
src/regex/regc_color.c
Normal file
778
src/regex/regc_color.c
Normal file
@@ -0,0 +1,778 @@
|
||||
/*
|
||||
* 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.
|
||||
*
|
||||
*
|
||||
*
|
||||
* 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 *, struct colormap *);
|
||||
*/
|
||||
static VOID
|
||||
initcm(v, cm)
|
||||
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 *);
|
||||
*/
|
||||
static VOID
|
||||
freecm(cm)
|
||||
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 *, union tree *, int);
|
||||
*/
|
||||
static VOID
|
||||
cmtreefree(cm, tree, level)
|
||||
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 setcolor(struct colormap *, pchr, pcolor);
|
||||
*/
|
||||
static color /* previous color */
|
||||
setcolor(cm, c, co)
|
||||
struct colormap *cm;
|
||||
pchr 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 *);
|
||||
*/
|
||||
static color
|
||||
maxcolor(cm)
|
||||
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 newcolor(struct colormap *);
|
||||
*/
|
||||
static color /* COLORLESS for error */
|
||||
newcolor(cm)
|
||||
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 *, pcolor);
|
||||
*/
|
||||
static VOID
|
||||
freecolor(cm, co)
|
||||
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 *);
|
||||
*/
|
||||
static color
|
||||
pseudocolor(cm)
|
||||
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 *, pchr c);
|
||||
*/
|
||||
static color
|
||||
subcolor(cm, c)
|
||||
struct colormap *cm;
|
||||
pchr 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 *, pcolor);
|
||||
*/
|
||||
static color
|
||||
newsub(cm, co)
|
||||
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 *, pchr, pchr, struct state *,
|
||||
^ struct state *);
|
||||
*/
|
||||
static VOID
|
||||
subrange(v, from, to, lp, rp)
|
||||
struct vars *v;
|
||||
pchr from;
|
||||
pchr 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 *, pchr, struct state *, struct state *);
|
||||
*/
|
||||
static VOID
|
||||
subblock(v, start, lp, rp)
|
||||
struct vars *v;
|
||||
pchr 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 *, struct colormap *);
|
||||
*/
|
||||
static VOID
|
||||
okcolors(nfa, cm)
|
||||
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 *, struct arc *);
|
||||
*/
|
||||
static VOID
|
||||
colorchain(cm, a)
|
||||
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 *, struct arc *);
|
||||
*/
|
||||
static VOID
|
||||
uncolorchain(cm, a)
|
||||
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 singleton(struct colormap *, pchr c);
|
||||
*/
|
||||
static int /* predicate */
|
||||
singleton(cm, c)
|
||||
struct colormap *cm;
|
||||
pchr 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 *, struct colormap *, int, pcolor,
|
||||
^ struct state *, struct state *);
|
||||
*/
|
||||
static VOID
|
||||
rainbow(nfa, cm, type, but, from, to)
|
||||
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 *, struct colormap *, int,
|
||||
^ struct state *, struct state *, struct state *);
|
||||
*/
|
||||
static VOID
|
||||
colorcomplement(nfa, cm, type, of, from, to)
|
||||
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
|
||||
/*
|
||||
^ #ifdef REG_DEBUG
|
||||
*/
|
||||
|
||||
/*
|
||||
- dumpcolors - debugging output
|
||||
^ static VOID dumpcolors(struct colormap *, FILE *);
|
||||
*/
|
||||
static VOID
|
||||
dumpcolors(cm, f)
|
||||
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 *, union tree *, int, FILE *);
|
||||
*/
|
||||
static VOID
|
||||
fillcheck(cm, tree, level, f)
|
||||
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(pchr, FILE *);
|
||||
*/
|
||||
static VOID
|
||||
dumpchr(c, f)
|
||||
pchr c;
|
||||
FILE *f;
|
||||
{
|
||||
if (c == '\\')
|
||||
fprintf(f, "\\\\");
|
||||
else if (c > ' ' && c <= '~')
|
||||
putc((char)c, f);
|
||||
else
|
||||
fprintf(f, "\\u%04lx", (long)c);
|
||||
}
|
||||
|
||||
/*
|
||||
^ #endif
|
||||
*/
|
||||
#endif /* ifdef REG_DEBUG */
|
208
src/regex/regc_cvec.c
Normal file
208
src/regex/regc_cvec.c
Normal file
@@ -0,0 +1,208 @@
|
||||
/*
|
||||
* Utility functions for handling cvecs
|
||||
* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
- newcvec - allocate a new cvec
|
||||
^ static struct cvec *newcvec(int, int, int);
|
||||
*/
|
||||
static struct cvec *
|
||||
newcvec(nchrs, nranges, nmcces)
|
||||
int nchrs; /* to hold this many chrs... */
|
||||
int nranges; /* ... and this many ranges... */
|
||||
int nmcces; /* ... and this many MCCEs */
|
||||
{
|
||||
size_t n;
|
||||
size_t nc;
|
||||
struct cvec *cv;
|
||||
|
||||
nc = (size_t)nchrs + (size_t)nmcces*(MAXMCCE+1) + (size_t)nranges*2;
|
||||
n = sizeof(struct cvec) + (size_t)(nmcces-1)*sizeof(chr *)
|
||||
+ nc*sizeof(chr);
|
||||
cv = (struct cvec *)MALLOC(n);
|
||||
if (cv == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
cv->chrspace = nchrs;
|
||||
cv->chrs = (chr *)&cv->mcces[nmcces]; /* chrs just after MCCE ptrs */
|
||||
cv->mccespace = nmcces;
|
||||
cv->ranges = cv->chrs + nchrs + nmcces*(MAXMCCE+1);
|
||||
cv->rangespace = nranges;
|
||||
return clearcvec(cv);
|
||||
}
|
||||
|
||||
/*
|
||||
- clearcvec - clear a possibly-new cvec
|
||||
* Returns pointer as convenience.
|
||||
^ static struct cvec *clearcvec(struct cvec *);
|
||||
*/
|
||||
static struct cvec *
|
||||
clearcvec(cv)
|
||||
struct cvec *cv; /* character vector */
|
||||
{
|
||||
int i;
|
||||
|
||||
assert(cv != NULL);
|
||||
cv->nchrs = 0;
|
||||
assert(cv->chrs == (chr *)&cv->mcces[cv->mccespace]);
|
||||
cv->nmcces = 0;
|
||||
cv->nmccechrs = 0;
|
||||
cv->nranges = 0;
|
||||
for (i = 0; i < cv->mccespace; i++) {
|
||||
cv->mcces[i] = NULL;
|
||||
}
|
||||
|
||||
return cv;
|
||||
}
|
||||
|
||||
/*
|
||||
- addchr - add a chr to a cvec
|
||||
^ static VOID addchr(struct cvec *, pchr);
|
||||
*/
|
||||
static VOID
|
||||
addchr(cv, c)
|
||||
struct cvec *cv; /* character vector */
|
||||
pchr c; /* character to add */
|
||||
{
|
||||
assert(cv->nchrs < cv->chrspace - cv->nmccechrs);
|
||||
cv->chrs[cv->nchrs++] = (chr)c;
|
||||
}
|
||||
|
||||
/*
|
||||
- addrange - add a range to a cvec
|
||||
^ static VOID addrange(struct cvec *, pchr, pchr);
|
||||
*/
|
||||
static VOID
|
||||
addrange(cv, from, to)
|
||||
struct cvec *cv; /* character vector */
|
||||
pchr from; /* first character of range */
|
||||
pchr to; /* last character of range */
|
||||
{
|
||||
assert(cv->nranges < cv->rangespace);
|
||||
cv->ranges[cv->nranges*2] = (chr)from;
|
||||
cv->ranges[cv->nranges*2 + 1] = (chr)to;
|
||||
cv->nranges++;
|
||||
}
|
||||
|
||||
/*
|
||||
- addmcce - add an MCCE to a cvec
|
||||
^ static VOID addmcce(struct cvec *, chr *, chr *);
|
||||
*/
|
||||
static VOID
|
||||
addmcce(cv, startp, endp)
|
||||
struct cvec *cv; /* character vector */
|
||||
chr *startp; /* beginning of text */
|
||||
chr *endp; /* just past end of text */
|
||||
{
|
||||
int len;
|
||||
int i;
|
||||
chr *s;
|
||||
chr *d;
|
||||
|
||||
if (startp == NULL && endp == NULL) {
|
||||
return;
|
||||
}
|
||||
len = endp - startp;
|
||||
assert(len > 0);
|
||||
assert(cv->nchrs + len < cv->chrspace - cv->nmccechrs);
|
||||
assert(cv->nmcces < cv->mccespace);
|
||||
d = &cv->chrs[cv->chrspace - cv->nmccechrs - len - 1];
|
||||
cv->mcces[cv->nmcces++] = d;
|
||||
for (s = startp, i = len; i > 0; s++, i--) {
|
||||
*d++ = *s;
|
||||
}
|
||||
*d++ = 0; /* endmarker */
|
||||
assert(d == &cv->chrs[cv->chrspace - cv->nmccechrs]);
|
||||
cv->nmccechrs += len + 1;
|
||||
}
|
||||
|
||||
/*
|
||||
- haschr - does a cvec contain this chr?
|
||||
^ static int haschr(struct cvec *, pchr);
|
||||
*/
|
||||
static int /* predicate */
|
||||
haschr(cv, c)
|
||||
struct cvec *cv; /* character vector */
|
||||
pchr c; /* character to test for */
|
||||
{
|
||||
int i;
|
||||
chr *p;
|
||||
|
||||
for (p = cv->chrs, i = cv->nchrs; i > 0; p++, i--) {
|
||||
if (*p == c) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
for (p = cv->ranges, i = cv->nranges; i > 0; p += 2, i--) {
|
||||
if ((*p <= c) && (c <= *(p+1))) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
- getcvec - get a cvec, remembering it as v->cv
|
||||
^ static struct cvec *getcvec(struct vars *, int, int, int);
|
||||
*/
|
||||
static struct cvec *
|
||||
getcvec(v, nchrs, nranges, nmcces)
|
||||
struct vars *v; /* context */
|
||||
int nchrs; /* to hold this many chrs... */
|
||||
int nranges; /* ... and this many ranges... */
|
||||
int nmcces; /* ... and this many MCCEs */
|
||||
{
|
||||
if (v->cv != NULL && nchrs <= v->cv->chrspace &&
|
||||
nranges <= v->cv->rangespace && nmcces <= v->cv->mccespace) {
|
||||
return clearcvec(v->cv);
|
||||
}
|
||||
|
||||
if (v->cv != NULL) {
|
||||
freecvec(v->cv);
|
||||
}
|
||||
v->cv = newcvec(nchrs, nranges, nmcces);
|
||||
if (v->cv == NULL) {
|
||||
ERR(REG_ESPACE);
|
||||
}
|
||||
|
||||
return v->cv;
|
||||
}
|
||||
|
||||
/*
|
||||
- freecvec - free a cvec
|
||||
^ static VOID freecvec(struct cvec *);
|
||||
*/
|
||||
static VOID
|
||||
freecvec(cv)
|
||||
struct cvec *cv; /* character vector */
|
||||
{
|
||||
FREE(cv);
|
||||
}
|
1061
src/regex/regc_lex.c
Normal file
1061
src/regex/regc_lex.c
Normal file
File diff suppressed because it is too large
Load Diff
989
src/regex/regc_locale.c
Normal file
989
src/regex/regc_locale.c
Normal file
@@ -0,0 +1,989 @@
|
||||
/*
|
||||
* regc_locale.c --
|
||||
*
|
||||
* This file contains the Unicode locale specific regexp routines.
|
||||
* This file is #included by regcomp.c.
|
||||
*
|
||||
* Copyright (c) 1998 by Scriptics Corporation.
|
||||
*
|
||||
* See the file "license.terms" for information on usage and redistribution
|
||||
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
||||
*
|
||||
* RCS: @(#) $Id$
|
||||
*/
|
||||
|
||||
/* ASCII 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}
|
||||
};
|
||||
|
||||
/* Unicode character-class tables */
|
||||
|
||||
typedef struct crange {
|
||||
chr start;
|
||||
chr end;
|
||||
} crange;
|
||||
|
||||
/*
|
||||
* Declarations of Unicode character ranges. This code
|
||||
* is automatically generated by the tools/uniClass.tcl script
|
||||
* and used in generic/regc_locale.c. Do not modify by hand.
|
||||
*/
|
||||
|
||||
/* Unicode: alphabetic characters */
|
||||
|
||||
static crange alphaRangeTable[] = {
|
||||
{0x0041, 0x005a}, {0x0061, 0x007a}, {0x00c0, 0x00d6}, {0x00d8, 0x00f6},
|
||||
{0x00f8, 0x021f}, {0x0222, 0x0233}, {0x0250, 0x02ad}, {0x02b0, 0x02b8},
|
||||
{0x02bb, 0x02c1}, {0x02e0, 0x02e4}, {0x0388, 0x038a}, {0x038e, 0x03a1},
|
||||
{0x03a3, 0x03ce}, {0x03d0, 0x03d7}, {0x03da, 0x03f5}, {0x0400, 0x0481},
|
||||
{0x048c, 0x04c4}, {0x04d0, 0x04f5}, {0x0531, 0x0556}, {0x0561, 0x0587},
|
||||
{0x05d0, 0x05ea}, {0x05f0, 0x05f2}, {0x0621, 0x063a}, {0x0640, 0x064a},
|
||||
{0x0671, 0x06d3}, {0x06fa, 0x06fc}, {0x0712, 0x072c}, {0x0780, 0x07a5},
|
||||
{0x0905, 0x0939}, {0x0958, 0x0961}, {0x0985, 0x098c}, {0x0993, 0x09a8},
|
||||
{0x09aa, 0x09b0}, {0x09b6, 0x09b9}, {0x09df, 0x09e1}, {0x0a05, 0x0a0a},
|
||||
{0x0a13, 0x0a28}, {0x0a2a, 0x0a30}, {0x0a59, 0x0a5c}, {0x0a72, 0x0a74},
|
||||
{0x0a85, 0x0a8b}, {0x0a8f, 0x0a91}, {0x0a93, 0x0aa8}, {0x0aaa, 0x0ab0},
|
||||
{0x0ab5, 0x0ab9}, {0x0b05, 0x0b0c}, {0x0b13, 0x0b28}, {0x0b2a, 0x0b30},
|
||||
{0x0b36, 0x0b39}, {0x0b5f, 0x0b61}, {0x0b85, 0x0b8a}, {0x0b8e, 0x0b90},
|
||||
{0x0b92, 0x0b95}, {0x0ba8, 0x0baa}, {0x0bae, 0x0bb5}, {0x0bb7, 0x0bb9},
|
||||
{0x0c05, 0x0c0c}, {0x0c0e, 0x0c10}, {0x0c12, 0x0c28}, {0x0c2a, 0x0c33},
|
||||
{0x0c35, 0x0c39}, {0x0c85, 0x0c8c}, {0x0c8e, 0x0c90}, {0x0c92, 0x0ca8},
|
||||
{0x0caa, 0x0cb3}, {0x0cb5, 0x0cb9}, {0x0d05, 0x0d0c}, {0x0d0e, 0x0d10},
|
||||
{0x0d12, 0x0d28}, {0x0d2a, 0x0d39}, {0x0d85, 0x0d96}, {0x0d9a, 0x0db1},
|
||||
{0x0db3, 0x0dbb}, {0x0dc0, 0x0dc6}, {0x0e01, 0x0e30}, {0x0e40, 0x0e46},
|
||||
{0x0e94, 0x0e97}, {0x0e99, 0x0e9f}, {0x0ea1, 0x0ea3}, {0x0ead, 0x0eb0},
|
||||
{0x0ec0, 0x0ec4}, {0x0f40, 0x0f47}, {0x0f49, 0x0f6a}, {0x0f88, 0x0f8b},
|
||||
{0x1000, 0x1021}, {0x1023, 0x1027}, {0x1050, 0x1055}, {0x10a0, 0x10c5},
|
||||
{0x10d0, 0x10f6}, {0x1100, 0x1159}, {0x115f, 0x11a2}, {0x11a8, 0x11f9},
|
||||
{0x1200, 0x1206}, {0x1208, 0x1246}, {0x124a, 0x124d}, {0x1250, 0x1256},
|
||||
{0x125a, 0x125d}, {0x1260, 0x1286}, {0x128a, 0x128d}, {0x1290, 0x12ae},
|
||||
{0x12b2, 0x12b5}, {0x12b8, 0x12be}, {0x12c2, 0x12c5}, {0x12c8, 0x12ce},
|
||||
{0x12d0, 0x12d6}, {0x12d8, 0x12ee}, {0x12f0, 0x130e}, {0x1312, 0x1315},
|
||||
{0x1318, 0x131e}, {0x1320, 0x1346}, {0x1348, 0x135a}, {0x13a0, 0x13f4},
|
||||
{0x1401, 0x166c}, {0x166f, 0x1676}, {0x1681, 0x169a}, {0x16a0, 0x16ea},
|
||||
{0x1780, 0x17b3}, {0x1820, 0x1877}, {0x1880, 0x18a8}, {0x1e00, 0x1e9b},
|
||||
{0x1ea0, 0x1ef9}, {0x1f00, 0x1f15}, {0x1f18, 0x1f1d}, {0x1f20, 0x1f45},
|
||||
{0x1f48, 0x1f4d}, {0x1f50, 0x1f57}, {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4},
|
||||
{0x1fb6, 0x1fbc}, {0x1fc2, 0x1fc4}, {0x1fc6, 0x1fcc}, {0x1fd0, 0x1fd3},
|
||||
{0x1fd6, 0x1fdb}, {0x1fe0, 0x1fec}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffc},
|
||||
{0x210a, 0x2113}, {0x2119, 0x211d}, {0x212a, 0x212d}, {0x212f, 0x2131},
|
||||
{0x2133, 0x2139}, {0x3031, 0x3035}, {0x3041, 0x3094}, {0x30a1, 0x30fa},
|
||||
{0x30fc, 0x30fe}, {0x3105, 0x312c}, {0x3131, 0x318e}, {0x31a0, 0x31b7},
|
||||
{0x3400, 0x4db5}, {0x4e00, 0x9fa5}, {0xa000, 0xa48c}, {0xac00, 0xd7a3},
|
||||
{0xf900, 0xfa2d}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xfb1f, 0xfb28},
|
||||
{0xfb2a, 0xfb36}, {0xfb38, 0xfb3c}, {0xfb46, 0xfbb1}, {0xfbd3, 0xfd3d},
|
||||
{0xfd50, 0xfd8f}, {0xfd92, 0xfdc7}, {0xfdf0, 0xfdfb}, {0xfe70, 0xfe72},
|
||||
{0xfe76, 0xfefc}, {0xff21, 0xff3a}, {0xff41, 0xff5a}, {0xff66, 0xffbe},
|
||||
{0xffc2, 0xffc7}, {0xffca, 0xffcf}, {0xffd2, 0xffd7}, {0xffda, 0xffdc}
|
||||
};
|
||||
|
||||
#define NUM_ALPHA_RANGE (sizeof(alphaRangeTable)/sizeof(crange))
|
||||
|
||||
static chr alphaCharTable[] = {
|
||||
0x00aa, 0x00b5, 0x00ba, 0x02d0, 0x02d1, 0x02ee, 0x037a, 0x0386, 0x038c,
|
||||
0x04c7, 0x04c8, 0x04cb, 0x04cc, 0x04f8, 0x04f9, 0x0559, 0x06d5, 0x06e5,
|
||||
0x06e6, 0x0710, 0x093d, 0x0950, 0x098f, 0x0990, 0x09b2, 0x09dc, 0x09dd,
|
||||
0x09f0, 0x09f1, 0x0a0f, 0x0a10, 0x0a32, 0x0a33, 0x0a35, 0x0a36, 0x0a38,
|
||||
0x0a39, 0x0a5e, 0x0a8d, 0x0ab2, 0x0ab3, 0x0abd, 0x0ad0, 0x0ae0, 0x0b0f,
|
||||
0x0b10, 0x0b32, 0x0b33, 0x0b3d, 0x0b5c, 0x0b5d, 0x0b99, 0x0b9a, 0x0b9c,
|
||||
0x0b9e, 0x0b9f, 0x0ba3, 0x0ba4, 0x0c60, 0x0c61, 0x0cde, 0x0ce0, 0x0ce1,
|
||||
0x0d60, 0x0d61, 0x0dbd, 0x0e32, 0x0e33, 0x0e81, 0x0e82, 0x0e84, 0x0e87,
|
||||
0x0e88, 0x0e8a, 0x0e8d, 0x0ea5, 0x0ea7, 0x0eaa, 0x0eab, 0x0eb2, 0x0eb3,
|
||||
0x0ebd, 0x0ec6, 0x0edc, 0x0edd, 0x0f00, 0x1029, 0x102a, 0x1248, 0x1258,
|
||||
0x1288, 0x12b0, 0x12c0, 0x1310, 0x1f59, 0x1f5b, 0x1f5d, 0x1fbe, 0x207f,
|
||||
0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x3005, 0x3006, 0x309d,
|
||||
0x309e, 0xfb1d, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfe74, 0xfffe
|
||||
};
|
||||
|
||||
#define NUM_ALPHA_CHAR (sizeof(alphaCharTable)/sizeof(chr))
|
||||
|
||||
/* Unicode: decimal digit characters */
|
||||
|
||||
static crange digitRangeTable[] = {
|
||||
{0x0030, 0x0039}, {0x0660, 0x0669}, {0x06f0, 0x06f9}, {0x0966, 0x096f},
|
||||
{0x09e6, 0x09ef}, {0x0a66, 0x0a6f}, {0x0ae6, 0x0aef}, {0x0b66, 0x0b6f},
|
||||
{0x0be7, 0x0bef}, {0x0c66, 0x0c6f}, {0x0ce6, 0x0cef}, {0x0d66, 0x0d6f},
|
||||
{0x0e50, 0x0e59}, {0x0ed0, 0x0ed9}, {0x0f20, 0x0f29}, {0x1040, 0x1049},
|
||||
{0x1369, 0x1371}, {0x17e0, 0x17e9}, {0x1810, 0x1819}, {0xff10, 0xff19}
|
||||
};
|
||||
|
||||
#define NUM_DIGIT_RANGE (sizeof(digitRangeTable)/sizeof(crange))
|
||||
|
||||
/* no singletons of digit characters */
|
||||
|
||||
/* Unicode: punctuation characters */
|
||||
|
||||
static crange punctRangeTable[] = {
|
||||
{0x0021, 0x0023}, {0x0025, 0x002a}, {0x002c, 0x002f}, {0x005b, 0x005d},
|
||||
{0x055a, 0x055f}, {0x066a, 0x066d}, {0x0700, 0x070d}, {0x0f04, 0x0f12},
|
||||
{0x0f3a, 0x0f3d}, {0x104a, 0x104f}, {0x1361, 0x1368}, {0x16eb, 0x16ed},
|
||||
{0x17d4, 0x17da}, {0x1800, 0x180a}, {0x2010, 0x2027}, {0x2030, 0x2043},
|
||||
{0x2048, 0x204d}, {0x3001, 0x3003}, {0x3008, 0x3011}, {0x3014, 0x301f},
|
||||
{0xfe30, 0xfe44}, {0xfe49, 0xfe52}, {0xfe54, 0xfe61}, {0xff01, 0xff03},
|
||||
{0xff05, 0xff0a}, {0xff0c, 0xff0f}, {0xff3b, 0xff3d}, {0xff61, 0xff65}
|
||||
};
|
||||
|
||||
#define NUM_PUNCT_RANGE (sizeof(punctRangeTable)/sizeof(crange))
|
||||
|
||||
static chr punctCharTable[] = {
|
||||
0x003a, 0x003b, 0x003f, 0x0040, 0x005f, 0x007b, 0x007d, 0x00a1, 0x00ab,
|
||||
0x00ad, 0x00b7, 0x00bb, 0x00bf, 0x037e, 0x0387, 0x0589, 0x058a, 0x05be,
|
||||
0x05c0, 0x05c3, 0x05f3, 0x05f4, 0x060c, 0x061b, 0x061f, 0x06d4, 0x0964,
|
||||
0x0965, 0x0970, 0x0df4, 0x0e4f, 0x0e5a, 0x0e5b, 0x0f85, 0x10fb, 0x166d,
|
||||
0x166e, 0x169b, 0x169c, 0x17dc, 0x2045, 0x2046, 0x207d, 0x207e, 0x208d,
|
||||
0x208e, 0x2329, 0x232a, 0x3030, 0x30fb, 0xfd3e, 0xfd3f, 0xfe63, 0xfe68,
|
||||
0xfe6a, 0xfe6b, 0xff1a, 0xff1b, 0xff1f, 0xff20, 0xff3f, 0xff5b, 0xff5d
|
||||
};
|
||||
|
||||
#define NUM_PUNCT_CHAR (sizeof(punctCharTable)/sizeof(chr))
|
||||
|
||||
/* Unicode: white space characters */
|
||||
|
||||
static crange spaceRangeTable[] = {
|
||||
{0x0009, 0x000d}, {0x2000, 0x200b}
|
||||
};
|
||||
|
||||
#define NUM_SPACE_RANGE (sizeof(spaceRangeTable)/sizeof(crange))
|
||||
|
||||
static chr spaceCharTable[] = {
|
||||
0x0020, 0x00a0, 0x1680, 0x2028, 0x2029, 0x202f, 0x3000
|
||||
};
|
||||
|
||||
#define NUM_SPACE_CHAR (sizeof(spaceCharTable)/sizeof(chr))
|
||||
|
||||
/* Unicode: lowercase characters */
|
||||
|
||||
static crange lowerRangeTable[] = {
|
||||
{0x0061, 0x007a}, {0x00df, 0x00f6}, {0x00f8, 0x00ff}, {0x017e, 0x0180},
|
||||
{0x0199, 0x019b}, {0x01bd, 0x01bf}, {0x0250, 0x02ad}, {0x03ac, 0x03ce},
|
||||
{0x03d5, 0x03d7}, {0x03ef, 0x03f3}, {0x0430, 0x045f}, {0x0561, 0x0587},
|
||||
{0x1e95, 0x1e9b}, {0x1f00, 0x1f07}, {0x1f10, 0x1f15}, {0x1f20, 0x1f27},
|
||||
{0x1f30, 0x1f37}, {0x1f40, 0x1f45}, {0x1f50, 0x1f57}, {0x1f60, 0x1f67},
|
||||
{0x1f70, 0x1f7d}, {0x1f80, 0x1f87}, {0x1f90, 0x1f97}, {0x1fa0, 0x1fa7},
|
||||
{0x1fb0, 0x1fb4}, {0x1fc2, 0x1fc4}, {0x1fd0, 0x1fd3}, {0x1fe0, 0x1fe7},
|
||||
{0x1ff2, 0x1ff4}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xff41, 0xff5a}
|
||||
};
|
||||
|
||||
#define NUM_LOWER_RANGE (sizeof(lowerRangeTable)/sizeof(crange))
|
||||
|
||||
static chr lowerCharTable[] = {
|
||||
0x00aa, 0x00b5, 0x00ba, 0x0101, 0x0103, 0x0105, 0x0107, 0x0109, 0x010b,
|
||||
0x010d, 0x010f, 0x0111, 0x0113, 0x0115, 0x0117, 0x0119, 0x011b, 0x011d,
|
||||
0x011f, 0x0121, 0x0123, 0x0125, 0x0127, 0x0129, 0x012b, 0x012d, 0x012f,
|
||||
0x0131, 0x0133, 0x0135, 0x0137, 0x0138, 0x013a, 0x013c, 0x013e, 0x0140,
|
||||
0x0142, 0x0144, 0x0146, 0x0148, 0x0149, 0x014b, 0x014d, 0x014f, 0x0151,
|
||||
0x0153, 0x0155, 0x0157, 0x0159, 0x015b, 0x015d, 0x015f, 0x0161, 0x0163,
|
||||
0x0165, 0x0167, 0x0169, 0x016b, 0x016d, 0x016f, 0x0171, 0x0173, 0x0175,
|
||||
0x0177, 0x017a, 0x017c, 0x0183, 0x0185, 0x0188, 0x018c, 0x018d, 0x0192,
|
||||
0x0195, 0x019e, 0x01a1, 0x01a3, 0x01a5, 0x01a8, 0x01aa, 0x01ab, 0x01ad,
|
||||
0x01b0, 0x01b4, 0x01b6, 0x01b9, 0x01ba, 0x01c6, 0x01c9, 0x01cc, 0x01ce,
|
||||
0x01d0, 0x01d2, 0x01d4, 0x01d6, 0x01d8, 0x01da, 0x01dc, 0x01dd, 0x01df,
|
||||
0x01e1, 0x01e3, 0x01e5, 0x01e7, 0x01e9, 0x01eb, 0x01ed, 0x01ef, 0x01f0,
|
||||
0x01f3, 0x01f5, 0x01f9, 0x01fb, 0x01fd, 0x01ff, 0x0201, 0x0203, 0x0205,
|
||||
0x0207, 0x0209, 0x020b, 0x020d, 0x020f, 0x0211, 0x0213, 0x0215, 0x0217,
|
||||
0x0219, 0x021b, 0x021d, 0x021f, 0x0223, 0x0225, 0x0227, 0x0229, 0x022b,
|
||||
0x022d, 0x022f, 0x0231, 0x0233, 0x0390, 0x03d0, 0x03d1, 0x03db, 0x03dd,
|
||||
0x03df, 0x03e1, 0x03e3, 0x03e5, 0x03e7, 0x03e9, 0x03eb, 0x03ed, 0x03f5,
|
||||
0x0461, 0x0463, 0x0465, 0x0467, 0x0469, 0x046b, 0x046d, 0x046f, 0x0471,
|
||||
0x0473, 0x0475, 0x0477, 0x0479, 0x047b, 0x047d, 0x047f, 0x0481, 0x048d,
|
||||
0x048f, 0x0491, 0x0493, 0x0495, 0x0497, 0x0499, 0x049b, 0x049d, 0x049f,
|
||||
0x04a1, 0x04a3, 0x04a5, 0x04a7, 0x04a9, 0x04ab, 0x04ad, 0x04af, 0x04b1,
|
||||
0x04b3, 0x04b5, 0x04b7, 0x04b9, 0x04bb, 0x04bd, 0x04bf, 0x04c2, 0x04c4,
|
||||
0x04c8, 0x04cc, 0x04d1, 0x04d3, 0x04d5, 0x04d7, 0x04d9, 0x04db, 0x04dd,
|
||||
0x04df, 0x04e1, 0x04e3, 0x04e5, 0x04e7, 0x04e9, 0x04eb, 0x04ed, 0x04ef,
|
||||
0x04f1, 0x04f3, 0x04f5, 0x04f9, 0x1e01, 0x1e03, 0x1e05, 0x1e07, 0x1e09,
|
||||
0x1e0b, 0x1e0d, 0x1e0f, 0x1e11, 0x1e13, 0x1e15, 0x1e17, 0x1e19, 0x1e1b,
|
||||
0x1e1d, 0x1e1f, 0x1e21, 0x1e23, 0x1e25, 0x1e27, 0x1e29, 0x1e2b, 0x1e2d,
|
||||
0x1e2f, 0x1e31, 0x1e33, 0x1e35, 0x1e37, 0x1e39, 0x1e3b, 0x1e3d, 0x1e3f,
|
||||
0x1e41, 0x1e43, 0x1e45, 0x1e47, 0x1e49, 0x1e4b, 0x1e4d, 0x1e4f, 0x1e51,
|
||||
0x1e53, 0x1e55, 0x1e57, 0x1e59, 0x1e5b, 0x1e5d, 0x1e5f, 0x1e61, 0x1e63,
|
||||
0x1e65, 0x1e67, 0x1e69, 0x1e6b, 0x1e6d, 0x1e6f, 0x1e71, 0x1e73, 0x1e75,
|
||||
0x1e77, 0x1e79, 0x1e7b, 0x1e7d, 0x1e7f, 0x1e81, 0x1e83, 0x1e85, 0x1e87,
|
||||
0x1e89, 0x1e8b, 0x1e8d, 0x1e8f, 0x1e91, 0x1e93, 0x1ea1, 0x1ea3, 0x1ea5,
|
||||
0x1ea7, 0x1ea9, 0x1eab, 0x1ead, 0x1eaf, 0x1eb1, 0x1eb3, 0x1eb5, 0x1eb7,
|
||||
0x1eb9, 0x1ebb, 0x1ebd, 0x1ebf, 0x1ec1, 0x1ec3, 0x1ec5, 0x1ec7, 0x1ec9,
|
||||
0x1ecb, 0x1ecd, 0x1ecf, 0x1ed1, 0x1ed3, 0x1ed5, 0x1ed7, 0x1ed9, 0x1edb,
|
||||
0x1edd, 0x1edf, 0x1ee1, 0x1ee3, 0x1ee5, 0x1ee7, 0x1ee9, 0x1eeb, 0x1eed,
|
||||
0x1eef, 0x1ef1, 0x1ef3, 0x1ef5, 0x1ef7, 0x1ef9, 0x1fb6, 0x1fb7, 0x1fbe,
|
||||
0x1fc6, 0x1fc7, 0x1fd6, 0x1fd7, 0x1ff6, 0x1ff7, 0x207f, 0x210a, 0x210e,
|
||||
0x210f, 0x2113, 0x212f, 0x2134, 0x2139
|
||||
};
|
||||
|
||||
#define NUM_LOWER_CHAR (sizeof(lowerCharTable)/sizeof(chr))
|
||||
|
||||
/* Unicode: uppercase characters */
|
||||
|
||||
static crange upperRangeTable[] = {
|
||||
{0x0041, 0x005a}, {0x00c0, 0x00d6}, {0x00d8, 0x00de}, {0x0189, 0x018b},
|
||||
{0x018e, 0x0191}, {0x0196, 0x0198}, {0x01b1, 0x01b3}, {0x01f6, 0x01f8},
|
||||
{0x0388, 0x038a}, {0x0391, 0x03a1}, {0x03a3, 0x03ab}, {0x03d2, 0x03d4},
|
||||
{0x0400, 0x042f}, {0x0531, 0x0556}, {0x10a0, 0x10c5}, {0x1f08, 0x1f0f},
|
||||
{0x1f18, 0x1f1d}, {0x1f28, 0x1f2f}, {0x1f38, 0x1f3f}, {0x1f48, 0x1f4d},
|
||||
{0x1f68, 0x1f6f}, {0x1fb8, 0x1fbb}, {0x1fc8, 0x1fcb}, {0x1fd8, 0x1fdb},
|
||||
{0x1fe8, 0x1fec}, {0x1ff8, 0x1ffb}, {0x210b, 0x210d}, {0x2110, 0x2112},
|
||||
{0x2119, 0x211d}, {0x212a, 0x212d}, {0xff21, 0xff3a}
|
||||
};
|
||||
|
||||
#define NUM_UPPER_RANGE (sizeof(upperRangeTable)/sizeof(crange))
|
||||
|
||||
static chr upperCharTable[] = {
|
||||
0x0100, 0x0102, 0x0104, 0x0106, 0x0108, 0x010a, 0x010c, 0x010e, 0x0110,
|
||||
0x0112, 0x0114, 0x0116, 0x0118, 0x011a, 0x011c, 0x011e, 0x0120, 0x0122,
|
||||
0x0124, 0x0126, 0x0128, 0x012a, 0x012c, 0x012e, 0x0130, 0x0132, 0x0134,
|
||||
0x0136, 0x0139, 0x013b, 0x013d, 0x013f, 0x0141, 0x0143, 0x0145, 0x0147,
|
||||
0x014a, 0x014c, 0x014e, 0x0150, 0x0152, 0x0154, 0x0156, 0x0158, 0x015a,
|
||||
0x015c, 0x015e, 0x0160, 0x0162, 0x0164, 0x0166, 0x0168, 0x016a, 0x016c,
|
||||
0x016e, 0x0170, 0x0172, 0x0174, 0x0176, 0x0178, 0x0179, 0x017b, 0x017d,
|
||||
0x0181, 0x0182, 0x0184, 0x0186, 0x0187, 0x0193, 0x0194, 0x019c, 0x019d,
|
||||
0x019f, 0x01a0, 0x01a2, 0x01a4, 0x01a6, 0x01a7, 0x01a9, 0x01ac, 0x01ae,
|
||||
0x01af, 0x01b5, 0x01b7, 0x01b8, 0x01bc, 0x01c4, 0x01c7, 0x01ca, 0x01cd,
|
||||
0x01cf, 0x01d1, 0x01d3, 0x01d5, 0x01d7, 0x01d9, 0x01db, 0x01de, 0x01e0,
|
||||
0x01e2, 0x01e4, 0x01e6, 0x01e8, 0x01ea, 0x01ec, 0x01ee, 0x01f1, 0x01f4,
|
||||
0x01fa, 0x01fc, 0x01fe, 0x0200, 0x0202, 0x0204, 0x0206, 0x0208, 0x020a,
|
||||
0x020c, 0x020e, 0x0210, 0x0212, 0x0214, 0x0216, 0x0218, 0x021a, 0x021c,
|
||||
0x021e, 0x0222, 0x0224, 0x0226, 0x0228, 0x022a, 0x022c, 0x022e, 0x0230,
|
||||
0x0232, 0x0386, 0x038c, 0x038e, 0x038f, 0x03da, 0x03dc, 0x03de, 0x03e0,
|
||||
0x03e2, 0x03e4, 0x03e6, 0x03e8, 0x03ea, 0x03ec, 0x03ee, 0x03f4, 0x0460,
|
||||
0x0462, 0x0464, 0x0466, 0x0468, 0x046a, 0x046c, 0x046e, 0x0470, 0x0472,
|
||||
0x0474, 0x0476, 0x0478, 0x047a, 0x047c, 0x047e, 0x0480, 0x048c, 0x048e,
|
||||
0x0490, 0x0492, 0x0494, 0x0496, 0x0498, 0x049a, 0x049c, 0x049e, 0x04a0,
|
||||
0x04a2, 0x04a4, 0x04a6, 0x04a8, 0x04aa, 0x04ac, 0x04ae, 0x04b0, 0x04b2,
|
||||
0x04b4, 0x04b6, 0x04b8, 0x04ba, 0x04bc, 0x04be, 0x04c0, 0x04c1, 0x04c3,
|
||||
0x04c7, 0x04cb, 0x04d0, 0x04d2, 0x04d4, 0x04d6, 0x04d8, 0x04da, 0x04dc,
|
||||
0x04de, 0x04e0, 0x04e2, 0x04e4, 0x04e6, 0x04e8, 0x04ea, 0x04ec, 0x04ee,
|
||||
0x04f0, 0x04f2, 0x04f4, 0x04f8, 0x1e00, 0x1e02, 0x1e04, 0x1e06, 0x1e08,
|
||||
0x1e0a, 0x1e0c, 0x1e0e, 0x1e10, 0x1e12, 0x1e14, 0x1e16, 0x1e18, 0x1e1a,
|
||||
0x1e1c, 0x1e1e, 0x1e20, 0x1e22, 0x1e24, 0x1e26, 0x1e28, 0x1e2a, 0x1e2c,
|
||||
0x1e2e, 0x1e30, 0x1e32, 0x1e34, 0x1e36, 0x1e38, 0x1e3a, 0x1e3c, 0x1e3e,
|
||||
0x1e40, 0x1e42, 0x1e44, 0x1e46, 0x1e48, 0x1e4a, 0x1e4c, 0x1e4e, 0x1e50,
|
||||
0x1e52, 0x1e54, 0x1e56, 0x1e58, 0x1e5a, 0x1e5c, 0x1e5e, 0x1e60, 0x1e62,
|
||||
0x1e64, 0x1e66, 0x1e68, 0x1e6a, 0x1e6c, 0x1e6e, 0x1e70, 0x1e72, 0x1e74,
|
||||
0x1e76, 0x1e78, 0x1e7a, 0x1e7c, 0x1e7e, 0x1e80, 0x1e82, 0x1e84, 0x1e86,
|
||||
0x1e88, 0x1e8a, 0x1e8c, 0x1e8e, 0x1e90, 0x1e92, 0x1e94, 0x1ea0, 0x1ea2,
|
||||
0x1ea4, 0x1ea6, 0x1ea8, 0x1eaa, 0x1eac, 0x1eae, 0x1eb0, 0x1eb2, 0x1eb4,
|
||||
0x1eb6, 0x1eb8, 0x1eba, 0x1ebc, 0x1ebe, 0x1ec0, 0x1ec2, 0x1ec4, 0x1ec6,
|
||||
0x1ec8, 0x1eca, 0x1ecc, 0x1ece, 0x1ed0, 0x1ed2, 0x1ed4, 0x1ed6, 0x1ed8,
|
||||
0x1eda, 0x1edc, 0x1ede, 0x1ee0, 0x1ee2, 0x1ee4, 0x1ee6, 0x1ee8, 0x1eea,
|
||||
0x1eec, 0x1eee, 0x1ef0, 0x1ef2, 0x1ef4, 0x1ef6, 0x1ef8, 0x1f59, 0x1f5b,
|
||||
0x1f5d, 0x1f5f, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x2130,
|
||||
0x2131, 0x2133
|
||||
};
|
||||
|
||||
#define NUM_UPPER_CHAR (sizeof(upperCharTable)/sizeof(chr))
|
||||
|
||||
/* Unicode: unicode print characters excluding space */
|
||||
|
||||
static crange graphRangeTable[] = {
|
||||
{0x0021, 0x007e}, {0x00a0, 0x011f}, {0x0121, 0x021f}, {0x0222, 0x0233},
|
||||
{0x0250, 0x02ad}, {0x02b0, 0x02ee}, {0x0300, 0x031f}, {0x0321, 0x034e},
|
||||
{0x0360, 0x0362}, {0x0384, 0x038a}, {0x038e, 0x03a1}, {0x03a3, 0x03ce},
|
||||
{0x03d0, 0x03d7}, {0x03da, 0x03f5}, {0x0400, 0x041f}, {0x0421, 0x0486},
|
||||
{0x048c, 0x04c4}, {0x04d0, 0x04f5}, {0x0531, 0x0556}, {0x0559, 0x055f},
|
||||
{0x0561, 0x0587}, {0x0591, 0x05a1}, {0x05a3, 0x05b9}, {0x05bb, 0x05c4},
|
||||
{0x05d0, 0x05ea}, {0x05f0, 0x05f4}, {0x0621, 0x063a}, {0x0640, 0x0655},
|
||||
{0x0660, 0x066d}, {0x0670, 0x06ed}, {0x06f0, 0x06fe}, {0x0700, 0x070d},
|
||||
{0x0710, 0x071f}, {0x0721, 0x072c}, {0x0730, 0x074a}, {0x0780, 0x07b0},
|
||||
{0x0901, 0x0903}, {0x0905, 0x091f}, {0x0921, 0x0939}, {0x093c, 0x094d},
|
||||
{0x0950, 0x0954}, {0x0958, 0x0970}, {0x0981, 0x0983}, {0x0985, 0x098c},
|
||||
{0x0993, 0x09a8}, {0x09aa, 0x09b0}, {0x09b6, 0x09b9}, {0x09be, 0x09c4},
|
||||
{0x09cb, 0x09cd}, {0x09df, 0x09e3}, {0x09e6, 0x09fa}, {0x0a05, 0x0a0a},
|
||||
{0x0a13, 0x0a1f}, {0x0a21, 0x0a28}, {0x0a2a, 0x0a30}, {0x0a3e, 0x0a42},
|
||||
{0x0a4b, 0x0a4d}, {0x0a59, 0x0a5c}, {0x0a66, 0x0a74}, {0x0a81, 0x0a83},
|
||||
{0x0a85, 0x0a8b}, {0x0a8f, 0x0a91}, {0x0a93, 0x0aa8}, {0x0aaa, 0x0ab0},
|
||||
{0x0ab5, 0x0ab9}, {0x0abc, 0x0ac5}, {0x0ac7, 0x0ac9}, {0x0acb, 0x0acd},
|
||||
{0x0ae6, 0x0aef}, {0x0b01, 0x0b03}, {0x0b05, 0x0b0c}, {0x0b13, 0x0b1f},
|
||||
{0x0b21, 0x0b28}, {0x0b2a, 0x0b30}, {0x0b36, 0x0b39}, {0x0b3c, 0x0b43},
|
||||
{0x0b4b, 0x0b4d}, {0x0b5f, 0x0b61}, {0x0b66, 0x0b70}, {0x0b85, 0x0b8a},
|
||||
{0x0b8e, 0x0b90}, {0x0b92, 0x0b95}, {0x0ba8, 0x0baa}, {0x0bae, 0x0bb5},
|
||||
{0x0bb7, 0x0bb9}, {0x0bbe, 0x0bc2}, {0x0bc6, 0x0bc8}, {0x0bca, 0x0bcd},
|
||||
{0x0be7, 0x0bf2}, {0x0c01, 0x0c03}, {0x0c05, 0x0c0c}, {0x0c0e, 0x0c10},
|
||||
{0x0c12, 0x0c1f}, {0x0c21, 0x0c28}, {0x0c2a, 0x0c33}, {0x0c35, 0x0c39},
|
||||
{0x0c3e, 0x0c44}, {0x0c46, 0x0c48}, {0x0c4a, 0x0c4d}, {0x0c66, 0x0c6f},
|
||||
{0x0c85, 0x0c8c}, {0x0c8e, 0x0c90}, {0x0c92, 0x0ca8}, {0x0caa, 0x0cb3},
|
||||
{0x0cb5, 0x0cb9}, {0x0cbe, 0x0cc4}, {0x0cc6, 0x0cc8}, {0x0cca, 0x0ccd},
|
||||
{0x0ce6, 0x0cef}, {0x0d05, 0x0d0c}, {0x0d0e, 0x0d10}, {0x0d12, 0x0d1f},
|
||||
{0x0d21, 0x0d28}, {0x0d2a, 0x0d39}, {0x0d3e, 0x0d43}, {0x0d46, 0x0d48},
|
||||
{0x0d4a, 0x0d4d}, {0x0d66, 0x0d6f}, {0x0d85, 0x0d96}, {0x0d9a, 0x0db1},
|
||||
{0x0db3, 0x0dbb}, {0x0dc0, 0x0dc6}, {0x0dcf, 0x0dd4}, {0x0dd8, 0x0ddf},
|
||||
{0x0df2, 0x0df4}, {0x0e01, 0x0e1f}, {0x0e21, 0x0e3a}, {0x0e3f, 0x0e5b},
|
||||
{0x0e94, 0x0e97}, {0x0e99, 0x0e9f}, {0x0ea1, 0x0ea3}, {0x0ead, 0x0eb9},
|
||||
{0x0ebb, 0x0ebd}, {0x0ec0, 0x0ec4}, {0x0ec8, 0x0ecd}, {0x0ed0, 0x0ed9},
|
||||
{0x0f00, 0x0f1f}, {0x0f21, 0x0f47}, {0x0f49, 0x0f6a}, {0x0f71, 0x0f8b},
|
||||
{0x0f90, 0x0f97}, {0x0f99, 0x0fbc}, {0x0fbe, 0x0fcc}, {0x1000, 0x101f},
|
||||
{0x1023, 0x1027}, {0x102c, 0x1032}, {0x1036, 0x1039}, {0x1040, 0x1059},
|
||||
{0x10a0, 0x10c5}, {0x10d0, 0x10f6}, {0x1100, 0x111f}, {0x1121, 0x1159},
|
||||
{0x115f, 0x11a2}, {0x11a8, 0x11f9}, {0x1200, 0x1206}, {0x1208, 0x121f},
|
||||
{0x1221, 0x1246}, {0x124a, 0x124d}, {0x1250, 0x1256}, {0x125a, 0x125d},
|
||||
{0x1260, 0x1286}, {0x128a, 0x128d}, {0x1290, 0x12ae}, {0x12b2, 0x12b5},
|
||||
{0x12b8, 0x12be}, {0x12c2, 0x12c5}, {0x12c8, 0x12ce}, {0x12d0, 0x12d6},
|
||||
{0x12d8, 0x12ee}, {0x12f0, 0x130e}, {0x1312, 0x1315}, {0x1318, 0x131e},
|
||||
{0x1321, 0x1346}, {0x1348, 0x135a}, {0x1361, 0x137c}, {0x13a0, 0x13f4},
|
||||
{0x1401, 0x141f}, {0x1421, 0x151f}, {0x1521, 0x161f}, {0x1621, 0x1676},
|
||||
{0x1680, 0x169c}, {0x16a0, 0x16f0}, {0x1780, 0x17dc}, {0x17e0, 0x17e9},
|
||||
{0x1800, 0x180a}, {0x1810, 0x1819}, {0x1821, 0x1877}, {0x1880, 0x18a9},
|
||||
{0x1e00, 0x1e1f}, {0x1e21, 0x1e9b}, {0x1ea0, 0x1ef9}, {0x1f00, 0x1f15},
|
||||
{0x1f18, 0x1f1d}, {0x1f21, 0x1f45}, {0x1f48, 0x1f4d}, {0x1f50, 0x1f57},
|
||||
{0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, {0x1fb6, 0x1fc4}, {0x1fc6, 0x1fd3},
|
||||
{0x1fd6, 0x1fdb}, {0x1fdd, 0x1fef}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffe},
|
||||
{0x2000, 0x200b}, {0x2010, 0x201f}, {0x2021, 0x2029}, {0x202f, 0x2046},
|
||||
{0x2048, 0x204d}, {0x2074, 0x208e}, {0x20a0, 0x20af}, {0x20d0, 0x20e3},
|
||||
{0x2100, 0x211f}, {0x2121, 0x213a}, {0x2153, 0x2183}, {0x2190, 0x21f3},
|
||||
{0x2200, 0x221f}, {0x2221, 0x22f1}, {0x2300, 0x231f}, {0x2321, 0x237b},
|
||||
{0x237d, 0x239a}, {0x2400, 0x241f}, {0x2421, 0x2426}, {0x2440, 0x244a},
|
||||
{0x2460, 0x24ea}, {0x2500, 0x251f}, {0x2521, 0x2595}, {0x25a0, 0x25f7},
|
||||
{0x2600, 0x2613}, {0x2619, 0x261f}, {0x2621, 0x2671}, {0x2701, 0x2704},
|
||||
{0x2706, 0x2709}, {0x270c, 0x271f}, {0x2721, 0x2727}, {0x2729, 0x274b},
|
||||
{0x274f, 0x2752}, {0x2758, 0x275e}, {0x2761, 0x2767}, {0x2776, 0x2794},
|
||||
{0x2798, 0x27af}, {0x27b1, 0x27be}, {0x2800, 0x281f}, {0x2821, 0x28ff},
|
||||
{0x2e80, 0x2e99}, {0x2e9b, 0x2ef3}, {0x2f00, 0x2f1f}, {0x2f21, 0x2fd5},
|
||||
{0x2ff0, 0x2ffb}, {0x3000, 0x301f}, {0x3021, 0x303a}, {0x3041, 0x3094},
|
||||
{0x3099, 0x309e}, {0x30a1, 0x30fe}, {0x3105, 0x311f}, {0x3121, 0x312c},
|
||||
{0x3131, 0x318e}, {0x3190, 0x31b7}, {0x3200, 0x321c}, {0x3221, 0x3243},
|
||||
{0x3260, 0x327b}, {0x327f, 0x32b0}, {0x32c0, 0x32cb}, {0x32d0, 0x32fe},
|
||||
{0x3300, 0x331f}, {0x3321, 0x3376}, {0x337b, 0x33dd}, {0x33e0, 0x33fe},
|
||||
{0x3400, 0x341f}, {0x3421, 0x351f}, {0x3521, 0x361f}, {0x3621, 0x371f},
|
||||
{0x3721, 0x381f}, {0x3821, 0x391f}, {0x3921, 0x3a1f}, {0x3a21, 0x3b1f},
|
||||
{0x3b21, 0x3c1f}, {0x3c21, 0x3d1f}, {0x3d21, 0x3e1f}, {0x3e21, 0x3f1f},
|
||||
{0x3f21, 0x401f}, {0x4021, 0x411f}, {0x4121, 0x421f}, {0x4221, 0x431f},
|
||||
{0x4321, 0x441f}, {0x4421, 0x451f}, {0x4521, 0x461f}, {0x4621, 0x471f},
|
||||
{0x4721, 0x481f}, {0x4821, 0x491f}, {0x4921, 0x4a1f}, {0x4a21, 0x4b1f},
|
||||
{0x4b21, 0x4c1f}, {0x4c21, 0x4d1f}, {0x4d21, 0x4db5}, {0x4e00, 0x4e1f},
|
||||
{0x4e21, 0x4f1f}, {0x4f21, 0x501f}, {0x5021, 0x511f}, {0x5121, 0x521f},
|
||||
{0x5221, 0x531f}, {0x5321, 0x541f}, {0x5421, 0x551f}, {0x5521, 0x561f},
|
||||
{0x5621, 0x571f}, {0x5721, 0x581f}, {0x5821, 0x591f}, {0x5921, 0x5a1f},
|
||||
{0x5a21, 0x5b1f}, {0x5b21, 0x5c1f}, {0x5c21, 0x5d1f}, {0x5d21, 0x5e1f},
|
||||
{0x5e21, 0x5f1f}, {0x5f21, 0x601f}, {0x6021, 0x611f}, {0x6121, 0x621f},
|
||||
{0x6221, 0x631f}, {0x6321, 0x641f}, {0x6421, 0x651f}, {0x6521, 0x661f},
|
||||
{0x6621, 0x671f}, {0x6721, 0x681f}, {0x6821, 0x691f}, {0x6921, 0x6a1f},
|
||||
{0x6a21, 0x6b1f}, {0x6b21, 0x6c1f}, {0x6c21, 0x6d1f}, {0x6d21, 0x6e1f},
|
||||
{0x6e21, 0x6f1f}, {0x6f21, 0x701f}, {0x7021, 0x711f}, {0x7121, 0x721f},
|
||||
{0x7221, 0x731f}, {0x7321, 0x741f}, {0x7421, 0x751f}, {0x7521, 0x761f},
|
||||
{0x7621, 0x771f}, {0x7721, 0x781f}, {0x7821, 0x791f}, {0x7921, 0x7a1f},
|
||||
{0x7a21, 0x7b1f}, {0x7b21, 0x7c1f}, {0x7c21, 0x7d1f}, {0x7d21, 0x7e1f},
|
||||
{0x7e21, 0x7f1f}, {0x7f21, 0x801f}, {0x8021, 0x811f}, {0x8121, 0x821f},
|
||||
{0x8221, 0x831f}, {0x8321, 0x841f}, {0x8421, 0x851f}, {0x8521, 0x861f},
|
||||
{0x8621, 0x871f}, {0x8721, 0x881f}, {0x8821, 0x891f}, {0x8921, 0x8a1f},
|
||||
{0x8a21, 0x8b1f}, {0x8b21, 0x8c1f}, {0x8c21, 0x8d1f}, {0x8d21, 0x8e1f},
|
||||
{0x8e21, 0x8f1f}, {0x8f21, 0x901f}, {0x9021, 0x911f}, {0x9121, 0x921f},
|
||||
{0x9221, 0x931f}, {0x9321, 0x941f}, {0x9421, 0x951f}, {0x9521, 0x961f},
|
||||
{0x9621, 0x971f}, {0x9721, 0x981f}, {0x9821, 0x991f}, {0x9921, 0x9a1f},
|
||||
{0x9a21, 0x9b1f}, {0x9b21, 0x9c1f}, {0x9c21, 0x9d1f}, {0x9d21, 0x9e1f},
|
||||
{0x9e21, 0x9f1f}, {0x9f21, 0x9fa5}, {0xa000, 0xa01f}, {0xa021, 0xa11f},
|
||||
{0xa121, 0xa21f}, {0xa221, 0xa31f}, {0xa321, 0xa41f}, {0xa421, 0xa48c},
|
||||
{0xa490, 0xa4a1}, {0xa4a4, 0xa4b3}, {0xa4b5, 0xa4c0}, {0xa4c2, 0xa4c4},
|
||||
{0xac00, 0xac1f}, {0xac21, 0xad1f}, {0xad21, 0xae1f}, {0xae21, 0xaf1f},
|
||||
{0xaf21, 0xb01f}, {0xb021, 0xb11f}, {0xb121, 0xb21f}, {0xb221, 0xb31f},
|
||||
{0xb321, 0xb41f}, {0xb421, 0xb51f}, {0xb521, 0xb61f}, {0xb621, 0xb71f},
|
||||
{0xb721, 0xb81f}, {0xb821, 0xb91f}, {0xb921, 0xba1f}, {0xba21, 0xbb1f},
|
||||
{0xbb21, 0xbc1f}, {0xbc21, 0xbd1f}, {0xbd21, 0xbe1f}, {0xbe21, 0xbf1f},
|
||||
{0xbf21, 0xc01f}, {0xc021, 0xc11f}, {0xc121, 0xc21f}, {0xc221, 0xc31f},
|
||||
{0xc321, 0xc41f}, {0xc421, 0xc51f}, {0xc521, 0xc61f}, {0xc621, 0xc71f},
|
||||
{0xc721, 0xc81f}, {0xc821, 0xc91f}, {0xc921, 0xca1f}, {0xca21, 0xcb1f},
|
||||
{0xcb21, 0xcc1f}, {0xcc21, 0xcd1f}, {0xcd21, 0xce1f}, {0xce21, 0xcf1f},
|
||||
{0xcf21, 0xd01f}, {0xd021, 0xd11f}, {0xd121, 0xd21f}, {0xd221, 0xd31f},
|
||||
{0xd321, 0xd41f}, {0xd421, 0xd51f}, {0xd521, 0xd61f}, {0xd621, 0xd71f},
|
||||
{0xd721, 0xd7a3}, {0xf900, 0xf91f}, {0xf921, 0xfa1f}, {0xfa21, 0xfa2d},
|
||||
{0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xfb1d, 0xfb1f}, {0xfb21, 0xfb36},
|
||||
{0xfb38, 0xfb3c}, {0xfb46, 0xfbb1}, {0xfbd3, 0xfc1f}, {0xfc21, 0xfd1f},
|
||||
{0xfd21, 0xfd3f}, {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7}, {0xfdf0, 0xfdfb},
|
||||
{0xfe21, 0xfe23}, {0xfe30, 0xfe44}, {0xfe49, 0xfe52}, {0xfe54, 0xfe66},
|
||||
{0xfe68, 0xfe6b}, {0xfe70, 0xfe72}, {0xfe76, 0xfefc}, {0xff01, 0xff1f},
|
||||
{0xff21, 0xff5e}, {0xff61, 0xffbe}, {0xffc2, 0xffc7}, {0xffca, 0xffcf},
|
||||
{0xffd2, 0xffd7}, {0xffda, 0xffdc}, {0xffe0, 0xffe6}, {0xffe8, 0xffee},
|
||||
{0xfffc, 0xffff}
|
||||
};
|
||||
|
||||
#define NUM_GRAPH_RANGE (sizeof(graphRangeTable)/sizeof(crange))
|
||||
|
||||
static chr graphCharTable[] = {
|
||||
0x0374, 0x0375, 0x037a, 0x037e, 0x038c, 0x0488, 0x0489, 0x04c7, 0x04c8,
|
||||
0x04cb, 0x04cc, 0x04f8, 0x04f9, 0x0589, 0x058a, 0x060c, 0x061b, 0x061f,
|
||||
0x098f, 0x0990, 0x09b2, 0x09bc, 0x09c7, 0x09c8, 0x09d7, 0x09dc, 0x09dd,
|
||||
0x0a02, 0x0a0f, 0x0a10, 0x0a32, 0x0a33, 0x0a35, 0x0a36, 0x0a38, 0x0a39,
|
||||
0x0a3c, 0x0a47, 0x0a48, 0x0a5e, 0x0a8d, 0x0ab2, 0x0ab3, 0x0ad0, 0x0ae0,
|
||||
0x0b0f, 0x0b10, 0x0b32, 0x0b33, 0x0b47, 0x0b48, 0x0b56, 0x0b57, 0x0b5c,
|
||||
0x0b5d, 0x0b82, 0x0b83, 0x0b99, 0x0b9a, 0x0b9c, 0x0b9e, 0x0b9f, 0x0ba3,
|
||||
0x0ba4, 0x0bd7, 0x0c55, 0x0c56, 0x0c60, 0x0c61, 0x0c82, 0x0c83, 0x0cd5,
|
||||
0x0cd6, 0x0cde, 0x0ce0, 0x0ce1, 0x0d02, 0x0d03, 0x0d57, 0x0d60, 0x0d61,
|
||||
0x0d82, 0x0d83, 0x0dbd, 0x0dca, 0x0dd6, 0x0e81, 0x0e82, 0x0e84, 0x0e87,
|
||||
0x0e88, 0x0e8a, 0x0e8d, 0x0ea5, 0x0ea7, 0x0eaa, 0x0eab, 0x0ec6, 0x0edc,
|
||||
0x0edd, 0x0fcf, 0x1021, 0x1029, 0x102a, 0x10fb, 0x1248, 0x1258, 0x1288,
|
||||
0x12b0, 0x12c0, 0x1310, 0x1f59, 0x1f5b, 0x1f5d, 0x2070, 0x274d, 0x2756,
|
||||
0x303e, 0x303f, 0xa4c6, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfe74
|
||||
};
|
||||
|
||||
#define NUM_GRAPH_CHAR (sizeof(graphCharTable)/sizeof(chr))
|
||||
|
||||
/*
|
||||
* End of auto-generated Unicode character ranges declarations.
|
||||
*/
|
||||
|
||||
#define CH NOCELT
|
||||
|
||||
/*
|
||||
- nmcces - how many distinct MCCEs are there?
|
||||
^ static int nmcces(struct vars *);
|
||||
*/
|
||||
static int
|
||||
nmcces(v)
|
||||
struct vars *v; /* context */
|
||||
{
|
||||
/*
|
||||
* No multi-character collating elements defined at the moment.
|
||||
*/
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
- nleaders - how many chrs can be first chrs of MCCEs?
|
||||
^ static int nleaders(struct vars *);
|
||||
*/
|
||||
static int
|
||||
nleaders(v)
|
||||
struct vars *v; /* context */
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
- allmcces - return a cvec with all the MCCEs of the locale
|
||||
^ static struct cvec *allmcces(struct vars *, struct cvec *);
|
||||
*/
|
||||
static struct cvec *
|
||||
allmcces(v, cv)
|
||||
struct vars *v; /* context */
|
||||
struct cvec *cv; /* this is supposed to have enough room */
|
||||
{
|
||||
return clearcvec(cv);
|
||||
}
|
||||
|
||||
/*
|
||||
- element - map collating-element name to celt
|
||||
^ static celt element(struct vars *, chr *, chr *);
|
||||
*/
|
||||
static celt
|
||||
element(v, startp, endp)
|
||||
struct vars *v; /* context */
|
||||
chr *startp; /* points to start of name */
|
||||
chr *endp; /* points just past end of name */
|
||||
{
|
||||
struct cname *cn;
|
||||
size_t len;
|
||||
Tcl_DString ds;
|
||||
CONST char *np;
|
||||
|
||||
/* generic: one-chr names stand for themselves */
|
||||
assert(startp < endp);
|
||||
len = endp - startp;
|
||||
if (len == 1) {
|
||||
return *startp;
|
||||
}
|
||||
|
||||
NOTE(REG_ULOCALE);
|
||||
|
||||
/* search table */
|
||||
Tcl_DStringInit(&ds);
|
||||
np = Tcl_UniCharToUtfDString(startp, (int)len, &ds);
|
||||
for (cn=cnames; cn->name!=NULL; cn++) {
|
||||
if (strlen(cn->name)==len && strncmp(cn->name, np, len)==0) {
|
||||
break; /* NOTE BREAK OUT */
|
||||
}
|
||||
}
|
||||
Tcl_DStringFree(&ds);
|
||||
if (cn->name != NULL) {
|
||||
return CHR(cn->code);
|
||||
}
|
||||
|
||||
/* couldn't find it */
|
||||
ERR(REG_ECOLLATE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
- range - supply cvec for a range, including legality check
|
||||
^ static struct cvec *range(struct vars *, celt, celt, int);
|
||||
*/
|
||||
static struct cvec *
|
||||
range(v, a, b, cases)
|
||||
struct vars *v; /* context */
|
||||
celt a; /* range start */
|
||||
celt b; /* range end, might equal a */
|
||||
int cases; /* case-independent? */
|
||||
{
|
||||
int nchrs;
|
||||
struct cvec *cv;
|
||||
celt c, lc, uc, tc;
|
||||
|
||||
if (a != b && !before(a, b)) {
|
||||
ERR(REG_ERANGE);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!cases) { /* easy version */
|
||||
cv = getcvec(v, 0, 1, 0);
|
||||
NOERRN();
|
||||
addrange(cv, a, b);
|
||||
return cv;
|
||||
}
|
||||
|
||||
/*
|
||||
* When case-independent, it's hard to decide when cvec ranges are
|
||||
* usable, so for now at least, we won't try. We allocate enough
|
||||
* space for two case variants plus a little extra for the two
|
||||
* title case variants.
|
||||
*/
|
||||
|
||||
nchrs = (b - a + 1)*2 + 4;
|
||||
|
||||
cv = getcvec(v, nchrs, 0, 0);
|
||||
NOERRN();
|
||||
|
||||
for (c=a; c<=b; c++) {
|
||||
addchr(cv, c);
|
||||
lc = Tcl_UniCharToLower((chr)c);
|
||||
uc = Tcl_UniCharToUpper((chr)c);
|
||||
tc = Tcl_UniCharToTitle((chr)c);
|
||||
if (c != lc) {
|
||||
addchr(cv, lc);
|
||||
}
|
||||
if (c != uc) {
|
||||
addchr(cv, uc);
|
||||
}
|
||||
if (c != tc && tc != uc) {
|
||||
addchr(cv, tc);
|
||||
}
|
||||
}
|
||||
|
||||
return cv;
|
||||
}
|
||||
|
||||
/*
|
||||
- before - is celt x before celt y, for purposes of range legality?
|
||||
^ static int before(celt, celt);
|
||||
*/
|
||||
static int /* predicate */
|
||||
before(x, y)
|
||||
celt x, y; /* collating elements */
|
||||
{
|
||||
/* trivial because no MCCEs */
|
||||
if (x < y) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
- eclass - supply cvec for an equivalence class
|
||||
* Must include case counterparts on request.
|
||||
^ static struct cvec *eclass(struct vars *, celt, int);
|
||||
*/
|
||||
static struct cvec *
|
||||
eclass(v, c, cases)
|
||||
struct vars *v; /* context */
|
||||
celt c; /* Collating element representing
|
||||
* the equivalence class. */
|
||||
int cases; /* all cases? */
|
||||
{
|
||||
struct cvec *cv;
|
||||
|
||||
/* crude fake equivalence class for testing */
|
||||
if ((v->cflags®_FAKE) && c == 'x') {
|
||||
cv = getcvec(v, 4, 0, 0);
|
||||
addchr(cv, (chr)'x');
|
||||
addchr(cv, (chr)'y');
|
||||
if (cases) {
|
||||
addchr(cv, (chr)'X');
|
||||
addchr(cv, (chr)'Y');
|
||||
}
|
||||
return cv;
|
||||
}
|
||||
|
||||
/* otherwise, none */
|
||||
if (cases) {
|
||||
return allcases(v, c);
|
||||
}
|
||||
cv = getcvec(v, 1, 0, 0);
|
||||
assert(cv != NULL);
|
||||
addchr(cv, (chr)c);
|
||||
return cv;
|
||||
}
|
||||
|
||||
/*
|
||||
- cclass - supply cvec for a character class
|
||||
* Must include case counterparts on request.
|
||||
^ static struct cvec *cclass(struct vars *, chr *, chr *, int);
|
||||
*/
|
||||
static struct cvec *
|
||||
cclass(v, startp, endp, cases)
|
||||
struct vars *v; /* context */
|
||||
chr *startp; /* where the name starts */
|
||||
chr *endp; /* just past the end of the name */
|
||||
int cases; /* case-independent? */
|
||||
{
|
||||
size_t len;
|
||||
struct cvec *cv = NULL;
|
||||
Tcl_DString ds;
|
||||
CONST char *np;
|
||||
char **namePtr;
|
||||
int i, index;
|
||||
|
||||
/*
|
||||
* The following arrays define the valid character class names.
|
||||
*/
|
||||
|
||||
static char *classNames[] = {
|
||||
"alnum", "alpha", "ascii", "blank", "cntrl", "digit", "graph",
|
||||
"lower", "print", "punct", "space", "upper", "xdigit", NULL
|
||||
};
|
||||
|
||||
enum classes {
|
||||
CC_ALNUM, CC_ALPHA, CC_ASCII, CC_BLANK, CC_CNTRL, CC_DIGIT, CC_GRAPH,
|
||||
CC_LOWER, CC_PRINT, CC_PUNCT, CC_SPACE, CC_UPPER, CC_XDIGIT
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Extract the class name
|
||||
*/
|
||||
|
||||
len = endp - startp;
|
||||
Tcl_DStringInit(&ds);
|
||||
np = Tcl_UniCharToUtfDString(startp, (int)len, &ds);
|
||||
|
||||
/*
|
||||
* Remap lower and upper to alpha if the match is case insensitive.
|
||||
*/
|
||||
|
||||
if (cases && len == 5 && (strncmp("lower", np, 5) == 0
|
||||
|| strncmp("upper", np, 5) == 0)) {
|
||||
np = "alpha";
|
||||
}
|
||||
|
||||
/*
|
||||
* Map the name to the corresponding enumerated value.
|
||||
*/
|
||||
|
||||
index = -1;
|
||||
for (namePtr=classNames,i=0 ; *namePtr!=NULL ; namePtr++,i++) {
|
||||
if ((strlen(*namePtr) == len) && (strncmp(*namePtr, np, len) == 0)) {
|
||||
index = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
Tcl_DStringInit(&ds);
|
||||
if (index == -1) {
|
||||
ERR(REG_ECTYPE);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Now compute the character class contents.
|
||||
*/
|
||||
|
||||
switch((enum classes) index) {
|
||||
case CC_PRINT:
|
||||
case CC_ALNUM:
|
||||
cv = getcvec(v, NUM_ALPHA_CHAR, NUM_DIGIT_RANGE + NUM_ALPHA_RANGE, 0);
|
||||
if (cv) {
|
||||
for (i=0 ; i<NUM_ALPHA_CHAR ; i++) {
|
||||
addchr(cv, alphaCharTable[i]);
|
||||
}
|
||||
for (i=0 ; i<NUM_ALPHA_RANGE ; i++) {
|
||||
addrange(cv, alphaRangeTable[i].start,
|
||||
alphaRangeTable[i].end);
|
||||
}
|
||||
for (i=0 ; i<NUM_DIGIT_RANGE ; i++) {
|
||||
addrange(cv, digitRangeTable[i].start,
|
||||
digitRangeTable[i].end);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case CC_ALPHA:
|
||||
cv = getcvec(v, NUM_ALPHA_CHAR, NUM_ALPHA_RANGE, 0);
|
||||
if (cv) {
|
||||
for (i=0 ; i<NUM_ALPHA_RANGE ; i++) {
|
||||
addrange(cv, alphaRangeTable[i].start,
|
||||
alphaRangeTable[i].end);
|
||||
}
|
||||
for (i=0 ; i<NUM_ALPHA_CHAR ; i++) {
|
||||
addchr(cv, alphaCharTable[i]);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case CC_ASCII:
|
||||
cv = getcvec(v, 0, 1, 0);
|
||||
if (cv) {
|
||||
addrange(cv, 0, 0x7f);
|
||||
}
|
||||
break;
|
||||
case CC_BLANK:
|
||||
cv = getcvec(v, 2, 0, 0);
|
||||
addchr(cv, '\t');
|
||||
addchr(cv, ' ');
|
||||
break;
|
||||
case CC_CNTRL:
|
||||
cv = getcvec(v, 0, 2, 0);
|
||||
addrange(cv, 0x0, 0x1f);
|
||||
addrange(cv, 0x7f, 0x9f);
|
||||
break;
|
||||
case CC_DIGIT:
|
||||
cv = getcvec(v, 0, NUM_DIGIT_RANGE, 0);
|
||||
if (cv) {
|
||||
for (i=0 ; i<NUM_DIGIT_RANGE ; i++) {
|
||||
addrange(cv, digitRangeTable[i].start,
|
||||
digitRangeTable[i].end);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case CC_PUNCT:
|
||||
cv = getcvec(v, NUM_PUNCT_CHAR, NUM_PUNCT_RANGE, 0);
|
||||
if (cv) {
|
||||
for (i=0 ; i<NUM_PUNCT_RANGE ; i++) {
|
||||
addrange(cv, punctRangeTable[i].start,
|
||||
punctRangeTable[i].end);
|
||||
}
|
||||
for (i=0 ; i<NUM_PUNCT_CHAR ; i++) {
|
||||
addchr(cv, punctCharTable[i]);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case CC_XDIGIT:
|
||||
/*
|
||||
* This is a 3 instead of (NUM_DIGIT_RANGE+2) because I've no
|
||||
* idea how to define the digits 'a' through 'f' in
|
||||
* non-western locales. The concept is quite possibly non
|
||||
* portable, or only used in contextx where the characters
|
||||
* used would be the western ones anyway! Whatever is
|
||||
* actually the case, the number of ranges is fixed (until
|
||||
* someone comes up with a better arrangement!)
|
||||
*/
|
||||
cv = getcvec(v, 0, 3, 0);
|
||||
if (cv) {
|
||||
addrange(cv, '0', '9');
|
||||
addrange(cv, 'a', 'f');
|
||||
addrange(cv, 'A', 'F');
|
||||
}
|
||||
break;
|
||||
case CC_SPACE:
|
||||
cv = getcvec(v, NUM_SPACE_CHAR, NUM_SPACE_RANGE, 0);
|
||||
if (cv) {
|
||||
for (i=0 ; i<NUM_SPACE_RANGE ; i++) {
|
||||
addrange(cv, spaceRangeTable[i].start,
|
||||
spaceRangeTable[i].end);
|
||||
}
|
||||
for (i=0 ; i<NUM_SPACE_CHAR ; i++) {
|
||||
addchr(cv, spaceCharTable[i]);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case CC_LOWER:
|
||||
cv = getcvec(v, NUM_LOWER_CHAR, NUM_LOWER_RANGE, 0);
|
||||
if (cv) {
|
||||
for (i=0 ; i<NUM_LOWER_RANGE ; i++) {
|
||||
addrange(cv, lowerRangeTable[i].start,
|
||||
lowerRangeTable[i].end);
|
||||
}
|
||||
for (i=0 ; i<NUM_LOWER_CHAR ; i++) {
|
||||
addchr(cv, lowerCharTable[i]);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case CC_UPPER:
|
||||
cv = getcvec(v, NUM_UPPER_CHAR, NUM_UPPER_RANGE, 0);
|
||||
if (cv) {
|
||||
for (i=0 ; i<NUM_UPPER_RANGE ; i++) {
|
||||
addrange(cv, upperRangeTable[i].start,
|
||||
upperRangeTable[i].end);
|
||||
}
|
||||
for (i=0 ; i<NUM_UPPER_CHAR ; i++) {
|
||||
addchr(cv, upperCharTable[i]);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case CC_GRAPH:
|
||||
cv = getcvec(v, NUM_GRAPH_CHAR, NUM_GRAPH_RANGE, 0);
|
||||
if (cv) {
|
||||
for (i=0 ; i<NUM_GRAPH_RANGE ; i++) {
|
||||
addrange(cv, graphRangeTable[i].start,
|
||||
graphRangeTable[i].end);
|
||||
}
|
||||
for (i=0 ; i<NUM_GRAPH_CHAR ; i++) {
|
||||
addchr(cv, graphCharTable[i]);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (cv == NULL) {
|
||||
ERR(REG_ESPACE);
|
||||
}
|
||||
return cv;
|
||||
}
|
||||
|
||||
/*
|
||||
- allcases - supply cvec for all case counterparts of a chr (including itself)
|
||||
* This is a shortcut, preferably an efficient one, for simple characters;
|
||||
* messy cases are done via range().
|
||||
^ static struct cvec *allcases(struct vars *, pchr);
|
||||
*/
|
||||
static struct cvec *
|
||||
allcases(v, pc)
|
||||
struct vars *v; /* context */
|
||||
pchr pc; /* character to get case equivs of */
|
||||
{
|
||||
struct cvec *cv;
|
||||
chr c = (chr)pc;
|
||||
chr lc, uc, tc;
|
||||
|
||||
lc = Tcl_UniCharToLower((chr)c);
|
||||
uc = Tcl_UniCharToUpper((chr)c);
|
||||
tc = Tcl_UniCharToTitle((chr)c);
|
||||
|
||||
if (tc != uc) {
|
||||
cv = getcvec(v, 3, 0, 0);
|
||||
addchr(cv, tc);
|
||||
} else {
|
||||
cv = getcvec(v, 2, 0, 0);
|
||||
}
|
||||
addchr(cv, lc);
|
||||
if (lc != uc) {
|
||||
addchr(cv, uc);
|
||||
}
|
||||
return cv;
|
||||
}
|
||||
|
||||
/*
|
||||
- cmp - chr-substring compare
|
||||
* Backrefs need this. It should preferably be efficient.
|
||||
* Note that it does not need to report anything except equal/unequal.
|
||||
* Note also that the length is exact, and the comparison should not
|
||||
* stop at embedded NULs!
|
||||
^ static int cmp(CONST chr *, CONST chr *, size_t);
|
||||
*/
|
||||
static int /* 0 for equal, nonzero for unequal */
|
||||
cmp(x, y, len)
|
||||
CONST chr *x, *y; /* strings to compare */
|
||||
size_t len; /* exact length of comparison */
|
||||
{
|
||||
return memcmp(VS(x), VS(y), len*sizeof(chr));
|
||||
}
|
||||
|
||||
/*
|
||||
- casecmp - case-independent chr-substring compare
|
||||
* REG_ICASE backrefs need this. It should preferably be efficient.
|
||||
* Note that it does not need to report anything except equal/unequal.
|
||||
* Note also that the length is exact, and the comparison should not
|
||||
* stop at embedded NULs!
|
||||
^ static int casecmp(CONST chr *, CONST chr *, size_t);
|
||||
*/
|
||||
static int /* 0 for equal, nonzero for unequal */
|
||||
casecmp(x, y, len)
|
||||
CONST chr *x, *y; /* strings to compare */
|
||||
size_t len; /* exact length of comparison */
|
||||
{
|
||||
for (; len > 0; len--, x++, y++) {
|
||||
if ((*x!=*y) && (Tcl_UniCharToLower(*x) != Tcl_UniCharToLower(*y))) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
1575
src/regex/regc_nfa.c
Normal file
1575
src/regex/regc_nfa.c
Normal file
File diff suppressed because it is too large
Load Diff
2179
src/regex/regcomp.c
Normal file
2179
src/regex/regcomp.c
Normal file
File diff suppressed because it is too large
Load Diff
120
src/regex/regcustom.h
Normal file
120
src/regex/regcustom.h
Normal file
@@ -0,0 +1,120 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/* headers if any */
|
||||
#include "tclInt.h"
|
||||
|
||||
/* overrides for regguts.h definitions, if any */
|
||||
#define FUNCPTR(name, args) (*name) _ANSI_ARGS_(args)
|
||||
#define MALLOC(n) ckalloc(n)
|
||||
#define FREE(p) ckfree(VS(p))
|
||||
#define REALLOC(p,n) ckrealloc(VS(p),n)
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Do not insert extras between the "begin" and "end" lines -- this
|
||||
* chunk is automatically extracted to be fitted into regex.h.
|
||||
*/
|
||||
/* --- begin --- */
|
||||
/* ensure certain things don't sneak in from system headers */
|
||||
#ifdef __REG_WIDE_T
|
||||
#undef __REG_WIDE_T
|
||||
#endif
|
||||
#ifdef __REG_WIDE_COMPILE
|
||||
#undef __REG_WIDE_COMPILE
|
||||
#endif
|
||||
#ifdef __REG_WIDE_EXEC
|
||||
#undef __REG_WIDE_EXEC
|
||||
#endif
|
||||
#ifdef __REG_REGOFF_T
|
||||
#undef __REG_REGOFF_T
|
||||
#endif
|
||||
#ifdef __REG_VOID_T
|
||||
#undef __REG_VOID_T
|
||||
#endif
|
||||
#ifdef __REG_CONST
|
||||
#undef __REG_CONST
|
||||
#endif
|
||||
#ifdef __REG_NOFRONT
|
||||
#undef __REG_NOFRONT
|
||||
#endif
|
||||
#ifdef __REG_NOCHAR
|
||||
#undef __REG_NOCHAR
|
||||
#endif
|
||||
/* interface types */
|
||||
#define __REG_WIDE_T Tcl_UniChar
|
||||
#define __REG_REGOFF_T long /* not really right, but good enough... */
|
||||
#define __REG_VOID_T VOID
|
||||
#define __REG_CONST CONST
|
||||
/* names and declarations */
|
||||
#define __REG_WIDE_COMPILE TclReComp
|
||||
#define __REG_WIDE_EXEC TclReExec
|
||||
#define __REG_NOFRONT /* don't want regcomp() and regexec() */
|
||||
#define __REG_NOCHAR /* or the char versions */
|
||||
#define regfree TclReFree
|
||||
#define regerror TclReError
|
||||
/* --- end --- */
|
||||
|
||||
|
||||
|
||||
/* internal character type and related */
|
||||
typedef Tcl_UniChar chr; /* the type itself */
|
||||
typedef int pchr; /* what it promotes to */
|
||||
typedef unsigned uchr; /* unsigned type that will hold a chr */
|
||||
typedef int celt; /* type to hold chr, MCCE number, or NOCELT */
|
||||
#define NOCELT (-1) /* celt value which is not valid chr or MCCE */
|
||||
#define CHR(c) (UCHAR(c)) /* turn char literal into chr literal */
|
||||
#define DIGITVAL(c) ((c)-'0') /* turn chr digit into its value */
|
||||
#if TCL_UTF_MAX > 3
|
||||
#define CHRBITS 32 /* bits in a chr; must not use sizeof */
|
||||
#define CHR_MIN 0x00000000 /* smallest and largest chr; the value */
|
||||
#define CHR_MAX 0xffffffff /* CHR_MAX-CHR_MIN+1 should fit in uchr */
|
||||
#else
|
||||
#define CHRBITS 16 /* bits in a chr; must not use sizeof */
|
||||
#define CHR_MIN 0x0000 /* smallest and largest chr; the value */
|
||||
#define CHR_MAX 0xffff /* CHR_MAX-CHR_MIN+1 should fit in uchr */
|
||||
#endif
|
||||
|
||||
/* functions operating on chr */
|
||||
#define iscalnum(x) Tcl_UniCharIsAlnum(x)
|
||||
#define iscalpha(x) Tcl_UniCharIsAlpha(x)
|
||||
#define iscdigit(x) Tcl_UniCharIsDigit(x)
|
||||
#define iscspace(x) Tcl_UniCharIsSpace(x)
|
||||
|
||||
/* name the external functions */
|
||||
#define compile TclReComp
|
||||
#define exec TclReExec
|
||||
|
||||
/* enable/disable debugging code (by whether REG_DEBUG is defined or not) */
|
||||
#if 0 /* no debug unless requested by makefile */
|
||||
#define REG_DEBUG /* */
|
||||
#endif
|
||||
|
||||
/* and pick up the standard header */
|
||||
#include "regex.h"
|
677
src/regex/rege_dfa.c
Normal file
677
src/regex/rege_dfa.c
Normal file
@@ -0,0 +1,677 @@
|
||||
/*
|
||||
* 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.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
- longest - longest-preferred matching engine
|
||||
^ static chr *longest(struct vars *, struct dfa *, chr *, chr *, int *);
|
||||
*/
|
||||
static chr * /* endpoint, or NULL */
|
||||
longest(v, d, start, stop, hitstopp)
|
||||
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®_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®_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®_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 *shortest(struct vars *, struct dfa *, chr *, chr *, chr *,
|
||||
^ chr **, int *);
|
||||
*/
|
||||
static chr * /* endpoint, or NULL */
|
||||
shortest(v, d, start, min, max, coldp, hitstopp)
|
||||
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®_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®_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®_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 *lastcold(struct vars *, struct dfa *);
|
||||
*/
|
||||
static chr * /* endpoint, or NULL */
|
||||
lastcold(v, d)
|
||||
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 *, struct cnfa *,
|
||||
^ struct colormap *, struct smalldfa *);
|
||||
*/
|
||||
static struct dfa *
|
||||
newdfa(v, cnfa, cm, small)
|
||||
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®_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 *);
|
||||
*/
|
||||
static VOID
|
||||
freedfa(d)
|
||||
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 *, int);
|
||||
*/
|
||||
static unsigned
|
||||
hash(uv, n)
|
||||
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 *, struct dfa *, chr *);
|
||||
*/
|
||||
static struct sset *
|
||||
initialize(v, d, start)
|
||||
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 *miss(struct vars *, struct dfa *, struct sset *,
|
||||
^ pcolor, chr *, chr *);
|
||||
*/
|
||||
static struct sset * /* NULL if goes to empty set */
|
||||
miss(v, d, css, co, cp, start)
|
||||
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 lacon(struct vars *, struct cnfa *, chr *, pcolor);
|
||||
*/
|
||||
static int /* predicate: constraint satisfied? */
|
||||
lacon(v, pcnfa, cp, co)
|
||||
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 *, struct dfa *, chr *, chr *);
|
||||
*/
|
||||
static struct sset *
|
||||
getvacant(v, d, cp, start)
|
||||
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 *, struct dfa *, chr *, chr *);
|
||||
*/
|
||||
static struct sset *
|
||||
pickss(v, d, cp, start)
|
||||
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;
|
||||
}
|
109
src/regex/regerror.c
Normal file
109
src/regex/regerror.c
Normal file
@@ -0,0 +1,109 @@
|
||||
/*
|
||||
* 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;
|
||||
}
|
18
src/regex/regerrs.h
Normal file
18
src/regex/regerrs.h
Normal file
@@ -0,0 +1,18 @@
|
||||
{ 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" },
|
341
src/regex/regex.h
Normal file
341
src/regex/regex.h
Normal file
@@ -0,0 +1,341 @@
|
||||
#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.
|
||||
*
|
||||
*
|
||||
*
|
||||
* Prototypes etc. marked with "^" within comments get gathered up (and
|
||||
* possibly edited) by the regfwd program and inserted near the bottom of
|
||||
* this file.
|
||||
*
|
||||
* We offer the option of declaring one wide-character version of the
|
||||
* RE functions as well as the char versions. To do that, define
|
||||
* __REG_WIDE_T to the type of wide characters (unfortunately, there
|
||||
* is no consensus that wchar_t is suitable) and __REG_WIDE_COMPILE and
|
||||
* __REG_WIDE_EXEC to the names to be used for the compile and execute
|
||||
* functions (suggestion: re_Xcomp and re_Xexec, where X is a letter
|
||||
* suggestive of the wide type, e.g. re_ucomp and re_uexec for Unicode).
|
||||
* For cranky old compilers, it may be necessary to do something like:
|
||||
* #define __REG_WIDE_COMPILE(a,b,c,d) re_Xcomp(a,b,c,d)
|
||||
* #define __REG_WIDE_EXEC(a,b,c,d,e,f,g) re_Xexec(a,b,c,d,e,f,g)
|
||||
* rather than just #defining the names as parameterless macros.
|
||||
*
|
||||
* For some specialized purposes, it may be desirable to suppress the
|
||||
* declarations of the "front end" functions, regcomp() and regexec(),
|
||||
* or of the char versions of the compile and execute functions. To
|
||||
* suppress the front-end functions, define __REG_NOFRONT. To suppress
|
||||
* the char versions, define __REG_NOCHAR.
|
||||
*
|
||||
* The right place to do those defines (and some others you may want, see
|
||||
* below) would be <sys/types.h>. If you don't have control of that file,
|
||||
* the right place to add your own defines to this file is marked below.
|
||||
* This is normally done automatically, by the makefile and regmkhdr, based
|
||||
* on the contents of regcustom.h.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* voodoo for C++
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Add your own defines, if needed, here.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Location where a chunk of regcustom.h is automatically spliced into
|
||||
* this file (working from its prototype, regproto.h).
|
||||
*/
|
||||
/* --- begin --- */
|
||||
/* ensure certain things don't sneak in from system headers */
|
||||
#ifdef __REG_WIDE_T
|
||||
#undef __REG_WIDE_T
|
||||
#endif
|
||||
#ifdef __REG_WIDE_COMPILE
|
||||
#undef __REG_WIDE_COMPILE
|
||||
#endif
|
||||
#ifdef __REG_WIDE_EXEC
|
||||
#undef __REG_WIDE_EXEC
|
||||
#endif
|
||||
#ifdef __REG_REGOFF_T
|
||||
#undef __REG_REGOFF_T
|
||||
#endif
|
||||
#ifdef __REG_VOID_T
|
||||
#undef __REG_VOID_T
|
||||
#endif
|
||||
#ifdef __REG_CONST
|
||||
#undef __REG_CONST
|
||||
#endif
|
||||
#ifdef __REG_NOFRONT
|
||||
#undef __REG_NOFRONT
|
||||
#endif
|
||||
#ifdef __REG_NOCHAR
|
||||
#undef __REG_NOCHAR
|
||||
#endif
|
||||
/* interface types */
|
||||
#define __REG_WIDE_T Tcl_UniChar
|
||||
#define __REG_REGOFF_T long /* not really right, but good enough... */
|
||||
#define __REG_VOID_T VOID
|
||||
#define __REG_CONST CONST
|
||||
/* names and declarations */
|
||||
#define __REG_WIDE_COMPILE TclReComp
|
||||
#define __REG_WIDE_EXEC TclReExec
|
||||
#define __REG_NOFRONT /* don't want regcomp() and regexec() */
|
||||
#define __REG_NOCHAR /* or the char versions */
|
||||
#define regfree TclReFree
|
||||
#define regerror TclReError
|
||||
/* --- end --- */
|
||||
|
||||
|
||||
/*
|
||||
* 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, so we
|
||||
* offer <sys/types.h> an override.
|
||||
*/
|
||||
#ifdef __REG_REGOFF_T
|
||||
typedef __REG_REGOFF_T regoff_t;
|
||||
#else
|
||||
typedef long regoff_t;
|
||||
#endif
|
||||
|
||||
/*
|
||||
* For benefit of old compilers, we offer <sys/types.h> the option of
|
||||
* overriding the `void' type used to declare nonexistent return types.
|
||||
*/
|
||||
#ifdef __REG_VOID_T
|
||||
typedef __REG_VOID_T re_void;
|
||||
#else
|
||||
typedef void re_void;
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Also for benefit of old compilers, <sys/types.h> can supply a macro
|
||||
* which expands to a substitute for `const'.
|
||||
*/
|
||||
#ifndef __REG_CONST
|
||||
#define __REG_CONST const
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* 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;
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* compilation
|
||||
^ #ifndef __REG_NOCHAR
|
||||
^ int re_comp(regex_t *, __REG_CONST char *, size_t, int);
|
||||
^ #endif
|
||||
^ #ifndef __REG_NOFRONT
|
||||
^ int regcomp(regex_t *, __REG_CONST char *, int);
|
||||
^ #endif
|
||||
^ #ifdef __REG_WIDE_T
|
||||
^ int __REG_WIDE_COMPILE(regex_t *, __REG_CONST __REG_WIDE_T *, size_t, int);
|
||||
^ #endif
|
||||
*/
|
||||
#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 :-) */
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* execution
|
||||
^ #ifndef __REG_NOCHAR
|
||||
^ int re_exec(regex_t *, __REG_CONST char *, size_t,
|
||||
^ rm_detail_t *, size_t, regmatch_t [], int);
|
||||
^ #endif
|
||||
^ #ifndef __REG_NOFRONT
|
||||
^ int regexec(regex_t *, __REG_CONST char *, size_t, regmatch_t [], int);
|
||||
^ #endif
|
||||
^ #ifdef __REG_WIDE_T
|
||||
^ int __REG_WIDE_EXEC(regex_t *, __REG_CONST __REG_WIDE_T *, size_t,
|
||||
^ rm_detail_t *, size_t, regmatch_t [], int);
|
||||
^ #endif
|
||||
*/
|
||||
#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 */
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* misc generics (may be more functions here eventually)
|
||||
^ re_void regfree(regex_t *);
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* error reporting
|
||||
* Be careful if modifying the list of error codes -- the table used by
|
||||
* regerror() is generated automatically from this file!
|
||||
*
|
||||
* Note that there is no wide-char variant of regerror at this time; what
|
||||
* kind of character is used for error reports is independent of what kind
|
||||
* is used in matching.
|
||||
*
|
||||
^ extern size_t regerror(int, __REG_CONST regex_t *, char *, size_t);
|
||||
*/
|
||||
#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, as possibly munched by regfwd
|
||||
*/
|
||||
/* =====^!^===== begin forwards =====^!^===== */
|
||||
/* automatically gathered by fwd; do not hand-edit */
|
||||
/* === regproto.h === */
|
||||
#ifndef __REG_NOCHAR
|
||||
int re_comp _ANSI_ARGS_((regex_t *, __REG_CONST char *, size_t, int));
|
||||
#endif
|
||||
#ifndef __REG_NOFRONT
|
||||
int regcomp _ANSI_ARGS_((regex_t *, __REG_CONST char *, int));
|
||||
#endif
|
||||
#ifdef __REG_WIDE_T
|
||||
int __REG_WIDE_COMPILE _ANSI_ARGS_((regex_t *, __REG_CONST __REG_WIDE_T *, size_t, int));
|
||||
#endif
|
||||
#ifndef __REG_NOCHAR
|
||||
int re_exec _ANSI_ARGS_((regex_t *, __REG_CONST char *, size_t, rm_detail_t *, size_t, regmatch_t [], int));
|
||||
#endif
|
||||
#ifndef __REG_NOFRONT
|
||||
int regexec _ANSI_ARGS_((regex_t *, __REG_CONST char *, size_t, regmatch_t [], int));
|
||||
#endif
|
||||
#ifdef __REG_WIDE_T
|
||||
int __REG_WIDE_EXEC _ANSI_ARGS_((regex_t *, __REG_CONST __REG_WIDE_T *, size_t, rm_detail_t *, size_t, regmatch_t [], int));
|
||||
#endif
|
||||
re_void regfree _ANSI_ARGS_((regex_t *));
|
||||
extern size_t regerror _ANSI_ARGS_((int, __REG_CONST regex_t *, char *, size_t));
|
||||
/* automatically gathered by fwd; do not hand-edit */
|
||||
/* =====^!^===== end forwards =====^!^===== */
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* more C++ voodoo
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#endif
|
1038
src/regex/regexec.c
Normal file
1038
src/regex/regexec.c
Normal file
File diff suppressed because it is too large
Load Diff
53
src/regex/regfree.c
Normal file
53
src/regex/regfree.c
Normal file
@@ -0,0 +1,53 @@
|
||||
/*
|
||||
* 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);
|
||||
}
|
83
src/regex/regfronts.c
Normal file
83
src/regex/regfronts.c
Normal file
@@ -0,0 +1,83 @@
|
||||
/*
|
||||
* 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);
|
||||
}
|
418
src/regex/regguts.h
Normal file
418
src/regex/regguts.h
Normal file
@@ -0,0 +1,418 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/* standard header files (NULL is a reasonable indicator for them) */
|
||||
#ifndef NULL
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <ctype.h>
|
||||
#include <limits.h>
|
||||
#include <string.h>
|
||||
#endif
|
||||
|
||||
/* assertions */
|
||||
#ifndef assert
|
||||
# ifndef REG_DEBUG
|
||||
# define NDEBUG /* no assertions */
|
||||
# endif
|
||||
#include <assert.h>
|
||||
#endif
|
||||
|
||||
/* voids */
|
||||
#ifndef VOID
|
||||
#define VOID void /* for function return values */
|
||||
#endif
|
||||
#ifndef DISCARD
|
||||
#define DISCARD VOID /* for throwing values away */
|
||||
#endif
|
||||
#ifndef PVOID
|
||||
#define PVOID VOID * /* generic pointer */
|
||||
#endif
|
||||
#ifndef VS
|
||||
#define VS(x) ((PVOID)(x)) /* cast something to generic ptr */
|
||||
#endif
|
||||
#ifndef NOPARMS
|
||||
#define NOPARMS VOID /* for empty parm lists */
|
||||
#endif
|
||||
|
||||
/* const */
|
||||
#ifndef CONST
|
||||
#define CONST const /* for old compilers, might be empty */
|
||||
#endif
|
||||
|
||||
/* function-pointer declarator */
|
||||
#ifndef FUNCPTR
|
||||
#if __STDC__ >= 1
|
||||
#define FUNCPTR(name, args) (*name)args
|
||||
#else
|
||||
#define FUNCPTR(name, args) (*name)()
|
||||
#endif
|
||||
#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 */
|
||||
};
|
904
src/regex/tclUniData.c
Normal file
904
src/regex/tclUniData.c
Normal file
@@ -0,0 +1,904 @@
|
||||
/*
|
||||
* 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))]])
|
||||
|
Reference in New Issue
Block a user