src/stc/scintilla/include/PosRegExp.h

#ifndef POSREGEXP_H
#define POSREGEXP_H

#define MatchesNum 0x10

enum EOps
{
  ReBlockOps = 0x1000,
  ReMul,              // *
  RePlus,             // +
  ReQuest,            // ?
  ReNGMul,            // *?
  ReNGPlus,           // +?
  ReNGQuest,          // ??
  ReRangeN,           // {n,}
  ReRangeNM,          // {n,m}
  ReNGRangeN,         // {n,}?
  ReNGRangeNM,        // {n,m}?
  ReOr,               // |
  ReBehind  = 0x1100, // ?#n
  ReNBehind = 0x1200, // ?~n
  ReAhead   = 0x1300, // ?=
  ReNAhead  = 0x1400, // ?!

  ReSymbolOps = 0x2000,
  ReEmpty,
  ReSymb,             // a b \W \s ...
  ReEnum,             // []
  ReNEnum,            // [^]
  ReBrackets,         // (...)
  ReBkTrace = 0x2100, // \yN
  ReBkBrack = 0x2200 // \N
};

enum ESymbols
{
  ReAnyChr = 0x4000,  // .
  ReSoL,              // ^
  ReEoL,              // $
  ReDigit,            // \d
  ReNDigit,           // \D
  ReWordSymb,         // \w
  ReNWordSymb,        // \W
  ReWSpace,           // \s
  ReNWSpace,          // \S
  ReUCase,            // \u
  ReNUCase ,          // \l
  ReWBound,           // \b
  ReNWBound,          // \B
  RePreNW,            // \c
  ReStart,            // \m
  ReEnd,              // \M

  ReChr    = 0x0      // Char in Lower Byte
};
enum ETempSymb
{
  ReTemp = 0x7000,
  ReLBrack, ReRBrack,
  ReEnumS, ReEnumE, ReNEnumS,
  ReRangeS, ReRangeE, ReNGRangeE, ReFrToEnum
};

#define BackSlash '\\'

typedef union SCharData
{
  int  IArr[8];
  char CArr[32];
  void SetBit(unsigned char Bit);
  void ClearBit(unsigned char Bit);
  bool GetBit(unsigned char Bit);
} *PCharData;

typedef struct SRegInfo
{
  SRegInfo();
  ~SRegInfo();

  EOps   Op;
  union{
    SRegInfo *Param;
    int Symb;
    PCharData ChrClass;
  }un;
  int s,e;
  SRegInfo *Parent;
  SRegInfo *Next;
} *PRegInfo;

typedef struct SMatches
{
  int s[MatchesNum];
  int e[MatchesNum];
  int CurMatch;
} *PMatches;

typedef class PosRegExp
{
  PRegInfo Info;
  PMatches BkTrace;
  bool NoCase,Extend,NoMoves;
  bool Error;
  int  *Exprn;
  int  posParse;
  int  posEnd,posStart;
  int  posBkStr;
  int  FirstChar;

  bool SetExprLow(const char *Expr);
  bool SetStructs(PRegInfo &Info,int st,int end);
  void Optimize();
  bool CheckSymb(int Symb,bool Inc);
  bool LowParse(PRegInfo Re);
  bool LowParseRe(PRegInfo &Next);
  bool LowCheckNext(PRegInfo Re);
  bool ParseRe(int posStr);
  bool QuickCheck();
public:
  PMatches Matches;
  int Ok, CurMatch;

  void *param;
  char (*CharAt)(int pos, void *param);

  PosRegExp();
  ~PosRegExp();

  bool isok();
  bool SetNoMoves(bool Moves);
  bool SetBkTrace(int posStr,PMatches Trace);
  bool SetExpr(const char *Expr);
  bool Parse(int posStr, int posStop, PMatches Mtch);
  bool Parse(int posStr,int posSol, int posEol, PMatches Mtch, int Moves = -1);
  bool Evaluate(char *Expr, int posStr, PMatches Mtch, char **Res);
} *PPosRegExp;

#endif /* POSREGEXP_H */
Commit	Line	Data
	1	#ifndef POSREGEXP_H
	2	#define POSREGEXP_H
	3
	4	#define MatchesNum 0x10
	5
	6	enum EOps
	7	{
	8	ReBlockOps = 0x1000,
	9	ReMul, // *
	10	RePlus, // +
	11	ReQuest, // ?
	12	ReNGMul, // *?
	13	ReNGPlus, // +?
	14	ReNGQuest, // ??
	15	ReRangeN, // {n,}
	16	ReRangeNM, // {n,m}
	17	ReNGRangeN, // {n,}?
	18	ReNGRangeNM, // {n,m}?
	19	ReOr, // \|
	20	ReBehind = 0x1100, // ?#n
	21	ReNBehind = 0x1200, // ?~n
	22	ReAhead = 0x1300, // ?=
	23	ReNAhead = 0x1400, // ?!
	24
	25	ReSymbolOps = 0x2000,
	26	ReEmpty,
	27	ReSymb, // a b \W \s ...
	28	ReEnum, // []
	29	ReNEnum, // [^]
	30	ReBrackets, // (...)
	31	ReBkTrace = 0x2100, // \yN
	32	ReBkBrack = 0x2200 // \N
	33	};
	34
	35	enum ESymbols
	36	{
	37	ReAnyChr = 0x4000, // .
	38	ReSoL, // ^
	39	ReEoL, // $
	40	ReDigit, // \d
	41	ReNDigit, // \D
	42	ReWordSymb, // \w
	43	ReNWordSymb, // \W
	44	ReWSpace, // \s
	45	ReNWSpace, // \S
	46	ReUCase, // \u
	47	ReNUCase , // \l
	48	ReWBound, // \b
	49	ReNWBound, // \B
	50	RePreNW, // \c
	51	ReStart, // \m
	52	ReEnd, // \M
	53
	54	ReChr = 0x0 // Char in Lower Byte
	55	};
	56	enum ETempSymb
	57	{
	58	ReTemp = 0x7000,
	59	ReLBrack, ReRBrack,
	60	ReEnumS, ReEnumE, ReNEnumS,
	61	ReRangeS, ReRangeE, ReNGRangeE, ReFrToEnum
	62	};
	63
	64	#define BackSlash '\\'
	65
	66	typedef union SCharData
	67	{
	68	int IArr[8];
	69	char CArr[32];
	70	void SetBit(unsigned char Bit);
	71	void ClearBit(unsigned char Bit);
	72	bool GetBit(unsigned char Bit);
	73	} *PCharData;
	74
	75	typedef struct SRegInfo
	76	{
	77	SRegInfo();
	78	~SRegInfo();
	79
	80	EOps Op;
	81	union{
	82	SRegInfo *Param;
	83	int Symb;
	84	PCharData ChrClass;
	85	}un;
	86	int s,e;
	87	SRegInfo *Parent;
	88	SRegInfo *Next;
	89	} *PRegInfo;
	90
	91	typedef struct SMatches
	92	{
	93	int s[MatchesNum];
	94	int e[MatchesNum];
	95	int CurMatch;
	96	} *PMatches;
	97
	98	typedef class PosRegExp
	99	{
	100	PRegInfo Info;
	101	PMatches BkTrace;
	102	bool NoCase,Extend,NoMoves;
	103	bool Error;
	104	int *Exprn;
	105	int posParse;
	106	int posEnd,posStart;
	107	int posBkStr;
	108	int FirstChar;
	109
	110	bool SetExprLow(const char *Expr);
	111	bool SetStructs(PRegInfo &Info,int st,int end);
	112	void Optimize();
	113	bool CheckSymb(int Symb,bool Inc);
	114	bool LowParse(PRegInfo Re);
	115	bool LowParseRe(PRegInfo &Next);
	116	bool LowCheckNext(PRegInfo Re);
	117	bool ParseRe(int posStr);
	118	bool QuickCheck();
	119	public:
	120	PMatches Matches;
	121	int Ok, CurMatch;
	122
	123	void *param;
	124	char (CharAt)(int pos, void param);
	125
	126	PosRegExp();
	127	~PosRegExp();
	128
	129	bool isok();
	130	bool SetNoMoves(bool Moves);
	131	bool SetBkTrace(int posStr,PMatches Trace);
	132	bool SetExpr(const char *Expr);
	133	bool Parse(int posStr, int posStop, PMatches Mtch);
	134	bool Parse(int posStr,int posSol, int posEol, PMatches Mtch, int Moves = -1);
	135	bool Evaluate(char Expr, int posStr, PMatches Mtch, char *Res);
	136	} *PPosRegExp;
	137
	138	#endif /* POSREGEXP_H */