bool DictBase::SearchData(std::vector<std::string> &SearchWords, guint32 idxitem_offset, guint32 idxitem_size, gchar *origin_data)
{
int nWord = SearchWords.size();
std::vector<bool> WordFind(nWord, false);
int nfound=0;
if (dictfile)
fseek(dictfile, idxitem_offset, SEEK_SET);
if (dictfile)
fread(origin_data, idxitem_size, 1, dictfile);
else
dictdzfile->read(origin_data, idxitem_offset, idxitem_size);
gchar *p = origin_data;
guint32 sec_size;
int j;
if (!sametypesequence.empty()) {
gint sametypesequence_len = sametypesequence.length();
for (int i=0; i<sametypesequence_len-1; i++) {
switch (sametypesequence[i]) {
case 'm':
case 't':
case 'y':
case 'l':
case 'g':
case 'x':
case 'k':
case 'w':
case 'h':
for (j=0; j<nWord; j++)
// KMP() is faster than strstr() in theory. Really? Always be true?
//if (!WordFind[j] && strstr(p, SearchWords[j].c_str())) {
if (!WordFind[j] && KMP(p, strlen(p), SearchWords[j].c_str())!=-1) {
WordFind[j] = true;
++nfound;
}
if (nfound==nWord)
return true;
sec_size = strlen(p)+1;
p+=sec_size;
break;
default:
if (g_ascii_isupper(sametypesequence[i])) {
sec_size = get_uint32(p);
sec_size += sizeof(guint32);
} else {
sec_size = strlen(p)+1;
}
p+=sec_size;
}
}
switch (sametypesequence[sametypesequence_len-1]) {
case 'm':
case 't':
case 'y':
case 'l':
case 'g':
case 'x':
case 'k':
case 'w':
case 'h':
sec_size = idxitem_size - (p-origin_data);
for (j=0; j<nWord; j++)
//if (!WordFind[j] && g_strstr_len(p, sec_size, SearchWords[j].c_str())) {
if (!WordFind[j] && KMP(p, sec_size, SearchWords[j].c_str())!=-1) {
WordFind[j] = true;
++nfound;
}
if (nfound==nWord)
return true;
break;
}
} else {
while (guint32(p - origin_data)<idxitem_size) {
switch (*p) {
case 'm':
case 't':
case 'y':
case 'l':
case 'g':
case 'x':
case 'k':
case 'w':
case 'h':
for (j=0; j<nWord; j++)
if (!WordFind[j] && strstr(p, SearchWords[j].c_str())) {
WordFind[j] = true;
++nfound;
}
if (nfound==nWord)
return true;
sec_size = strlen(p)+1;
p+=sec_size;
break;
default:
if (g_ascii_isupper(*p)) {
sec_size = get_uint32(p);
sec_size += sizeof(guint32);
} else {
sec_size = strlen(p)+1;
}
p+=sec_size;
}
}
}
return false;
}
bool DictBase::SearchData(std::vector<std::string> &SearchWords, guint32 idxitem_offset, guint32 idxitem_size, gchar *origin_data)
{
const int nWord = SearchWords.size();
std::vector<bool> WordFind(nWord, false);
int nfound=0;
if (dictfile)
fseek(dictfile, idxitem_offset, SEEK_SET);
if (dictfile) {
size_t fread_size;
fread_size = fread(origin_data, idxitem_size, 1, dictfile);
if (fread_size != 1) {
g_print("fread error!\n");
}
} else {
dictdzfile->read(origin_data, idxitem_offset, idxitem_size);
}
gchar *p = origin_data;
guint32 sec_size;
int j;
if (!sametypesequence.empty()) {
const gint sametypesequence_len = sametypesequence.length();
for (int i=0; i<sametypesequence_len-1; i++) {
if(is_dict_data_type_search_data(sametypesequence[i])) {
sec_size = strlen(p);
for (j=0; j<nWord; j++)
// KMP() is faster than strstr() in theory. Really? Always be true?
if (!WordFind[j] && KMP(p, sec_size, SearchWords[j].c_str())!=-1) {
WordFind[j] = true;
++nfound;
}
if (nfound==nWord)
return true;
sec_size += sizeof(gchar);
p+=sec_size;
} else {
if (g_ascii_isupper(sametypesequence[i])) {
sec_size = g_ntohl(get_uint32(p));
sec_size += sizeof(guint32);
} else {
sec_size = strlen(p)+1;
}
p+=sec_size;
}
}
if(is_dict_data_type_search_data(sametypesequence[sametypesequence_len-1])) {
sec_size = idxitem_size - (p-origin_data);
for (j=0; j<nWord; j++)
if (!WordFind[j] && KMP(p, sec_size, SearchWords[j].c_str())!=-1) {
WordFind[j] = true;
++nfound;
}
if (nfound==nWord)
return true;
}
} else {
while (guint32(p - origin_data)<idxitem_size) {
if(is_dict_data_type_search_data(*p)) {
for (j=0; j<nWord; j++)
if (!WordFind[j] && strstr(p, SearchWords[j].c_str())) {
WordFind[j] = true;
++nfound;
}
if (nfound==nWord)
return true;
sec_size = strlen(p)+1;
p+=sec_size;
} else {
if (g_ascii_isupper(*p)) {
sec_size = g_ntohl(get_uint32(p));
sec_size += sizeof(guint32);
} else {
sec_size = strlen(p)+1;
}
p+=sec_size;
}
}
}
return false;
}
void global_declare(enum Syn_Type deType)
{
int len;
if(!getNextSyn_Noend())
return;
if(syn!=_Id)
error(Exp_Id);
if(!getNextSyn_Noend())
return;
switch(syn)
{
case _Sem:
if(deType==_Void)
error(Void_Variable);
else
{
ExplainGrammar(_Global_Var_Declare);
if(WordFind(now))
error(Re_declared);
else
Word_insert(now,_Type_Int);
}
break;
case _Br_Sq_Left:
if(deType==_Void)
error(Void_Variable);
if(WordFind(now))
{
error(Re_declared);
do
{
if(!getNextSyn_Noend())
return;
}
while(syn!=_Br_Sq_Right);
}
else
{
if(!getNextSyn_Noend())
return;
if(syn!=_Digit)
error(Exp_Constant);
else
{
sscanf(now,"%d",&len);
Word_insert(now,_Type_Int_arr,len);
if(!getNextSyn_Noend())
return;
if(syn!=_Br_Sq_Right)
error(Exp_Br_Sq_Right);
}
if(!getNextSyn_Noend())
return;
if(syn!=_Sem)
error(Exp_Sem);
ExplainGrammar(_Global_Arr_Declar);
}
break;
case _Br_Sm_Left:
Fun_insert(deType);
ExplainGrammar(_Fun_Declare);
break;
default :
error(Exp_Sem);
break;
}
}
enum Type expression()
{
WordTree* wdt;
FunTree* ft;
char tmp[Max_word_length];
int tNDS,len;
enum Type rType;
switch(syn)
{
case _Id:
if(!getNextSyn_Noend())
return _Type_Void;
switch(syn)
{
case _Br_Sq_Left:// array
wdt=WordFind(now);
if(wdt==NULL)
error(Word_NoFound);
if(wdt&&wdt->type!=_Type_Int_arr)
error(Use_var_to_arr);
if(!getNextSyn_Noend()) return _Type_Void;
tNDS=NeedSem;
NeedSem=0;
rType=expression();
NeedSem=tNDS;
if(rType==_Type_Void)
error(Br_Void);
if(syn!=_Br_Sq_Right)
error(Exp_Br_Sq_Right);
if(!getNextSyn_Noend()) return _Type_Int;
judgeNext();
rType=_Type_Int;
break;
case _Eql: //assignment
wdt=WordFind(now);
if(wdt==NULL)
error(Word_NoFound);
if(wdt&&wdt->type!=_Type_Int)
error(Use_arr_to_var);
rType=NextExpression();
if(rType==_Type_Void)
error(Eql_Void);
break;
case _Compare:
wdt=WordFind(now);
if(wdt==NULL)
error(Word_NoFound);
if(wdt&&wdt->type!=_Type_Int)
error(Use_arr_to_var);
rType=NextExpression();
if(rType==_Type_Void)
error(Com_Void);
break;
case _Op_Add:
case _Op_Mul:
wdt=WordFind(now);
if(wdt==NULL)
error(Word_NoFound);
if(wdt&&wdt->type!=_Type_Int)
error(Use_arr_to_var);
rType=NextExpression();
if(rType==_Type_Void)
error(Op_Void);
break;
case _Br_Sm_Left: //function
ft=FunTree_find(now);
if(ft==NULL)
{
rType=_Type_Void;
error(Fun_NoFound);
while(getNextSyn_Noend())
if(syn==_Br_Sm_Right)
break;
}
else
{
JudgePara(ft->para);
rType=ft->type;
}
// if(getNextSyn_Noend()) return rType;
judgeNext();
break;
case _Sem: //end expression
wdt=WordFind(now);
if(wdt)
rType=wdt->type;
else
{
error(Word_NoFound);
rType=_Type_Void;
}
if(!NeedSem) error(Unexp_Sem);
else getNextSyn();
break;
default:
if(NeedSem)error(Exp_Sem);
wdt=WordFind(now);
if(wdt)
rType=wdt->type;
else
{
error(Word_NoFound);
rType=_Type_Void;
}
break;
}
break;
case _Digit:
if(!getNextSyn_Noend()) return _Type_Int;
rType=_Type_Int;
judgeNext();
break;
case _If:
if(!getNextSyn_Noend()) return _Type_Void;
if(syn!=_Br_Sm_Left)
error(Exp_Br_Sm_Left);
if(!getNextSyn_Noend()) return _Type_Void;
tNDS=NeedSem;
NeedSem=0;
rType=expression();
NeedSem=tNDS;
if(rType==_Type_Void)
error(Br_Void);
if(syn!=_Br_Sm_Right)
error(Exp_Br_Sm_Right);
if(!getNextSyn_Noend()) return _Type_Void;
if(syn==_Br_Big_Left)
{
ReadExprssions();
if(!getNextSyn_Noend()) return _Type_Void;
}
else
{
expression();
// if(!getNextSyn_Noend()) return _Type_Void;
}
if(syn==_Else)
{
if(!getNextSyn_Noend()) return _Type_Void;
if(syn==_Br_Big_Left)
{
ReadExprssions();
if(!getNextSyn_Noend()) return _Type_Void;
}
else
{
expression();
// if(!getNextSyn_Noend()) return _Type_Void;
}
}
rType=_Type_Void;
break;
case _While:
if(!getNextSyn_Noend()) return _Type_Void;
if(syn!=_Br_Sm_Left)
error(Exp_Br_Sm_Left);
if(!getNextSyn_Noend()) return _Type_Void;
tNDS=NeedSem;
NeedSem=0;
rType=expression();
NeedSem=tNDS;
if(rType==_Type_Void)
error(Br_Void);
if(syn!=_Br_Sm_Right)
error(Exp_Br_Sm_Right);
if(!getNextSyn_Noend()) return _Type_Void;
if(syn==_Br_Big_Left)
{
ReadExprssions();
if(!getNextSyn_Noend()) return _Type_Void;
}
else expression();
rType=_Type_Void;
break;
case _Return:
if(!getNextSyn_Noend()) return _Type_Void;
rType=expression();
if(Stack_p==0)
error(Global_Return);
else if(rType!=FunTreeStack[Stack_p]->type)
error(Fun_Return);
rType=_Type_Void;
break;
case _Int: //local defination
if(!getNextSyn_Noend())
return _Type_Void;
if(syn!=_Id)
error(Exp_Id);
if(!getNextSyn_Noend())
return _Type_Void;
switch(syn)
{
case _Sem:
if(WordFind(now))
error(Re_declared);
else
Word_insert(now,_Type_Int);
if(getNextSyn_Noend()) return _Type_Void;
break;
case _Br_Sq_Left:
if(WordFind_now(now))
{
error(Re_declared);
do
{
if(!getNextSyn_Noend())
return _Type_Void;
}
while(syn!=_Br_Sq_Right);
}
else
{
strcpy(tmp,now);
if(!getNextSyn_Noend())
return _Type_Void;
if(syn!=_Digit)
error(Exp_Constant);
else
{
sscanf(now,"%d",&len);
Word_insert(tmp,_Type_Int_arr,len);
if(!getNextSyn_Noend())
return _Type_Void;
if(syn!=_Br_Sq_Right)
error(Exp_Br_Sq_Right);
}
if(!getNextSyn_Noend())
return _Type_Void;
if(syn!=_Sem)
error(Exp_Sem);
else getNextSyn();
}
break;
case _Br_Sm_Left:
error(Fun_InFun);
while(syn!=_Br_Sm_Right)
if(getNextSyn_Noend()) return _Type_Void;
break;
default :
error(Exp_Sem);
break;
}
break;
case _Br_Sm_Left:
if(!getNextSyn_Noend()) return _Type_Void;
tNDS=NeedSem;
NeedSem=0;
rType=expression();
NeedSem=tNDS;
if(rType!=_Type_Int)
error(Br_Void);
if(syn!=_Br_Sm_Right)
error(Exp_Br_Sm_Right);
else if(!getNextSyn_Noend()) return _Type_Void;
judgeNext();
break;
default:
error(Unexp_err);
getNextSyn_Noend();
rType=_Type_Void;
}
return rType;
}
