📄 re_syntex.inl
字号:
m_Syntex->m_Syntex.back() = Syntex;
return ree_ok;
}
re_error _parse_count(re_block * root,const re_char * & sz)
{
if(m_Syntex->m_Syntex.size() == 0)
return ree_syntex;
sz = Next(sz);
if(root->_is_end(sz))
return ree_syntex;
//<m:n>
re_char * end;
long m = to_int(sz,root->szEnd,&end);
if(m < 0)
return ree_syntex;
if(root->_is_end(end) || rt_colon != ToSize_t(end))
return ree_syntex;
sz = Next(end);
if(root->_is_end(sz))
return ree_syntex;
long n = to_int(sz,root->szEnd,&end);
if(end == sz)
{
n = -1;
if(root->_is_end(end) || rt_count_end != ToSize_t(end))
return ree_syntex;
}
else
{
if(n <= 0)
return ree_syntex;
if(m > n)
return ree_syntex;
if(root->_is_end(end) || rt_count_end != ToSize_t(end))
return ree_syntex;
}
sz = Next(end);
//<m:n>?
if(!root->_is_end(sz))
{
if(rt_zero_one == ToSize_t(sz))
{
rp_repeat_specify * Syntex = new rp_repeat_specify;
Syntex->m_Leaf = m_Syntex->m_Syntex.back();
Syntex->m_Min = m;
Syntex->m_Max = n;
m_Syntex->m_Syntex.back() = Syntex;
sz = Next(sz);
rp_array * pNew = new rp_array;
Syntex->m_Next = pNew;
m_Syntex->m_Syntex.push_back(pNew);
_push_syntex(pNew);
const re_char * szSave = root->szStart;
root->szStart = sz;
re_error e = _parse_array(root);
root->szStart = szSave;
_pop_syntex();
sz = root->szEnd;
return e;
}
}
rp_repeat_specify_greed * Syntex = new rp_repeat_specify_greed;
Syntex->m_Leaf = m_Syntex->m_Syntex.back();
Syntex->m_Min = m;
Syntex->m_Max = n;
m_Syntex->m_Syntex.back() = Syntex;
return ree_ok;
}
re_error _parse_exactness(const re_char * & sz)
{
rp_exactness * Syntex = new rp_exactness;
Syntex->m_Coding = ToSize_t(sz);
m_Syntex->m_Syntex.push_back(Syntex);
sz = Next(sz);
return ree_ok;
}
re_error _parse_escape(re_block * root,const re_char * & sz)
{
sz = Next(sz);
if(root->_is_end(sz))
return ree_syntex;
size_t c = ToSize_t(sz);
const re_char ** szAbbrevs = Abbrevs();
for(;*szAbbrevs; ++szAbbrevs)
{
if(ToSize_t(*szAbbrevs) == c)
{
const re_char * szSyntex = Next(*szAbbrevs);
rp_array * Syntex = new rp_array;
//save info
m_Syntex->m_Syntex.push_back(Syntex);
_push_syntex(Syntex);
const re_char * szEnd = reinterpret_cast<const re_char *>(reinterpret_cast<const char *>(szSyntex) + ByteLen(szSyntex));
re_error e = _parse(szSyntex,szEnd);
_pop_syntex();
sz = Next(sz);
return e == ree_ok ? ree_ok : ree_interior;
}
}
rp_exactness * Syntex = new rp_exactness;
Syntex->m_Coding = _get_escape_char(root,sz);
m_Syntex->m_Syntex.push_back(Syntex);
return ree_ok;
}
re_error _parse_array_root(re_block * root)
{
re_error e = ree_ok;
const re_char * sz = root->szStart;
while(!root->_is_end(sz))
{
switch(ToSize_t(sz))
{
case rt_any: //'.',
e = _parse_any(sz);
break;
case rt_escape: //'\\', //转义符号
e = _parse_escape(root,sz);
break;
case rt_begin_line: //'^', //作为多行匹配的时候，匹配行的开始
e = _parse_begin_line(sz);
break;
case rt_end_line: //'$', //作为多行匹配的时候，匹配行的结束。
//行的结束以'\r\n'或'\n'作为结束。根据一个选项决定如何匹配
e = _parse_end_line(sz);
break;
case rt_range_begin: //'[',
e = _parse_not_range(root,sz);
break;
case rt_more_zero: //'*',
e = _parse_more_zero(root,sz);
break;
case rt_more_one: //'+',
e = _parse_more_one(root,sz);
break;
case rt_zero_one: //'?',
e = _parse_zero_one(root,sz);
break;
case rt_count_begin: //'<', //<m:n>
e = _parse_count(root,sz);
break;
case rt_new_begin: //'(',
//case rt_new_end: //')',
case rt_group_begin: //'{',
//case rt_group_end: //'}',
case rt_not_regular: //'!', //否定正则表达式
e = _parse_not(root,sz);
break;
case rt_and_regular: //'&', //与正则表达式
case rt_or_regular: //'|', //或正则表达式
//case rt_range_end:
//case rt_count_end:
e = ree_interior;
break;
default:
e = _parse_exactness(sz);
break;
}
if(e != ree_ok)
break;
}
return e;
}
re_error _parse_array_or(re_block * root)
{
if(m_Syntex->m_Syntex.size() == 0)
return ree_syntex;
rp_array * Syntex = new rp_array;
_push_syntex(Syntex);
re_error e = _parse_block(root);
_pop_syntex();
if(e != ree_ok)
{
delete Syntex;
return e;
}
if(Syntex->m_Syntex.size() <= 0) //r|
{
delete Syntex;
return ree_syntex;
}
rp_or_regular * or = new rp_or_regular;
or->m_First = m_Syntex->m_Syntex.back();
or->m_Second = Syntex->m_Syntex.front();
m_Syntex->m_Syntex.back() = or;
rp_array::myvector::iterator i = Syntex->m_Syntex.begin();
for(++i;i!=Syntex->m_Syntex.end();++i)
m_Syntex->m_Syntex.push_back(*i);
Syntex->m_Syntex.clear();
delete Syntex;
return ree_ok;
}
re_error _parse_array_and(re_block * root)
{
if(m_Syntex->m_Syntex.size() == 0)
return ree_syntex;
rp_array * Syntex = new rp_array;
_push_syntex(Syntex);
re_error e = _parse_block(root);
_pop_syntex();
if(e != ree_ok)
{
delete Syntex;
return e;
}
if(Syntex->m_Syntex.size() <= 0) //r|
{
delete Syntex;
return ree_syntex;
}
rp_and_regular * and = new rp_and_regular;
and->m_First = m_Syntex->m_Syntex.back();
and->m_Second = Syntex->m_Syntex.front();
m_Syntex->m_Syntex.back() = and;
rp_array::myvector::iterator i = Syntex->m_Syntex.begin();
for(++i;i!=Syntex->m_Syntex.end();++i)
m_Syntex->m_Syntex.push_back(*i);
Syntex->m_Syntex.clear();
delete Syntex;
return ree_ok;
}
re_error _parse_array_new(re_block * root)
{
rp_array * Syntex = new rp_array;
m_Syntex->m_Syntex.push_back(Syntex);
_push_syntex(Syntex);
re_error e = _parse_block(root);
_pop_syntex();
if(Syntex->m_Syntex.size() == 0)
return ree_syntex;
return e;
}
re_error _parse_array_group(re_block * root)
{
rp_group * Syntex = new rp_group;
Syntex->m_GroupId = m_nGroupId;
++m_nGroupId;
m_Syntex->m_Syntex.push_back(Syntex);
_push_syntex(&Syntex->m_Array);
re_error e = _parse_block(root);
size_t s = m_Syntex->m_Syntex.size();
_pop_syntex();
if(s == 0)
return ree_syntex;
return e;
}
re_error _parse_array(re_block * root)
{
switch(root->eType)
{
case rt_root:
return _parse_array_root(root);
case rt_or_regular:
return _parse_array_or(root);
case rt_and_regular:
return _parse_array_and(root);
case rt_new_begin:
return _parse_array_new(root);
case rt_group_begin:
return _parse_array_group(root);
}
return ree_interior;
}
re_error _parse_block(re_block * block)
{
re_error e = ree_syntex;
for(re_block::myvector::iterator i=block->m_Block.begin();
i!=block->m_Block.end();
++i)
{
e = _parse_array(*i);
if(e != ree_ok)
break;
}
return e;
}
re_error _parse(const re_char * szStart,const re_char * szEnd)
{
re_block * block = new re_block;
block->eType = rt_root;
block->szStart = szStart;
block->szEnd = szEnd;
re_error e = _make_block(block);
if(e == ree_ok)
e = _parse_block(block);
delete block;
return e;
}
//-----------------------------------------------------------------------------
re_error _make_group_skip_range(re_block * root,const re_char * & szStart)
{
const re_char * sz = Next(szStart);
if(root->_is_end(sz))
return ree_syntex;
for(;!root->_is_end(sz);sz = Next(sz))
{
size_t c = ToSize_t(sz);
switch(c)
{
case rt_escape:
sz = Next(sz);
if(root->_is_end(sz))
return ree_syntex;
break;
case rt_range_end:
szStart = sz;
return ree_ok;
}
}
return ree_syntex;
}
re_error _make_group(re_block * root,const re_char * & szStart,re_types rtBegin,re_types rtEnd)
{
const re_char * sz = Next(szStart);
int nCount = 1;
for(;!root->_is_end(sz);)
{
size_t c = ToSize_t(sz);
if(rtBegin == static_cast<re_types>(c))
{
++nCount;
}
else if(rtEnd == static_cast<re_types>(c))
{
--nCount;
}
else if(rt_escape == static_cast<re_types>(c))
{
sz = Next(sz);
if(root->_is_end(sz))
return ree_syntex;
}
else if(rt_range_begin == static_cast<re_types>(c))
{
re_error e = _make_group_skip_range(root,sz);
if(e != ree_ok)
return e;
}
if(nCount == 0)
break;
sz = Next(sz);
}
if(nCount != 0)
return ree_syntex;
re_block * block = new re_block;
block->eType = rtBegin;
block->szStart = Next(szStart);
block->szEnd = sz;
root->m_Block.push_back(block);
re_error e = _make_block(block);
if(e != ree_ok)
return e;
szStart = Next(sz);
return ree_ok;
}
void _save_last_block(re_block * root,const re_char * & szStart,const re_char * szEnd)
{
if(szStart < szEnd)
{
re_block * block = new re_block;
block->eType = rt_root;
block->szStart = szStart;
block->szEnd = szEnd;
root->m_Block.push_back(block);
}
}
re_error _make_block(re_block * root)
{
re_error e;
const re_char * sz = root->szStart;
const re_char * szBlockStart = sz;
while(!root->_is_end(sz))
{
size_t rt = ToSize_t(sz);
switch(rt)
{
case rt_escape: //'\\', //转义符号
sz = Next(sz);
if(root->_is_end(sz))
return ree_syntex;
sz = Next(sz);
break;
case rt_new_begin: //'(',
_save_last_block(root,szBlockStart,sz);
e = _make_group(root,sz,rt_new_begin,rt_new_end);
if(e != ree_ok)
return e;
szBlockStart = sz;
break;
case rt_new_end: //')',
return ree_syntex;
case rt_group_begin: //'{',
_save_last_block(root,szBlockStart,sz);
e = _make_group(root,sz,rt_group_begin,rt_group_end);
if(e != ree_ok)
return e;
szBlockStart = sz;
break;
case rt_group_end: //'}',
return ree_syntex;
case rt_and_regular: //'&', //与正则表达式
case rt_or_regular: //'|', //或正则表达式
{
_save_last_block(root,szBlockStart,sz);
sz = Next(sz);
if(root->_is_end(sz))
return ree_syntex;
re_block * block = new re_block;
block->eType = static_cast<re_types>(rt);
block->szStart = sz;
block->szEnd = root->szEnd;
root->m_Block.push_back(block);
e = _make_block(block);
if(e != ree_ok)
return e;
szBlockStart = sz = root->szEnd;
}
break;
case rt_range_begin:
e = _make_group_skip_range(root,sz);
if(e != ree_ok)
return e;
sz = Next(sz);
break;
default:
sz = Next(sz);
break;
}
}
_save_last_block(root,szBlockStart,sz);
return ree_ok;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -