int CManageObject::NextWord(int offset)
{
if(_iCacheScore != -1)
{
if(PushWord(_iCacheScore, _stCacheRec, offset) != 0)
return -1;
}
return NextWord();
}
void McuMessageHandler::SendGetDealRecord(int i, EnumRecordFlag clear, int index)
{
StruMcuPacket *thepacket = CreatePacket();
McuPacket &packet = thepacket->packet;
PushByte(packet, ((m_pos_addr[i] << 4) & MCU_POS_SRC_ADDR));
PushByte(packet, 0x06);
PushByte(packet, MCU_POS_FLAG);
PushByte(packet, 0x38);
PushByte(packet, 0x31);
if(clear == CLEAR_RECORD)
{
PushByte(packet, 0x02);
}
else
{
PushByte(packet, 0x01);
}
PushWord(packet, index);
thepacket->data = (int)clear;
thepacket->data2 = i;
SendBody(thepacket, MCU_POS_GET_DEAL);
}
static int MakeRegex( DaoRegex *self, DString *ds, void *spatt,
int start, int end, int grouping )
{
DaoRgxItem *patt, *patt2, *split=NULL, *patts = self->items;
DaoRgxItem word = { PAT_NONE };
DaoRgxItem set = { PAT_NONE };
DCharState st = { 0, 1, 0 };
DCharState st2 = { 0, 1, 0 };
char *buf, *mbs = (char*) spatt;
int i, j, k, count=0, repeat=0, refgroup=0;
short type, gid = self->indexed >0 ? self->indexed + 1E4 : self->group;
int alts = DString_BalancedChar( ds, '|', '(', ')', '%', start, end, 1 );
daoint pos, pos2;
int chi, chi2;
if( alts >0 || grouping >0 ){
split = PushRegex( self, PAT_SPLIT );
split->gid = gid;
count = self->count;
}
self->indexed = 0;
word.next = set.next = 1;
word.jump = set.jump = 0;
for(i=start; i<end; i++){
int verbatim = 0;
chi = mbs[i];
chi2 = (i+1) >= end ? 0 : mbs[i+1];
type = 0;
k = i;
/* space chars are ignored, to avoid this, write as [ ][\t][\n] */
if( isspace( chi ) ){
if( word.type == PAT_WORD ) PushWord( self, & word );
continue;
}
if( chi == '%' ){
if( i+1 < end ) chi = mbs[i+1];
switch( chi ){
case 's': case 'S': case 'k': case 'K': case 'p': case 'P':
case 'c': case 'C': case 'a': case 'A': case 'w': case 'W':
case 'e': case 'E': case 'd': case 'D': case 'x': case 'X':
type = chi;
break;
case 't':
type = PAT_WORD;
SetWord( self, & word, i, L'\t' );
break;
case 'n':
type = PAT_WORD;
SetWord( self, & word, i, L'\n' );
break;
case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9':
j = ScanInteger( & refgroup, spatt, i+1, end );
type = PAT_BACKREF;
i += j-1;
break;
case 'b':
type = PAT_NONE;
if( i+3 < end ){
st = DString_DecodeChar( mbs + i + 2, mbs + end );
st2 = DString_DecodeChar( mbs + i + 2 + st.width, mbs + end );
chi = st.value;
chi2 = st2.value;
if( ! iswspace( chi ) && ! iswspace( chi2 ) ){
set.type = type = PAT_PAIR;
set.word = i + 1;
set.length = st.width + st2.width;
buf = self->wordbuf + set.word;
memcpy( buf, mbs + i + 2, set.length * sizeof(char) );
i += set.length;
}
}
break;
case 'B':
type = PAT_NONE;
chi = mbs[i+2];
if( chi == '{' ){
pos = DString_BalancedChar( ds, '}','{','}','%', i+3, end, 0 );
chi = 0;
pos2 = DAO_NULLPOS;
if( pos != DAO_NULLPOS ){
chi = mbs[pos+1];
pos2 = DString_BalancedChar( ds, '}','{','}','%', pos+2, end, 0 );
}
if( chi == '{' && pos2 != DAO_NULLPOS ){
short count2, count3;
count2 = self->count;
patt = PushRegex( self, PAT_PATPAIR );
PushRegex( self, PAT_BEGIN );
MakeRegex( self, ds, spatt, i+3, pos, 0 );
PushRegex( self, PAT_STOP );
count3 = self->count;
PushRegex( self, PAT_BEGIN );
MakeRegex( self, ds, spatt, pos+2, pos2, 0 );
PushRegex( self, PAT_STOP );
patt->next = self->count - count2;
patt->length = count3 - count2;
i = pos2;
i += SetRepeat( & patt->min, & patt->max, spatt, ds, i+1, end );
continue;
}
}
break;
default :
type = (i+1 < end) ? PAT_WORD : PAT_NONE;
SetWord( self, & word, i, chi );
break;
}
i ++;
}else if( chi == '{' && chi2 == '{' ){ /* {{text}} */
verbatim = 1;
type = PAT_WORD;
i += 2;
while( i < end ){
chi = mbs[i];
i += 1;
/* printf( "%c\n", chi ); */
if( chi == '}' ) break;
SetWord( self, & word, i-1, chi );
}
chi = 0;
k = i - 1;
if( i < end ){
chi = mbs[i];
k = i;
}
if( chi != '}' ) type = PAT_NONE;
}else if( chi == '(' ){
if( word.type == PAT_WORD ) PushWord( self, & word );
pos = DString_BalancedChar( ds, ')', '(', ')', '%', i+1, end, 0 );
if( pos != DAO_NULLPOS ){
self->group ++;
MakeRegex( self, ds, spatt, i+1, pos, 1 );
i = pos;
continue;
}
}else if( chi == '[' ){
pos = DString_BalancedChar( ds, ']', 0, 0, '%', i+1, end, 0 );
pos2 = DString_BalancedChar( ds, '[', '[', ']', '%', i+1, end, 0 );
if( pos == i+2 && pos2 == DAO_NULLPOS ){
type = PAT_WORD;
i ++;
chi = mbs[i];
SetWord( self, & word, i, chi );
i = pos;
}else if( pos != DAO_NULLPOS && pos2 == DAO_NULLPOS ){
type = PAT_SET;
set.type = PAT_SET;
set.length = pos - i - 1;
set.word = i + 1;
buf = self->wordbuf + set.word;
memcpy( buf, mbs + i + 1, set.length * sizeof(char) );
buf[ set.length ] = 0;
i = pos;
}else{
type = PAT_NONE;
}
}else if( chi == '<' ){
int k;
if( word.type == PAT_WORD ) PushWord( self, & word );
j = SkipSpace( spatt, i+1, end ); i += j+1;
chi = mbs[i];
k = i;
if( isdigit( chi ) ){
j = ScanInteger( & k, spatt, i, end ); i += j;
self->indexed = k;
}else if( islower( chi ) ){
if( strncmp( mbs + i, "min", 3 ) ==0 ){
self->config |= PAT_CONFIG_MIN;
i += 3;
}
}else{
for(; i<end; i++){
chi = mbs[i];
if( chi == 'I' ){
self->config |= PAT_CONFIG_CASEINS;
}else if( chi == 'C' ){
self->config &= ~ PAT_CONFIG_CASEINS;
}else{
break;
}
}
}
j = SkipSpace( spatt, i, end ); i += j;
chi = mbs[i];
if( chi == '>' && k != i ){
continue;
}else{
type = PAT_NONE;
}
}else if( chi == '.' ){
type = PAT_ANY;
}else if( chi == '|' ){
if( word.type == PAT_WORD ) PushWord( self, & word );
patt2 = PushRegex( self, PAT_JOIN );
patt = PushRegex( self, PAT_SPLIT );
patt->gid = patt2->gid = gid;
if( split ) split->jump = patt - split;
split = patt;
continue;
}else if( chi == '^' ){
type = PAT_START;
}else if( chi == '$' ){
type = PAT_END;
}else if( chi == '&' ){
type = PAT_WBORDER;
}else{
type = PAT_NONE;
switch( chi ){
case ']': case ')': case '{': case '}': case '|':
case '-': case '?': case '*': case '+': break;
default : type = PAT_WORD; break;
}
if( type == PAT_WORD ) SetWord( self, & word, i, chi );
}
if( type != PAT_WORD && word.type == PAT_WORD ) PushWord( self, & word );
patt = patts + self->count;
patt->type = type;
patt->gid = 0;
patt->min = patt->max = 1;
patt->next = 1;
patt->jump = 0;
if( type == PAT_BACKREF ) patt->gid = refgroup;
if( type == PAT_NONE ) patt->length = k + 1; /* store the error position */
if( word.type == PAT_WORD ){
patt->word = word.word;
patt->length = word.length;
}else if( set.type == PAT_SET || set.type == PAT_PAIR ){
patt->word = set.word;
patt->length = set.length;
set.type = PAT_NONE;
}
repeat = SetRepeat( & patt->min, & patt->max, spatt, ds, i+1, end );
i += repeat;
if( patt->type == PAT_WORD && repeat && verbatim == 0 && patt->length > 1 ){
/* Handle single character repetition: */
int offset = patt->word;
int length = patt->length;
int min = patt->min;
int max = patt->max;
self->count += 1;
patt->min = patt->max = 1;
patt->length -= 1;
patt = PushRegex( self, PAT_WORD );
patt->min = min;
patt->max = max;
patt->word = offset + length - 1;
patt->length = 1;
self->count -= 1;
}
if( patt->type != PAT_WORD || repeat ){
patt2 = NULL;
if( self->count ) patt2 = patts + (self->count-1);
if( patt2 && RegexCompare( self, patt, patt2 ) ){
patt2->min += patt->min;
if( patt2->max >=0 && patt->max >=0 ){
patt2->max += patt->max;
}else{
patt2->max = -1;
}
}else{
patt->config = self->config;
self->count ++;
}
word.type = PAT_NONE;
}
}
if( word.type == PAT_WORD ) PushWord( self, & word );
if( alts >0 || grouping >0 ){
patt = PushRegex( self, PAT_JOIN );
patt->gid = gid;
for(j=count; j<self->count; j++){
patt = patts + j;
if( patt->type == PAT_JOIN && patt->gid == gid )
patt->next = self->count - j;
if( patt->gid == gid && j+1 < self->count ){
/* for PAT_SPLIT added for | in groups,
* required for calculate matching length */
if( patt->type == PAT_SPLIT ) patt->gid = 0;
}
}
split->length = self->count - count;
}
return self->count;
}
