示例#1
0
// **************************************************************************
// Function:   LoadDictionary
// Purpose:    This function loads a dictionary file
// Parameters: dictionaryfile - filename of the dictionary file
//             eraseold - true  ... deletes all existing words in the dictionary
//                        false ... does not delete existing words in the dictionary
// Returns:    0 ... error
//             1 ... OK
// **************************************************************************
int DICTIONARY::LoadDictionary(const char *dictionaryfile, bool eraseold)
{
char    line[MAX_WORDLENGTH];
FILE    *fp;
int     i;

 if (eraseold) DeleteWords();

 fp=fopen(dictionaryfile, "rb");
 if (!fp) return(0);

 
 while (!feof(fp))
  {
  fgets(line, MAX_WORDLENGTH, fp);
  line[MAX_WORDLENGTH-1]=0;
  for (i=0; i<(int)strlen(line); i++)
   if ((line[i] == ' ') || (line[i] == '\r') || (line[i] == '\n'))
      line[i]=0;
  AddWord(line);
  }
 fclose(fp);

 return(1);
}
示例#2
0
void Phrase::Append(const Phrase &endPhrase)
{

  for (size_t i = 0; i < endPhrase.GetSize(); i++) {
    AddWord(endPhrase.GetWord(i));
  }
}
示例#3
0
文件: niall.c 项目: Farthen/OTFBot
/* Create a new, blank dictionary
*/
void Niall_NewDictionary(void)
{
	ClearDictionary();

	WordList=AddWord("");
	if(!WordList) Niall_Error("Out of memory.");
}
示例#4
0
文件: protocol.c 项目: softirq/common
/*-----------------------------------------------------------------------------
 *  add a string.string = wlen + buffer
 *-----------------------------------------------------------------------------*/
int AddString(char **p, int *piLenLeft, char *pBuf, uint16_t wBufLen)
{
    int iLeftLen = 5000;
    char *pCur = NULL;

    if(AddWord(p, piLenLeft,wBufLen) != 0)
        return -1;

    pCur = *p;
    if(piLenLeft)
        iLeftLen = *piLenLeft;

    if(iLeftLen < wBufLen)
        return -2;

    memcpy(pCur, pBuf, wBufLen);
    pCur += wBufLen;
    iLeftLen -= wBufLen;

    *p = pCur;
    if(piLenLeft)
        *piLenLeft = iLeftLen;

    return 0;
}
示例#5
0
Phrase::Phrase(const vector< const Word* > &mergeWords)
{
  m_words.reserve(mergeWords.size());
  for (size_t currPos = 0 ; currPos < mergeWords.size() ; currPos++) {
    AddWord(*mergeWords[currPos]);
  }
}
示例#6
0
void WordFinder::AddWords( std::vector<std::string> words )
{
	for (int i = 0; i < words.size(); i++)
	{
		AddWord(words[i], i+1);
	}
}
Phrase::Phrase(FactorDirection direction, const vector< const Word* > &mergeWords)
  :m_direction(direction)
{
  m_words.reserve(mergeWords.size());
  for (size_t currPos = 0 ; currPos < mergeWords.size() ; currPos++) {
    AddWord(*mergeWords[currPos]);
  }
}
示例#8
0
文件: niall.c 项目: Farthen/OTFBot
/* Load a dictionary
*/
void Niall_LoadDictionary(char *FileName)
{
	char Buffer[BUFSIZ];
	FILE *fHandle;
	int nWords,i,d;
	int nAsocs,j,w,p,k;
	WORD *Word;

	fHandle=fopen(FileName,"r");
	if(!fHandle)
	{
		Niall_Warning("File %s not found.",FileName);
		return;
	}
	fscanf(fHandle,"%s %d\n",Buffer,&nWords);
	if((strcmp(Buffer,FILE_ID))||(nWords<2))
	{
		Niall_Warning("File %s is not a valid Niall file.",FileName);
		return;
	}
	ClearDictionary();

	for(i=0;i<nWords;i++)
	{
		fscanf(fHandle,"%4d: %s %d|",&d,Buffer,&nAsocs);
		if((d!=i)||(nAsocs<1))
		{
			Niall_Warning("Word %d is corrupted.",i);
			Niall_NewDictionary();
			return;
		}
		if(Buffer[0]=='>')
		{
			if(i!=0)
			{
				Niall_Warning("Word %d is corrupted.",i);
				Niall_NewDictionary();
				return;
			}
			Buffer[0]=0;
		}
		Word=AddWord(Buffer);
		if(Word==NULL) Niall_Error("Out of memory.");

		for(j=0;j<nAsocs;)
		{
			fscanf(fHandle," %d(%d)",&w,&p);
			if(w>=nWords)
			{
				Niall_Warning("Word %d/Assoc %d is corrupted.",i,j);
				Niall_NewDictionary();
				return;
			}
			for(k=0;k<p;k++) Associate(Word,w);
			j+=p;
		}
	}
}
示例#9
0
void TSwSet::LoadFromFile(const TStr& FNm) {
    TStr FileStr = TStr::LoadTxt(FNm);
    FileStr.DelChAll('\r');
    TStrV WordV; FileStr.SplitOnAllCh('\n', WordV);
    for (int WordN = 0; WordN < WordV.Len(); WordN++) {
        const TStr& WordStr = WordV[WordN];
        if (!IsIn(WordStr)) { AddWord(WordStr); }
    }
}
示例#10
0
/**
 *push消息的组包
 */
int ComposePkg(tASecMsgHead &stHead, tASecPushMsgReq &stReq, uint8_t *pPkg, int& iPkgBufSize)
{
	//数据预处理.做个保护措施

	char szPkgBuf[2048];
	char *pCur = szPkgBuf;

	bzero(szPkgBuf, sizeof(szPkgBuf));

	*pCur = 0x02;
	pCur++;

	tASecMsgHead* pHead = (tASecMsgHead*)pCur;
	pCur+=sizeof(tASecMsgHead);

	memcpy(pHead, &stHead, sizeof(stHead));

	if(stReq.usENLen > sizeof(stReq.aucEN)
			|| stReq.usReservedLen > sizeof(stReq.aucReserved))
	{
		return -1;
	}

	AddWord(&pCur, NULL, stReq.usENLen);
	AddFixData(&pCur, NULL, (char*)stReq.aucEN, stReq.usENLen);
	AddWord(&pCur, NULL, stReq.usReservedLen);
	AddFixData(&pCur, NULL, (char*)stReq.aucReserved, stReq.usReservedLen);

	*pCur = 0x03;
	pCur++;

	int iPkgLen = pCur-szPkgBuf;
	if (iPkgLen > iPkgBufSize)
	{
		return -2;
	}

	pHead->usLength = iPkgLen;
	Hton(pHead);

	memcpy(pPkg, szPkgBuf, iPkgLen);
	iPkgBufSize=iPkgLen;
	return 0;
}
示例#11
0
void wxHtmlWinParser::AddPreBlock(const wxString& text)
{
    if ( text.find('\t') != wxString::npos )
    {
        wxString text2;
        text2.reserve(text.length());

        const wxString::const_iterator end = text.end();
        wxString::const_iterator copyFrom = text.begin();
        size_t pos = 0;
        int posColumn = m_posColumn;
        for ( wxString::const_iterator i = copyFrom; i != end; ++i, ++pos )
        {
            if ( *i == '\t' )
            {
                if ( copyFrom != i )
                    text2.append(copyFrom, i);

                const unsigned SPACES_PER_TAB = 8;
                const size_t expandTo = SPACES_PER_TAB - posColumn % SPACES_PER_TAB;
                text2.append(expandTo, ' ');

                posColumn += expandTo;
                copyFrom = i + 1;
            }
            else
            {
                ++posColumn;
            }
        }
        if ( copyFrom != text.end() )
            text2.append(copyFrom, text.end());

        AddWord(new wxHtmlWordWithTabsCell(text2, text, m_posColumn, *(GetDC())));

        m_posColumn = posColumn;
    }
    else
    {
        // no special formatting needed
        AddWord(text);
        m_posColumn += text.length();
    }
}
NS_IMETHODIMP 
mozSpellChecker::AddWordToPersonalDictionary(const nsAString &aWord)
{
  nsresult res;
  PRUnichar empty=0;
  if (!mPersonalDictionary)
    return NS_ERROR_NULL_POINTER;
  res = mPersonalDictionary->AddWord(PromiseFlatString(aWord).get(),&empty);
  return res;
}
示例#13
0
VOID AinMessage::AddStr(LPCSTR pStr)
{
	if(NULL == pStr)
	{
		assert(false);
		return;
	}
	WORD wStrLen = (WORD)strlen(pStr);
	AddWord(wStrLen);
	AddEx(pStr, wStrLen);		
}
示例#14
0
void Phrase::PrependWord(const Word &newWord)
{
  AddWord();

  // shift
  for (size_t pos = GetSize() - 1; pos >= 1; --pos) {
    const Word &word = m_words[pos - 1];
    m_words[pos] = word;
  }

  m_words[0] = newWord;
}
示例#15
0
void CMyFirewallDlg::OnBnClickedBwordAdd()
{
	UpdateData();
	WordFilter wf;
	wf.id = m_idWord++;
	char ascii[10];
	wcstombs( ascii, m_word, 10 );
	strcpy(wf.word, ascii);
	if( AddWord(wf) )	//send the rule
		m_listWords.InsertItem(LVIF_TEXT|LVIF_PARAM, m_listWords.GetItemCount(), m_word, 0, 0, 0, wf.id);
	m_word = "";
	UpdateData(false);
}
示例#16
0
void BadWords::Permute(const std::string& suffix,
        const std::vector<std::string>& parts,
        const std::vector<const std::vector<std::string> *>& values,
        int index, bool standalone, bool wildcards) {
    for (int i = 0; i < values[index]->size(); i++) {
        std::string word = parts[index] + (*values[index])[i] + suffix;
        if (index > 0) {
            Permute(word, parts, values, index - 1, standalone, wildcards);
        } else {
            AddWord(word, standalone, wildcards);
        }
    }
}
示例#17
0
void AddText (TraverseCtx &Ctx, const CString &sText)
{
    enum States
    {
        stateInText,
        stateInDelimeter,
        stateDone,
    };

    //	Parse the text into words

    char *pPos = sText.GetASCIIZPointer();
    char *pStart = pPos;
    int iState = stateInText;
    CString sWord;

    while (iState != stateDone)
    {
        bool bText = strIsAlphaNumeric(pPos);

        switch (iState)
        {
        case stateInText:
        {
            if (!bText)
            {
                AddWord(Ctx, CString(pStart, pPos - pStart));
                iState = stateInDelimeter;
            }
            break;
        }

        case stateInDelimeter:
        {
            if (bText)
            {
                pStart = pPos;
                iState = stateInText;
            }
            break;
        }
        }

        //	Next

        if (*pPos == '\0')
            iState = stateDone;
        else
            pPos++;
    }
}
示例#18
0
void Phrase::CreateFromStringNewFormat(FactorDirection direction
																			 , const std::vector<FactorType> &factorOrder
																			 , const std::string &phraseString
																			 , const std::string &factorDelimiter
																			 , Word &lhs)
{
	m_arity = 0;
	
	// parse
	vector<string> annotatedWordVector;
	Tokenize(annotatedWordVector, phraseString);
	// KOMMA|none ART|Def.Z NN|Neut.NotGen.Sg VVFIN|none 
	//		to
	// "KOMMA|none" "ART|Def.Z" "NN|Neut.NotGen.Sg" "VVFIN|none"
	
	for (size_t phrasePos = 0 ; phrasePos < annotatedWordVector.size() -  1 ; phrasePos++)
	{
		string &annotatedWord = annotatedWordVector[phrasePos];
		bool isNonTerminal;
		if (annotatedWord.substr(0, 1) == "[" && annotatedWord.substr(annotatedWord.size()-1, 1) == "]")
		{ // non-term
			isNonTerminal = true;
			
			size_t nextPos = annotatedWord.find("[", 1);
			assert(nextPos != string::npos);
			
			if (direction == Input)
				annotatedWord = annotatedWord.substr(1, nextPos - 2);
			else
				annotatedWord = annotatedWord.substr(nextPos + 1, annotatedWord.size() - nextPos - 2);
			
			m_arity++;
		}
		else
		{
			isNonTerminal = false;
		}
		
		Word &word = AddWord();
		word.CreateFromString(direction, factorOrder, annotatedWord, isNonTerminal);		
		
	}
	
	// lhs
	string &annotatedWord = annotatedWordVector.back();
	assert(annotatedWord.substr(0, 1) == "[" && annotatedWord.substr(annotatedWord.size()-1, 1) == "]");
	annotatedWord = annotatedWord.substr(1, annotatedWord.size() - 2);
	
	lhs.CreateFromString(direction, factorOrder, annotatedWord, true);		
	assert(lhs.IsNonTerminal());
}
示例#19
0
void Phrase::InitStartEndWord()
{
  FactorCollection &factorCollection = FactorCollection::Instance();

  Word startWord(Input);
  const Factor *factor = factorCollection.AddFactor(Input, 0, BOS_); // TODO - non-factored
  startWord.SetFactor(0, factor);
  PrependWord(startWord);

  Word endWord(Input);
  factor = factorCollection.AddFactor(Input, 0, EOS_); // TODO - non-factored
  endWord.SetFactor(0, factor);
  AddWord(endWord);
}
示例#20
0
void BacaDict(Tree *T)
{	
	char s[20];
	/* ALGORITMA */
	STARTKATA("Dictionary.txt");
	CreateTree(T);
	SetRoot(T,'\0', false);
	while(!EndKata)
	{
		KataToString(s);
		AddWord(T, s);
		ADVKATA();
	}
}
示例#21
0
 string alienOrder(vector<string>& words) {
     int n=words.size();
     if (!n) return "";
     
     next.clear();
     degree.clear();
     
     AddWord(words[0]);
     for (int i=1; i<n; ++i) {
         AddWord(words[i]);            
         Diff(words[i-1], words[i]);
     }
     
     queue<char> q;
     for (const auto& kv : degree) {
         if (kv.second==0) {
             q.push(kv.first);
         }
     }
     
     string res;
     while (!q.empty()) {
         res += q.front();
         for (char c : next[q.front()]) {
             if ((--degree[c]) == 0) {
                 q.push(c);
             }
         }
         q.pop();
     }
     
     for (const auto& kv : degree) {
         if (kv.second > 0)  return "";
     }
     
     return res;
 }
示例#22
0
bool IfExsist(Info *L,char *s)//搜索是否存在
{
	node *search;
	for(search=L->head->next;search!=NULL;search=search->next)
	{
		if(strcmp(search->word,s)==0)//如果相等!
		{
			search->num++;
			L->num++;
			return true;
		}
	}
	AddWord(L,s);
	return false;
}
示例#23
0
int CNetData::AddString(const char *pszString, int iSize)
{
	int iLen = Strnlen(pszString, iSize-1);

	if(m_iPos + (int)sizeof(unsigned short) + iLen > m_iSize)
		return -1;

	if(-1 == AddWord(iLen))
		return -1;

	memcpy(m_pBuf + m_iPos, pszString, iLen);
	m_iPos += iLen;

	return m_iPos;
}
CPVT_WordPlace CPDF_VariableText::InsertWord(const CPVT_WordPlace& place,
                                             uint16_t word,
                                             int32_t charset,
                                             const CPVT_WordProps* pWordProps) {
  int32_t nTotlaWords = GetTotalWords();
  if (m_nLimitChar > 0 && nTotlaWords >= m_nLimitChar)
    return place;
  if (m_nCharArray > 0 && nTotlaWords >= m_nCharArray)
    return place;

  CPVT_WordPlace newplace = place;
  newplace.nWordIndex++;
  if (m_bRichText) {
    CPVT_WordProps* pNewProps =
        pWordProps ? new CPVT_WordProps(*pWordProps) : new CPVT_WordProps();
    pNewProps->nFontIndex =
        GetWordFontIndex(word, charset, pWordProps->nFontIndex);
    return AddWord(newplace, CPVT_WordInfo(word, charset, -1, pNewProps));
  }
  int32_t nFontIndex =
      GetSubWord() > 0 ? GetDefaultFontIndex()
                       : GetWordFontIndex(word, charset, GetDefaultFontIndex());
  return AddWord(newplace, CPVT_WordInfo(word, charset, nFontIndex, nullptr));
}
示例#25
0
    INT32 CNetData::AddString(const CHAR *pszString, INT32 iSize)
    {
        static const INT32 BUFLEN = 4096;
        size_t iLen = 0;
		//去掉libiconv库的依赖,避免iphone可能的移植问题
		/*
        if ((m_iCharsetNet >= 0) || (m_iCharsetHost >= 0))
        {
            if (m_iCharsetNet != m_iCharsetHost)
            {
                static char szBuffer[BUFLEN];
                INT32 iResult = 0;
                iLen = BUFLEN;
                iResult = SDIconvCovert(g_szCharset[m_iCharsetNet], 
                    g_szCharset[m_iCharsetHost], const_cast<char*>(pszString), iSize, szBuffer, iLen);
                if (0 != iResult)
                {
                    return -1;
                }
                if((INT32)(m_iPos + (INT32)sizeof(UINT16) + iLen) > m_iSize)
                {
                    return -1;
                }
	            if(-1 == AddWord((UINT16)iLen))
                {
		            return -1;
                }
                memcpy(m_pBuf + m_iPos, szBuffer, iLen);
	            m_iPos += iLen;
                return m_iPos;
            }
        }
		*/

        iLen = Strnlen(pszString, iSize-1);

        if((INT32)(m_iPos + (INT32)sizeof(UINT16) + iLen) > m_iSize)
	        return -1;

        if(-1 == AddWord((UINT16)iLen))
	        return -1;

        memcpy(m_pBuf + m_iPos, pszString, iLen);
        m_iPos += iLen;

	    return m_iPos;
    }
示例#26
0
void CorpusReader::FillDocument(const proto_doc& source, const IntIntMap& vocab,
                                const set<int>& pos, const IntIntMap& synsets,
                                BaseDoc* doc) {
  doc->time_ = Time(source.date().year(), source.date().month(),
                    source.date().day());

  int sentences_seen = 0;
  for (int ss = 0; ss < source.sentences_size(); ++ss) {
    const lib_corpora_proto::Document_Sentence sent = source.sentences(ss);
    int words_added = 0;
    for (int ww = 0; ww < sent.words_size(); ++ww) {
      const lib_corpora_proto::Document_Sentence_Word word = sent.words(ww);
      if (AddWord(word, sentences_seen, vocab, pos, synsets, doc))
        ++words_added;
    }
    if (words_added > 0) ++sentences_seen;
  }
}
示例#27
0
UINT64 TargetPhrase::ReadFromFile(std::fstream &fileTP)
{
  UINT64 bytesRead = 0;

  fileTP.seekg(m_filePos);

  UINT64 numWords;
  fileTP.read((char*) &numWords, sizeof(UINT64));
  bytesRead += sizeof(UINT64);

  for (size_t ind = 0; ind < numWords; ++ind) {
    Word *word = new Word();
    bytesRead += word->ReadFromFile(fileTP);
    AddWord(word);
  }

  return bytesRead;
}
示例#28
0
void Phrase::CreateFromString(const std::vector<FactorType> &factorOrder
															, const vector< vector<string> > &phraseVector)
{
	FactorCollection &factorCollection = FactorCollection::Instance();

	for (size_t phrasePos = 0 ; phrasePos < phraseVector.size() ; phrasePos++)
	{
		// add word this phrase
		Word &word = AddWord();
		for (size_t currFactorIndex= 0 ; currFactorIndex < factorOrder.size() ; currFactorIndex++)
		{
			FactorType factorType = factorOrder[currFactorIndex];
			const string &factorStr = phraseVector[phrasePos][currFactorIndex];
			const Factor *factor = factorCollection.AddFactor(m_direction, factorType, factorStr); 
			word[factorType] = factor;
		}
	}
}
示例#29
0
void wxHtmlWinParser::FlushWordBuf(wxChar *buf, int& len)
{
    buf[len] = 0;

    for ( int i = 0; i < len; i++ )
    {
        if ( buf[i] == CUR_NBSP_VALUE )
            buf[i] = ' ';
    }

#if !wxUSE_UNICODE
    if (m_EncConv)
        m_EncConv->Convert(buf);
#endif

    AddWord(wxString(buf, len));

    len = 0;
}
示例#30
0
文件: wincc.c 项目: certik/vendor
WORDS *AddFile(WORDS *wbase, char *fnam)
{
   int i, len;
   len = strlen(fnam);
   assert(len > 2);
   if (fnam[len-1] = 'c' && fnam[len-2] == '.');
   {
      for (i=len-3; i > 0; i--)
      {
         if (fnam[i] == ' ' || fnam[i] == '/' || fnam[i] == '\\')
         {
            i++;
            break;
         }
      }
      wbase = AddWord(wbase, fnam+i, len-i-2);
   }
   return(wbase);
}