mirror of
https://github.com/levinsv/pgadmin3.git
synced 2026-05-15 06:05:49 -06:00
New control ctlStyledText with RegExp hightligth
Добавлен элемент для редактирования RegExp выражений с подсветкой. По цвету сделан похожим на regex101.com. Для разбора выражений использовалась грамматика https://github.com/bkiers/pcre-parser/blob/master/src/main/antlr4/nl/bigo/pcreparser/PCREParser.g4
This commit is contained in:
lsv
lsv
parent
c981b6b84f
commit
61a5b78bc8
5 changed files with 1103 additions and 1 deletions
427
ctl/ctlStyledText.cpp
Normal file
427
ctl/ctlStyledText.cpp
Normal file
|
|
@ -0,0 +1,427 @@
|
|||
|
||||
#include "pgAdmin3.h"
|
||||
|
||||
#include "ctl/ctlStyledText.h"
|
||||
#include <wx/log.h>
|
||||
#include <wx/regex.h>
|
||||
|
||||
BEGIN_EVENT_TABLE(ctlStyledText, wxStyledTextCtrl)
|
||||
//EVT_KEY_DOWN(ctlStyledText::OnKeyDown)
|
||||
// EVT_ERASE_BACKGROUND(ctlSQLBox::OnBackGround)
|
||||
#ifdef __WXMAC__
|
||||
EVT_STC_PAINTED(-1, ctlStyledText::OnPositionStc)
|
||||
#else
|
||||
EVT_STC_UPDATEUI(-1, ctlStyledText::OnPositionStc)
|
||||
#endif
|
||||
//EVT_STC_MARGINCLICK(-1, ctlSQLBox::OnMarginClick)
|
||||
//EVT_STC_DOUBLECLICK(-1, ctlSQLBox::OnDoubleClick)
|
||||
|
||||
END_EVENT_TABLE()
|
||||
|
||||
|
||||
IMPLEMENT_DYNAMIC_CLASS(ctlStyledText, wxStyledTextCtrl)
|
||||
|
||||
ctlStyledText::ctlStyledText()
|
||||
{
|
||||
m_regparser.SetStyleControl(this);
|
||||
setDecorate();
|
||||
}
|
||||
void ctlStyledText::setDecorate() {
|
||||
extern sysSettings* settings;
|
||||
wxFont fntSQLBox = settings->GetSQLFont();
|
||||
|
||||
StyleSetBackground(wxSTC_STYLE_BRACELIGHT, wxColour(0x99, 0xF9, 0xFF));
|
||||
StyleSetBackground(wxSTC_STYLE_BRACEBAD, wxColour(0xFF, 0xCF, 0x27));
|
||||
StyleSetFont(wxSTC_STYLE_BRACELIGHT, fntSQLBox);
|
||||
StyleSetFont(wxSTC_STYLE_BRACEBAD, fntSQLBox);
|
||||
|
||||
}
|
||||
ctlStyledText::ctlStyledText(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
|
||||
{
|
||||
Create(parent, id, pos, size, style);
|
||||
m_regparser.SetStyleControl(this);
|
||||
setDecorate();
|
||||
}
|
||||
void ctlStyledText::OnPositionStc(wxStyledTextEvent& event) {
|
||||
|
||||
int u = event.GetUpdated();
|
||||
if ((u & wxSTC_UPDATE_CONTENT) && ishighlight) {
|
||||
wxString t = GetText();
|
||||
{
|
||||
// wxLogNull logNo;
|
||||
// wxRegEx r(t, wxRE_NEWLINE);
|
||||
}
|
||||
if (m_regparser.ParseStr(t, RegExpParser::defrule::pcre) > 0) {
|
||||
}
|
||||
m_regparser.StyledTextControl(this);
|
||||
|
||||
}
|
||||
|
||||
int pos = GetCurrentPos();
|
||||
wxChar ch = GetCharAt(pos - 1);
|
||||
wxChar nextch = GetCharAt(pos);
|
||||
int st = GetStyleAt(pos - 1);
|
||||
int match;
|
||||
// Line numbers
|
||||
// Ensure we don't recurse through any paint handlers on Mac
|
||||
// Roll back through the doc and highlight any unmatched braces
|
||||
int tmp = pos;
|
||||
|
||||
while ((pos--) >= 0)
|
||||
{
|
||||
ch = GetCharAt(pos);
|
||||
st = GetStyleAt(pos)- (wxSTC_STYLE_LASTPREDEFINED + 1);
|
||||
if ( (
|
||||
//ch == '{' || ch == '}' ||
|
||||
//ch == '[' || ch == ']' ||
|
||||
ch == '(' || ch == ')') &&
|
||||
st != 5 )
|
||||
{
|
||||
match = BraceMatch(pos);
|
||||
if (match == wxSTC_INVALID_POSITION)
|
||||
{
|
||||
event.Skip();
|
||||
return;
|
||||
}
|
||||
BraceHighlight(pos, match);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
event.Skip();
|
||||
}
|
||||
void ctlStyledText::setRegExphighlight(bool enable) {
|
||||
ishighlight = enable;
|
||||
if (!enable) m_regparser.SetStyleControl(NULL);
|
||||
}
|
||||
|
||||
///////////////////////////// RegExpParser
|
||||
|
||||
void RegExpParser::init() {
|
||||
for (int i = 0; i < sizeof(rulemap) / sizeof(rulemap[0]); i++) rulemap[i] = -1;
|
||||
for (int i = 0; i < sizeof(rules) / sizeof(rules[0]); i++) {
|
||||
if (ISCHECKTYPE(i, rule_type::start_rule)) {
|
||||
wxASSERT_MSG(rules[i].ruledef >= 0, "rule < 0 this bad");
|
||||
rulemap[rules[i].ruledef] = i;
|
||||
}
|
||||
}
|
||||
// check all refernce
|
||||
for (int i = 0; i < sizeof(rules) / sizeof(rules[0]); i++) {
|
||||
if (rules[i].ruleref > 0) {
|
||||
wxASSERT_MSG(rulemap[rules[i].ruleref] >= 0, wxString::Format("rule %d not define", rules[i].ruleref));
|
||||
}
|
||||
}
|
||||
};
|
||||
int RegExpParser::ParseStr(const wxString str, defrule start_rule) {
|
||||
t = str;
|
||||
len = t.length();
|
||||
maxPos = 0;
|
||||
int idx = rulemap[start_rule];
|
||||
int n;
|
||||
marker.clear();
|
||||
int r = testRule(idx, 0, n, -1);
|
||||
if (r > 0) {
|
||||
if (n == len) return 1;
|
||||
if (n < len) {
|
||||
if (marker.size() > 0) marker.push_back(styletextmarker{ 0, n,len });
|
||||
}
|
||||
return -11;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
void RegExpParser::SetStyleControl(wxStyledTextCtrl* ctrl) {
|
||||
if (ctrl == NULL) {
|
||||
intitstyle = false;
|
||||
return;
|
||||
}
|
||||
//ctrl->StyleClearAll();
|
||||
for (int i = 0; i < sizeof(stylemap) / sizeof(stylemap[0]); i++) stylemap[i] = -1;
|
||||
wxColour bgdef = ctrl->GetBackgroundColour();
|
||||
wxColour fgdef = ctrl->GetForegroundColour();
|
||||
tablestyle.push_back(styletextdef{ fgdef,wxColour("#ddd0fe") }); // 00 verb
|
||||
tablestyle.push_back(styletextdef{ fgdef,wxColour("#fed1ff") }); // 1 capture (reed)
|
||||
tablestyle.push_back(styletextdef{ fgdef,wxColour("#e3e3e3") }); // 2 backslash
|
||||
tablestyle.push_back(styletextdef{ fgdef,wxColour("#d3a776") }); // 3 class char
|
||||
tablestyle.push_back(styletextdef{ fgdef,wxColour("#99beff") }); // 4 quantifier
|
||||
tablestyle.push_back(styletextdef{ wxColour("#989898"),bgdef }); // 5 comment
|
||||
tablestyle.push_back(styletextdef{ fgdef,wxColour("#bae634") }); // 6 captute (green)
|
||||
|
||||
tablestyle.push_back(styletextdef{ fgdef,wxColour("#ed5c65") }); // last color. error bg
|
||||
stylemap[0] = tablestyle.size() - 1; // error bg
|
||||
|
||||
stylemap[defrule::option_setting] = 0;
|
||||
stylemap[defrule::atomic_group] = 0;
|
||||
stylemap[defrule::lookaround] = 0;
|
||||
stylemap[defrule::quantifier] = 4;
|
||||
stylemap[defrule::comment] = 5;
|
||||
stylemap[defrule::character_class] = 3;
|
||||
stylemap[defrule::posix_character_class] = 3;
|
||||
stylemap[defrule::character_type] = 2;
|
||||
stylemap[defrule::character] = 2;
|
||||
stylemap[defrule::character_type] = 2;
|
||||
stylemap[defrule::backreference] = 2;
|
||||
stylemap[defrule::anchor] = 2;
|
||||
stylemap[defrule::match_point_reset] = 2;
|
||||
stylemap[defrule::backtracking_control] = 0;
|
||||
stylemap[defrule::alternation] = 0;
|
||||
stylemap[defrule::capture] = 6;
|
||||
stylemap[defrule::capture_1] = 6;
|
||||
stylemap[defrule::conditional_pattern] = 1;
|
||||
//wxLogNull logNo;
|
||||
int count = 0;
|
||||
int userstyle = wxSTC_STYLE_LASTPREDEFINED + 1;
|
||||
for (int i = 0; i < sizeof(stylemap) / sizeof(stylemap[0]); i++) {
|
||||
if (stylemap[i] != -1) {
|
||||
int k = stylemap[i];
|
||||
stylemap[i] += userstyle;
|
||||
ctrl->StyleSetBackground(stylemap[i], tablestyle[k].bg);
|
||||
ctrl->StyleSetForeground(stylemap[i], tablestyle[k].fg);
|
||||
}
|
||||
}
|
||||
intitstyle = true;
|
||||
}
|
||||
void RegExpParser::StyledTextControl(wxStyledTextCtrl* ctrl) {
|
||||
if (!intitstyle) SetStyleControl(ctrl);
|
||||
ctrl->ClearDocumentStyle();
|
||||
if (marker.size() == 0) {
|
||||
marker.push_back(styletextmarker{ 0,maxPos + 1,maxPos + 2 });
|
||||
}
|
||||
int userstyle = wxSTC_STYLE_LASTPREDEFINED + 1;
|
||||
for (auto m : marker) {
|
||||
if (m.rule >= 0) {
|
||||
int style = stylemap[m.rule];
|
||||
if (style < 0) continue;
|
||||
int CharPos = ctrl->PositionRelative(0, m.start);
|
||||
ctrl->StartStyling(CharPos);
|
||||
int CharPosEnd = ctrl->PositionRelative(CharPos, m.end - m.start);
|
||||
int ll = CharPosEnd - CharPos;
|
||||
//ctrl->SetStyling(m.end - m.start, style);
|
||||
ctrl->SetStyling(ll, style);
|
||||
}
|
||||
}
|
||||
}
|
||||
bool RegExpParser::iseqchar(int pos, const char* const str) {
|
||||
int i = 0;
|
||||
int n = len - pos;
|
||||
char c;
|
||||
if (n == 0)
|
||||
return false;
|
||||
wxChar tc = t[pos];
|
||||
while (str[i] != 0) {
|
||||
c = str[i++];
|
||||
if (c == tc) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool RegExpParser::istexteq(int pos, int& nextpos, const char* str) {
|
||||
int i = 0;
|
||||
int n = len - pos;
|
||||
char c;
|
||||
while (str[i] != 0) {
|
||||
if (n - i == 0) {
|
||||
return false; // end of string
|
||||
}
|
||||
c = str[i];
|
||||
wxChar tc = t[pos + i++];
|
||||
if (c == tc) continue;
|
||||
return false;
|
||||
}
|
||||
//equal
|
||||
nextpos = pos + i;
|
||||
return true;
|
||||
}
|
||||
int RegExpParser::testRule(int ruleindex, int startCharPosition, int& nextCharPosition, int ruleparent) {
|
||||
int p = startCharPosition;
|
||||
int n = p;
|
||||
bool isruleok = false;
|
||||
bool isanonim = false;
|
||||
int ri = ruleindex;
|
||||
int rule = -1;
|
||||
int ruletype = 0;
|
||||
int sizemarker = marker.size();
|
||||
if (ISCHECKTYPE(ri, start_anonim_rule)) {
|
||||
ri++;
|
||||
rule = ruleparent;
|
||||
};
|
||||
int countOkrule = 0;
|
||||
int nextel = true;
|
||||
int nextRule = 0;
|
||||
while (nextel) {
|
||||
p = n;
|
||||
int incnextrule = 1;
|
||||
if (rules[ri].type == 0) { // end rule
|
||||
break;
|
||||
}
|
||||
if (ISCHECKTYPE(ri, start_rule)) {
|
||||
rule = rules[ri].ruledef;
|
||||
ruletype = rules[ri].type;
|
||||
ri = ri + incnextrule;
|
||||
continue;
|
||||
}
|
||||
isruleok = false;
|
||||
if (ISCHECKTYPE(ri, text)) {
|
||||
//
|
||||
isruleok = (istexteq(p, n, rules[ri].text));
|
||||
//if (ISCHECKTYPE(ri, inversion) && p != len) isruleok = !isruleok;
|
||||
if (isruleok) marker.push_back(styletextmarker{ rule,p,n });
|
||||
}
|
||||
else if (ISCHECKTYPE(ri, char_any)) {
|
||||
int n2 = p;
|
||||
if (rule == defrule::other && (maskOpt & maskopt::extended) && (p < len && t[p] == '#')) {
|
||||
//extended comment
|
||||
while (n2 < len && t[n2] != '\n') n2++;
|
||||
if (n2 < len) n2++;
|
||||
marker.push_back(styletextmarker{ defrule::comment,p,n2 });
|
||||
isruleok = true;
|
||||
n = n2;
|
||||
}
|
||||
else {
|
||||
isruleok = iseqchar(p, rules[ri].text);
|
||||
if (ISCHECKTYPE(ri, inversion) && p != len) isruleok = !isruleok;
|
||||
if (isruleok) n = p + 1;
|
||||
if (isruleok) marker.push_back(styletextmarker{ rule,p,n });
|
||||
}
|
||||
}
|
||||
else if (ISCHECKTYPE(ri, special_dot)) {
|
||||
isruleok = false;
|
||||
int n2 = p;
|
||||
{
|
||||
if (ISCHECKTYPE(ri, zero_more) && ISCHECKTYPE(ri + 1, text)) {
|
||||
isruleok = istexteq(p, n2, rules[ri + 1].text);
|
||||
isruleok = !isruleok;
|
||||
if (isruleok) n2++;
|
||||
}
|
||||
else {
|
||||
isruleok = true; // only 1 spec dot
|
||||
n2++;
|
||||
}
|
||||
|
||||
if (p == len || n2 == p) isruleok = false; // end expression alaways false
|
||||
if (isruleok) n = n2;
|
||||
}
|
||||
}
|
||||
else if (rules[ri].ruleref >= 0) {
|
||||
//Use defibe rule
|
||||
int r = GETRULEREFINDEX(ri);
|
||||
isanonim = ISCHECKTYPE(ri, start_anonim_rule);
|
||||
if (isanonim) r = ri;
|
||||
nextRule = testRule(r, p, n, rule);
|
||||
isruleok = nextRule > 0;
|
||||
if (isanonim) {
|
||||
if (!isruleok) nextRule = nextRule * -1;
|
||||
incnextrule = nextRule - ri + 1; // next element after ZERO
|
||||
}
|
||||
else
|
||||
nextRule = 0;
|
||||
}
|
||||
//
|
||||
if (isruleok) countOkrule++;
|
||||
if (countOkrule < 2 && (ISCHECKTYPE(ri, zero_one))) {
|
||||
isruleok = true;
|
||||
}
|
||||
if (countOkrule >= 0 && (ISCHECKTYPE(ri, zero_more))) {
|
||||
if (countOkrule > 0 && isruleok) continue;
|
||||
if (countOkrule >= 0) isruleok = true;
|
||||
}
|
||||
if ((ISCHECKTYPE(ri, one_more))) {
|
||||
if (countOkrule > 0 && isruleok) continue;
|
||||
// zero - this false rule
|
||||
if (countOkrule > 0) isruleok = true;
|
||||
}
|
||||
// next element
|
||||
countOkrule = 0;
|
||||
ri = ri + incnextrule;
|
||||
// NEXT elemenT
|
||||
if (isruleok && ISCHECKTYPE(ri, alternative)) break; // end rule
|
||||
if (isruleok) continue;
|
||||
n = p; // undo position
|
||||
n = startCharPosition;
|
||||
// find alternative or end rule (control anonim rule)
|
||||
int llvel = 0;
|
||||
while (!((rules[ri].type == 0 || ISCHECKTYPE(ri, alternative)
|
||||
) && llvel == 0)
|
||||
)
|
||||
{ // find alternative or end rule
|
||||
|
||||
if (ISCHECKTYPE(ri, start_anonim_rule)) {
|
||||
llvel++; // inner rule
|
||||
}
|
||||
if ((rules[ri].type == 0) && (llvel != 0)) {
|
||||
llvel--; //end inner rule
|
||||
}
|
||||
ri++;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// isruleok
|
||||
|
||||
if (isruleok) {
|
||||
p = n;
|
||||
nextCharPosition = p;
|
||||
if (p > maxPos) maxPos = p;
|
||||
// find end rule (control anonim rule)
|
||||
int llvel = 0;
|
||||
while (!((rules[ri].type == 0
|
||||
) && llvel == 0)
|
||||
) { // find end rule
|
||||
if (ISCHECKTYPE(ri, start_anonim_rule)) {
|
||||
llvel++; // inner rule
|
||||
}
|
||||
if ((rules[ri].type == 0) && (llvel != 0)) {
|
||||
llvel--; //end inner rule
|
||||
}
|
||||
ri++;
|
||||
|
||||
}
|
||||
if ((ruletype & styled_ALL) == styled_ALL) {
|
||||
// undo marker
|
||||
marker.resize(sizemarker);
|
||||
// replace all rule
|
||||
marker.push_back(styletextmarker{ rule,startCharPosition,n });
|
||||
}
|
||||
// check is option_setting ?
|
||||
|
||||
if (rule == defrule::option_setting && (startCharPosition + 1<len) && t[startCharPosition + 1] == '?') {
|
||||
// (?is-xJ)
|
||||
int maskset = 0;
|
||||
int maskreset = 0;
|
||||
bool neg = false;
|
||||
int mask = 0;
|
||||
for (int i = startCharPosition; i < nextCharPosition; i++) {
|
||||
wxChar c = t[i];
|
||||
if (c == 'i') mask |= (int)maskopt::caseless;
|
||||
if (c == 'J') mask |= (int)maskopt::allow_duplicate_names;
|
||||
if (c == 'm') mask |= (int)maskopt::multiline;
|
||||
if (c == 's') mask |= (int)maskopt::single_line;
|
||||
if (c == 'U') mask |= (int)maskopt::default_ungreed;
|
||||
if (c == 'x') mask |= (int)maskopt::extended;
|
||||
if (c == '-') {
|
||||
maskset = mask;
|
||||
mask = 0;
|
||||
neg = true;
|
||||
}
|
||||
}
|
||||
if (neg) {
|
||||
maskOpt |= maskset;
|
||||
maskreset = ~mask;
|
||||
maskOpt &= maskreset;
|
||||
}
|
||||
else if (mask > 0) {
|
||||
maskOpt |= mask;
|
||||
}
|
||||
}
|
||||
return ri; // end rule position , isruleok=true;
|
||||
}
|
||||
else {
|
||||
// undo marker
|
||||
marker.resize(sizemarker);
|
||||
|
||||
nextCharPosition = startCharPosition;
|
||||
return -ri; //- end rule position isruleok=false;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
45
ctl/xh_styledtext.cpp
Normal file
45
ctl/xh_styledtext.cpp
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
//////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// pgAdmin III - PostgreSQL Tools
|
||||
//
|
||||
// Copyright (C) 2002 - 2016, The pgAdmin Development Team
|
||||
// This software is released under the PostgreSQL Licence
|
||||
//
|
||||
// xh_styledtext.cpp - ctlStyledText handler
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "pgAdmin3.h"
|
||||
|
||||
#include "wx/wx.h"
|
||||
#include "ctl/xh_styledtext.h"
|
||||
#include "ctl/ctlStyledText.h"
|
||||
|
||||
|
||||
IMPLEMENT_DYNAMIC_CLASS(ctlStyledTextXmlHandler, wxXmlResourceHandler)
|
||||
|
||||
ctlStyledTextXmlHandler::ctlStyledTextXmlHandler()
|
||||
: wxXmlResourceHandler()
|
||||
{
|
||||
XRC_ADD_STYLE(wxTE_MULTILINE);
|
||||
XRC_ADD_STYLE(wxSIMPLE_BORDER);
|
||||
XRC_ADD_STYLE(wxSUNKEN_BORDER);
|
||||
XRC_ADD_STYLE(wxTE_RICH2);
|
||||
|
||||
AddWindowStyles();
|
||||
}
|
||||
|
||||
|
||||
wxObject *ctlStyledTextXmlHandler::DoCreateResource()
|
||||
{
|
||||
ctlStyledText *StyledText = new ctlStyledText(m_parentAsWindow, GetID(), GetPosition(), GetSize(), GetStyle());
|
||||
|
||||
SetupWindow(StyledText);
|
||||
|
||||
return StyledText;
|
||||
}
|
||||
|
||||
bool ctlStyledTextXmlHandler::CanHandle(wxXmlNode *node)
|
||||
{
|
||||
return IsOfClass(node, wxT("ctlStyledText"));
|
||||
}
|
||||
597
include/ctl/ctlStyledText.h
Normal file
597
include/ctl/ctlStyledText.h
Normal file
|
|
@ -0,0 +1,597 @@
|
|||
#ifndef _CTLSTYLEDTEXT_H_
|
||||
#define _CTLSTYLEDTEXT_H_
|
||||
#include <wx/stc/stc.h>
|
||||
#include <vector>
|
||||
|
||||
|
||||
struct styletextmarker {
|
||||
int rule; // rule
|
||||
int start;
|
||||
int end; // next char
|
||||
};
|
||||
struct styletextdef {
|
||||
wxColour fg;
|
||||
wxColour bg;
|
||||
};
|
||||
|
||||
|
||||
|
||||
class RegExpParser
|
||||
{
|
||||
public:
|
||||
enum maskopt {
|
||||
caseless = 1,
|
||||
allow_duplicate_names = 2,
|
||||
multiline = 4,
|
||||
single_line = 8,
|
||||
default_ungreed = 16,
|
||||
extended = 32
|
||||
};
|
||||
enum defrule {
|
||||
digits = 1,
|
||||
digit,
|
||||
quoting,
|
||||
letter,
|
||||
letters,
|
||||
name,
|
||||
newline_conventions,
|
||||
option_setting,
|
||||
option_setting_1,
|
||||
option_setting_11,
|
||||
option_setting_111,
|
||||
option_setting_12,
|
||||
option_setting_2,
|
||||
option_setting_21,
|
||||
option_setting_22,
|
||||
option_setting_flag,
|
||||
option_setting_flag_cap,
|
||||
backtracking_control,
|
||||
backtracking_control_1,
|
||||
|
||||
pcre,
|
||||
expr,
|
||||
alternation,
|
||||
element,
|
||||
atom,
|
||||
quantifier,
|
||||
comment,
|
||||
capture,
|
||||
capture_1,
|
||||
atomic_group,
|
||||
lookaround,
|
||||
backreference,
|
||||
hex,
|
||||
hex4,
|
||||
anchor,
|
||||
match_point_reset,
|
||||
character,
|
||||
character_type,
|
||||
posix_character_class,
|
||||
posix_character_class_name,
|
||||
character_class_range_atom,
|
||||
character_class_range,
|
||||
character_class_atom,
|
||||
character_class,
|
||||
conditional_pattern,
|
||||
call_out,
|
||||
|
||||
other,
|
||||
|
||||
MAX_COUNT_RULE
|
||||
};
|
||||
enum rule_type {
|
||||
end_rule = 0,
|
||||
start_rule = 1,
|
||||
zero_one = 2,
|
||||
one_more = 4,
|
||||
zero_more = 8,
|
||||
alternative = 16,
|
||||
char_any = 32,
|
||||
text = 64,
|
||||
none = 128,
|
||||
special_dot = 256,
|
||||
start_anonim_rule = 512,
|
||||
inversion = 1024,
|
||||
styled_parent = 1024 * 2,
|
||||
styled_ALL = 1024 * 4,
|
||||
};
|
||||
struct ERule {
|
||||
int type;
|
||||
int ruleref = 0; // use rule reference
|
||||
int ruledef; // start define rule
|
||||
const char* text;
|
||||
};
|
||||
RegExpParser() {
|
||||
init();
|
||||
intitstyle = false;
|
||||
}
|
||||
int ParseStr(const wxString str, RegExpParser::defrule start_rule);
|
||||
void SetStyleControl(wxStyledTextCtrl* ctrl);
|
||||
void StyledTextControl(wxStyledTextCtrl* ctrl);
|
||||
static void TEST() {
|
||||
|
||||
const char* const t1[] = { "F0", "Z0T_a1234", "f" };
|
||||
const char* const t2[] = { "(?i-ix)", "(*UTF)" };
|
||||
const char* const t3[] = { "(*SKIP:m9)","(*:q2)", "(*FAIL)", "(*MARK:q)" };
|
||||
const char* const t4[] = { "(?#аы)","(?#d2)", };
|
||||
const char* const t5[] = { "(?|das)","(?i-i:ab)", "$ \\p{Fre}","(?>ATM)\\n\\0\\x{FFF}\\u1234abcd","(?P=ss)", "\\g{1}", "(P=ss)","\\g2",".\\V","\\Q\\s\\E" };
|
||||
const char* const t6[] = { "\\0","\\u1abc", "\\o{881}","\\xaa" };
|
||||
const char* const t7[] = { ".","\\V", "\\p{^ssa&}","\\psd" };
|
||||
const char* const t8[] = { "[[:^digit:]]", "[[:digit:]]" };
|
||||
const char* const t9[] = { "(?(sd)ffff)","(?(-23)cond_expr|no_expr_cond)" };
|
||||
|
||||
test_2(RegExpParser::defrule::pcre, t5, sizeof(t5) / sizeof(t5[0]));
|
||||
test_2(RegExpParser::defrule::conditional_pattern, t9, sizeof(t9) / sizeof(t9[0]));
|
||||
test_2(RegExpParser::defrule::character_class, t8, sizeof(t8) / sizeof(t8[0]));
|
||||
test_2(RegExpParser::defrule::character_type, t7, sizeof(t7) / sizeof(t7[0]));
|
||||
test_2(RegExpParser::defrule::character, t6, sizeof(t6) / sizeof(t6[0]));
|
||||
test_2(RegExpParser::defrule::backtracking_control, t3, sizeof(t3) / sizeof(t3[0]));
|
||||
|
||||
//test_2(RegExpParser::defrule::backreference, t5);
|
||||
test_2(RegExpParser::defrule::comment, t4, sizeof(t4) / sizeof(t4[0]));
|
||||
test_2(RegExpParser::defrule::option_setting, t2, sizeof(t2) / sizeof(t2[0]));
|
||||
test_2(RegExpParser::defrule::name, t1, sizeof(t1) / sizeof(t1[0]));
|
||||
|
||||
|
||||
}
|
||||
static void test_2(RegExpParser::defrule rule, const char* const arr[], int arraysize) {
|
||||
RegExpParser t;
|
||||
int nt = 1;
|
||||
int sz = arraysize;
|
||||
wxString ss;
|
||||
for (int i = 0; i < sz; i++) {
|
||||
ss = arr[i];
|
||||
int rez = t.ParseStr(ss, rule);
|
||||
wxString rezfail = wxString::Format("Test %d to %d failed\n Regexp expression: %s", nt, arraysize, wxString(ss));
|
||||
wxASSERT_MSG(rez >= 0, rezfail.c_str());
|
||||
nt++;
|
||||
}
|
||||
}
|
||||
private:
|
||||
std::vector<styletextmarker> marker;
|
||||
std::vector<styletextdef> tablestyle;
|
||||
int stylemap[RegExpParser::defrule::MAX_COUNT_RULE] = { -1 };
|
||||
int rulemap[RegExpParser::defrule::MAX_COUNT_RULE] = { -1 };
|
||||
bool intitstyle;
|
||||
wxString t;
|
||||
int len;
|
||||
int maxPos = 0; // last position
|
||||
int maskOpt = 0; // global options
|
||||
bool iseqchar(int pos, const char* const str);
|
||||
bool istexteq(int pos, int& nextpos, const char* str);
|
||||
void init();
|
||||
//////
|
||||
int testRule(int ruleindex, int startCharPosition, int& nextCharPosition, int ruleparent);
|
||||
};
|
||||
/// <summary>
|
||||
/// ctlStyledText - Regexp hightli
|
||||
/// </summary>
|
||||
class ctlStyledText :
|
||||
public wxStyledTextCtrl
|
||||
{
|
||||
public:
|
||||
ctlStyledText();
|
||||
ctlStyledText(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style);
|
||||
void setRegExphighlight(bool enable);
|
||||
void setDecorate();
|
||||
DECLARE_DYNAMIC_CLASS(ctlStyledText)
|
||||
DECLARE_EVENT_TABLE()
|
||||
private:
|
||||
void OnPositionStc(wxStyledTextEvent& event);
|
||||
RegExpParser m_regparser;
|
||||
bool ishighlight = false;
|
||||
//
|
||||
//
|
||||
};
|
||||
//using namespace RegExpParser;
|
||||
#define ZERO RegExpParser::ERule {0,0,0,0}
|
||||
#define TEXTSIM(str) RegExpParser::ERule {RegExpParser::rule_type::text,0,0,str}
|
||||
#define TEXT_TYPE(type,str) {type,0,0,str}
|
||||
#define USE_RULE(type,rule) {type,rule,0,0}
|
||||
#define START_R(rule) {RegExpParser::rule_type::start_rule,0,rule,0}
|
||||
#define START_R_STYLE(rule,style) {RegExpParser::rule_type::start_rule|style,0,rule,0}
|
||||
#define START_A_R(type) {RegExpParser::rule_type::start_anonim_rule|RegExpParser::rule_type::styled_parent|type,0,0,0}
|
||||
#define ISCHECKTYPE(i,typerule) ((rules[i].type & typerule) == typerule)
|
||||
#define GETRULEREFINDEX(i) (rulemap[(rules[i].ruleref)])
|
||||
|
||||
const RegExpParser::ERule rules[] = {
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::letter),
|
||||
TEXT_TYPE(RegExpParser::rule_type::char_any, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::letters),
|
||||
USE_RULE(RegExpParser::rule_type::one_more,RegExpParser::defrule::letter),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::anchor),
|
||||
TEXTSIM("\\"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::char_any, "bBAzZG"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::char_any | RegExpParser::rule_type::alternative, "^$"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::match_point_reset),
|
||||
TEXTSIM("\\K"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::backtracking_control_1),
|
||||
TEXTSIM("ACCEPT"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "FAIL"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "COMMIT"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text | RegExpParser::rule_type::zero_one, "MARK"),
|
||||
TEXTSIM(":"),
|
||||
USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::name),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "PRUNE"),
|
||||
START_A_R(RegExpParser::rule_type::zero_one),
|
||||
TEXTSIM(":"),
|
||||
USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::name),
|
||||
ZERO,
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "SKIP"),
|
||||
START_A_R(RegExpParser::rule_type::zero_one),
|
||||
TEXTSIM(":"),
|
||||
USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::name),
|
||||
ZERO,
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "THEN"),
|
||||
START_A_R(RegExpParser::rule_type::zero_one),
|
||||
TEXTSIM(":"),
|
||||
USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::name),
|
||||
ZERO,
|
||||
ZERO,
|
||||
START_R_STYLE(RegExpParser::defrule::backtracking_control,RegExpParser::rule_type::styled_ALL),
|
||||
TEXTSIM("(*"),
|
||||
USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::backtracking_control_1),
|
||||
TEXTSIM(")"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::name),
|
||||
USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::letter),
|
||||
START_A_R(RegExpParser::rule_type::zero_more),
|
||||
USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::letter),
|
||||
USE_RULE(RegExpParser::rule_type::alternative,RegExpParser::defrule::digit),
|
||||
ZERO,
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::option_setting_flag),
|
||||
TEXT_TYPE(RegExpParser::rule_type::char_any, "iJmsUx"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::digit),
|
||||
TEXT_TYPE(RegExpParser::rule_type::char_any, "0123456789"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::digits),
|
||||
USE_RULE(RegExpParser::rule_type::one_more,RegExpParser::defrule::digit),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::hex),
|
||||
TEXT_TYPE(RegExpParser::rule_type::char_any, "0123456789abcdefABCDEF"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::quoting),
|
||||
TEXTSIM("\\Q"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::special_dot | RegExpParser::rule_type::zero_more, ""),
|
||||
TEXTSIM("\\E"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\\"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::special_dot, ""),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::newline_conventions),
|
||||
TEXTSIM("CRLF"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"LF"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"CR"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"ANYCRLF"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"ANY"),
|
||||
ZERO,
|
||||
|
||||
// option_setting
|
||||
START_R(RegExpParser::defrule::option_setting_22),
|
||||
TEXT_TYPE(RegExpParser::rule_type::text,"-"),
|
||||
USE_RULE(RegExpParser::rule_type::one_more,RegExpParser::defrule::option_setting_flag),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::option_setting_21),
|
||||
USE_RULE(RegExpParser::rule_type::one_more,RegExpParser::defrule::option_setting_flag),
|
||||
USE_RULE(RegExpParser::rule_type::zero_one,RegExpParser::defrule::option_setting_22),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"-"),
|
||||
USE_RULE(RegExpParser::rule_type::one_more,RegExpParser::defrule::option_setting_flag),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::option_setting_111),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "UTF"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"UCP"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"NO_AUTO_POSSESS"),
|
||||
USE_RULE(RegExpParser::rule_type::alternative,RegExpParser::defrule::newline_conventions),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"NO_START_OPT"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"BSR_ANYCRLF"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"BSR_UNICODE"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"LIMIT_MATCH="),
|
||||
USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::digits),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"LIMIT_RECURSION="),
|
||||
USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::digits),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::option_setting_1),
|
||||
TEXTSIM("*"),
|
||||
USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::option_setting_111),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::option_setting_2),
|
||||
TEXTSIM("?"),
|
||||
USE_RULE(RegExpParser::rule_type::zero_one,RegExpParser::defrule::option_setting_21),
|
||||
ZERO,
|
||||
START_R_STYLE(RegExpParser::defrule::option_setting,RegExpParser::rule_type::styled_ALL),
|
||||
TEXTSIM("("),
|
||||
START_A_R(RegExpParser::rule_type::none),
|
||||
USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::option_setting_1),
|
||||
USE_RULE(RegExpParser::rule_type::alternative,RegExpParser::defrule::option_setting_2),
|
||||
ZERO,
|
||||
TEXTSIM(")"),
|
||||
ZERO,
|
||||
// PCRE START rule
|
||||
START_R(RegExpParser::defrule::pcre),
|
||||
USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::alternation),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::alternation),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::expr),
|
||||
START_A_R(RegExpParser::rule_type::zero_more),
|
||||
TEXTSIM("|"),
|
||||
USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::expr),
|
||||
ZERO,
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::expr),
|
||||
USE_RULE(RegExpParser::rule_type::one_more, RegExpParser::defrule::element),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::element),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::atom),
|
||||
USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::quantifier),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::atom), //////////////////////////////////////////// ATOM
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::option_setting),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::backtracking_control),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::atomic_group),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::lookaround),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::backreference),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::conditional_pattern),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::comment),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::capture),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::character),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::character_type),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::character_class),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::posix_character_class),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::letter),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::digit),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::anchor),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::match_point_reset),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::quoting),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::other),
|
||||
ZERO,
|
||||
START_R_STYLE(RegExpParser::defrule::quantifier, RegExpParser::rule_type::styled_ALL),
|
||||
TEXT_TYPE(RegExpParser::rule_type::char_any, "?*+"),
|
||||
START_A_R(RegExpParser::rule_type::zero_one),
|
||||
TEXTSIM("+"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "?"),
|
||||
ZERO,
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "{"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::digits),
|
||||
START_A_R(RegExpParser::rule_type::zero_one),
|
||||
TEXTSIM(","),
|
||||
USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::digits),
|
||||
ZERO,
|
||||
TEXTSIM("}"),
|
||||
START_A_R(RegExpParser::rule_type::zero_one),
|
||||
TEXTSIM("+"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "?"),
|
||||
ZERO,
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::comment),
|
||||
TEXTSIM("(?#"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::inversion | RegExpParser::rule_type::char_any | RegExpParser::rule_type::one_more, ")"),
|
||||
TEXTSIM(")"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::option_setting_flag_cap),
|
||||
USE_RULE(RegExpParser::rule_type::one_more, RegExpParser::defrule::option_setting_flag),
|
||||
USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::option_setting_22),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::capture_1),
|
||||
TEXTSIM("?"),
|
||||
START_A_R(RegExpParser::rule_type::none),
|
||||
TEXTSIM("<"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
|
||||
TEXTSIM(">"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::alternation),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\'"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
|
||||
TEXTSIM("\'"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::alternation),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "P<"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
|
||||
TEXTSIM(">"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::alternation),
|
||||
USE_RULE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::zero_one, RegExpParser::defrule::option_setting_flag_cap),
|
||||
TEXTSIM(":"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::alternation),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "|"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::alternation),
|
||||
ZERO,
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::capture),
|
||||
TEXTSIM("("),
|
||||
START_A_R(RegExpParser::rule_type::none),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::capture_1),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::alternation),
|
||||
//TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "?"),
|
||||
ZERO,
|
||||
TEXTSIM(")"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::atomic_group),
|
||||
TEXTSIM("(?>"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::alternation),
|
||||
TEXTSIM(")"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::lookaround),
|
||||
TEXTSIM("(?"),
|
||||
START_A_R(RegExpParser::rule_type::none),
|
||||
TEXTSIM("="),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "!"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "<="),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "<!"),
|
||||
ZERO,
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::alternation),
|
||||
TEXTSIM(")"),
|
||||
ZERO,
|
||||
START_R_STYLE(RegExpParser::defrule::backreference,RegExpParser::rule_type::styled_ALL),
|
||||
START_A_R(RegExpParser::rule_type::none),
|
||||
TEXTSIM("\\g"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::digits),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\\g{"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::zero_one | RegExpParser::rule_type::text, "-"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::digits),
|
||||
TEXTSIM("}"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\\g{"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
|
||||
TEXTSIM("}"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\\k<"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
|
||||
TEXTSIM(">"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\\k\'"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
|
||||
TEXTSIM("\'"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\\k{"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
|
||||
TEXTSIM("}"),
|
||||
ZERO,
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "(?P="),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
|
||||
TEXTSIM(")"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::hex4),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex),
|
||||
ZERO,
|
||||
START_R_STYLE(RegExpParser::defrule::character,RegExpParser::rule_type::styled_ALL),
|
||||
TEXTSIM("\\"),
|
||||
START_A_R(RegExpParser::rule_type::none),
|
||||
TEXT_TYPE(RegExpParser::rule_type::char_any, "acefnrt"),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::digit),
|
||||
START_A_R(RegExpParser::rule_type::zero_one),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::digit),
|
||||
USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::digit),
|
||||
ZERO,
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "o{"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::digit),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::digit),
|
||||
USE_RULE(RegExpParser::rule_type::one_more, RegExpParser::defrule::digit),
|
||||
TEXTSIM("}"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "x"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "x{"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex),
|
||||
USE_RULE(RegExpParser::rule_type::one_more, RegExpParser::defrule::hex),
|
||||
TEXTSIM("}"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "u"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex4),
|
||||
USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::hex4),
|
||||
ZERO,
|
||||
ZERO,
|
||||
START_R_STYLE(RegExpParser::defrule::character_type,RegExpParser::rule_type::styled_ALL),
|
||||
TEXTSIM("."),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\\"),
|
||||
START_A_R(RegExpParser::rule_type::none),
|
||||
TEXT_TYPE(RegExpParser::rule_type::char_any, "CdDhHNRsSvVwWX"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "p{"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::zero_one | RegExpParser::rule_type::text, "^"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
|
||||
TEXT_TYPE(RegExpParser::rule_type::zero_one | RegExpParser::rule_type::text, "&"),
|
||||
TEXTSIM("}"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "P{"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
|
||||
TEXT_TYPE(RegExpParser::rule_type::zero_one | RegExpParser::rule_type::text, "&"),
|
||||
TEXTSIM("}"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "p"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::letter),
|
||||
USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::letter),
|
||||
ZERO,
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::posix_character_class_name),
|
||||
TEXTSIM("alnum"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "alpha"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "ascii"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "blank"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "ctrl"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "digit"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "graph"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "lower"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "print"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "punct"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "space"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "upper"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "word"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "xdigit"),
|
||||
ZERO,
|
||||
START_R_STYLE(RegExpParser::defrule::posix_character_class,RegExpParser::rule_type::styled_ALL),
|
||||
TEXTSIM("[:"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::zero_one | RegExpParser::rule_type::text, "^"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::posix_character_class_name),
|
||||
TEXTSIM(":]"),
|
||||
//TEXT_TYPE(RegExpParser::rule_type::inversion | RegExpParser::rule_type::char_any | RegExpParser::rule_type::zero_one, "^"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::character_class_range_atom),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::character),
|
||||
TEXT_TYPE(RegExpParser::rule_type::inversion | RegExpParser::rule_type::char_any , "]"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::character_class_range),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::character_class_range_atom),
|
||||
TEXTSIM("-"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::character_class_range_atom),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::character_class_atom),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::quoting),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::character_class_range_atom),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::posix_character_class),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::character),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::character_type),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::inversion | RegExpParser::rule_type::char_any, "\\]"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::character_class),
|
||||
TEXTSIM("["),
|
||||
TEXT_TYPE(RegExpParser::rule_type::zero_one | RegExpParser::rule_type::text, "^"),
|
||||
TEXTSIM("]"),
|
||||
USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::character_class_atom),
|
||||
TEXTSIM("]"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "["),
|
||||
TEXT_TYPE(RegExpParser::rule_type::zero_one | RegExpParser::rule_type::text, "^"),
|
||||
USE_RULE(RegExpParser::rule_type::one_more, RegExpParser::defrule::character_class_atom),
|
||||
TEXTSIM("]"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::other),
|
||||
TEXT_TYPE(RegExpParser::rule_type::char_any | RegExpParser::rule_type::inversion, "\\^$.[|()?+{"),
|
||||
//TEXT_TYPE(RegExpParser::rule_type::none |RegExpParser::rule_type::special_dot, ""),
|
||||
//TEXT_TYPE(RegExpParser::rule_type::alternative |RegExpParser::rule_type::text, "\\"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::call_out),
|
||||
TEXTSIM("(?C"),
|
||||
USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::digits),
|
||||
TEXTSIM(")"),
|
||||
ZERO,
|
||||
START_R(RegExpParser::defrule::conditional_pattern),
|
||||
TEXTSIM("(?"),
|
||||
START_A_R(RegExpParser::rule_type::none),
|
||||
TEXTSIM("("),
|
||||
START_A_R(RegExpParser::rule_type::none),
|
||||
TEXT_TYPE(RegExpParser::rule_type::char_any | RegExpParser::rule_type::zero_one, "+-"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::digits),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "<"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
|
||||
TEXT_TYPE(RegExpParser::rule_type::text, ">"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\'"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
|
||||
TEXT_TYPE(RegExpParser::rule_type::text, "\'"),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "R&"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
|
||||
TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "R"),
|
||||
USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::digits),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::name),
|
||||
ZERO,
|
||||
TEXTSIM(")"),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::call_out),
|
||||
USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::lookaround),
|
||||
ZERO,
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::expr),
|
||||
START_A_R(RegExpParser::rule_type::zero_one),
|
||||
TEXTSIM("|"),
|
||||
USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::expr),
|
||||
ZERO,
|
||||
TEXTSIM(")"),
|
||||
ZERO,
|
||||
ZERO
|
||||
};
|
||||
#endif
|
||||
30
include/ctl/xh_styledtext.h
Normal file
30
include/ctl/xh_styledtext.h
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
//////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// pgAdmin III - PostgreSQL Tools
|
||||
//
|
||||
// Copyright (C) 2002 - 2016, The pgAdmin Development Team
|
||||
// This software is released under the PostgreSQL Licence
|
||||
//
|
||||
// xh_styledtext.h - wxStyledText handler
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
#ifndef _WX_XH_STYLEDTEXT_H_
|
||||
#define _WX_XH_STYLEDTEXT_H_
|
||||
|
||||
|
||||
#include "wx/xrc/xmlres.h"
|
||||
|
||||
//class WXDLLIMPEXP_XRC
|
||||
class ctlStyledTextXmlHandler : public wxXmlResourceHandler
|
||||
{
|
||||
DECLARE_DYNAMIC_CLASS(ctlStyledTextXmlHandler)
|
||||
public:
|
||||
ctlStyledTextXmlHandler();
|
||||
virtual wxObject *DoCreateResource();
|
||||
virtual bool CanHandle(wxXmlNode *node);
|
||||
};
|
||||
|
||||
|
||||
#endif // _WX_XH_STYLEDTEXT_H_
|
||||
|
|
@ -73,6 +73,8 @@
|
|||
#include "ctl/xh_ctltree.h"
|
||||
#include "ctl/xh_ctlchecktreeview.h"
|
||||
#include "ctl/xh_ctlcolourpicker.h"
|
||||
#include "ctl/xh_styledtext.h"
|
||||
|
||||
|
||||
#define DOC_DIR wxT("/docs")
|
||||
#define UI_DIR wxT("/ui")
|
||||
|
|
@ -508,7 +510,8 @@ bool pgAdmin3::OnInit()
|
|||
wxXmlResource::Get()->AddHandler(new ctlTreeXmlHandler);
|
||||
wxXmlResource::Get()->AddHandler(new ctlCheckTreeViewXmlHandler);
|
||||
wxXmlResource::Get()->AddHandler(new ctlColourPickerXmlHandler);
|
||||
|
||||
wxXmlResource::Get()->AddHandler(new ctlStyledTextXmlHandler);
|
||||
//wxXmlResource::Get()->AddHandler(new ctlTreeJSONXmlHandler);
|
||||
InitXml();
|
||||
|
||||
wxOGLInitialize();
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue