void LoadPack(){
packInfo.keyslot = 0x2C; packInfo.keyY = KeyY; packInfo.ctr = Ctr; packInfo.size = FILEPACK_SIZE; packInfo.buffer = FILEPACK_ADDR;
File FilePack; FileOpen(&FilePack, "rxTools.dat", 0);
curSize = FileRead(&FilePack, FILEPACK_ADDR, FILEPACK_SIZE, FILEPACK_OFF);
FileClose(&FilePack);
DecryptPartition(&packInfo);
nEntry = *((unsigned int*)(FILEPACK_ADDR));
Entry = ((PackEntry*)(FILEPACK_ADDR + 0x10));
for(int i = 0; i < nEntry; i++){
Entry[i].off += (int)FILEPACK_ADDR;
if(!CheckHash((void*)Entry[i].off, Entry[i].size, Entry[i].hash)){
DrawString(TOP_SCREEN, " rxTools.dat is corrupted!", 0, 240-8, BLACK, WHITE); //Who knows, if there is any corruption in our files, we need to stop
while(1);
}
}
}
int DeData(BYTE * DataBuf, int DataLen)
{
DATA temp;
int result = 0;
int length = 0;
memset(RecvBuf,0,sizeof(RecvBuf));
if(DataLen<4)
return -3;
length = DataBuf[2] * 0x100 + DataBuf[3];
if(DataBuf[0] != 0x88 || DataLen - 5 != length || DataBuf[DataLen -1] != 0x77)
{
memcpy(RecvBuf,&DataBuf,DataLen);
return -3;
}
memcpy(RecvBuf,&DataBuf[4],length);
temp.x = RecvBuf;
temp.length = length;
#if ZIP_ENCRYPT_ENABLE
if((DataBuf[1] & EXE_ENCRYPT) == EXE_ENCRYPT)
{
RD_DeMain(&temp, m_key);
}
#endif
#if ZIP_SHA_ENABLE
if((DataBuf[1] & EXE_SHA) == EXE_SHA)
{
if((result = CheckHash (&temp))==-2) //校验散列值
return result;
}
#endif
if((DataBuf[1] & EXE_COMPRESS_NEW) == EXE_COMPRESS_NEW)
{
Expand(&temp);
}
return temp.length;
}
STDMETHODIMP CAssemblyStream::Commit(DWORD dwCommitFlags)
{
BOOL fRet;
HRESULT hr;
IAssemblyName *pName = NULL;
IAssemblyName *pNameCopy = NULL;
IAssemblyManifestImport *pImport = NULL;
if(FAILED(hr = AddSizeToItem()))
goto exit;
fRet = CloseHandle (_hf);
_hf = INVALID_HANDLE_VALUE;
hr = fRet? S_OK : HRESULT_FROM_WIN32(GetLastError());
if (FAILED(hr))
goto exit;
// If this file contains a manifest extract the
// name and set it on the parent cache item.
switch (_dwFormat)
{
case STREAM_FORMAT_COMPLIB_MANIFEST:
{
// If a manifest interface has not already been
// set on this item, construct one from path.
if (!(pImport = _pParent->GetManifestInterface()))
{
if (FAILED(hr = CreateAssemblyManifestImport(_szPath, &pImport)))
goto exit;
if(FAILED(hr = _pParent->SetManifestInterface( pImport )))
goto exit;
}
// Get the read-only name def.
if (FAILED(hr = pImport->GetAssemblyNameDef(&pName)))
goto exit;
// Make a writeable copy of the name def.
if (FAILED(hr = pName->Clone(&pNameCopy)))
goto exit;
// Cache this on the parent cache item.
if (FAILED(hr = _pParent->SetNameDef(pNameCopy)))
goto exit;
}
break;
case STREAM_FORMAT_COMPLIB_MODULE:
{
if( FAILED(hr = CheckHash()) )
goto exit;
}
break;
} // end switch
exit:
SAFERELEASE(pImport);
SAFERELEASE(pName);
SAFERELEASE(pNameCopy);
CryptDestroyHash(_hHash);
_hHash = 0;
ReleaseParent (hr);
return hr;
}
int main(int argc, char **argv) {
const char *lexiconDir = getenv("DEVELOPERS_TAGGER_LEXICON");
char *opt = NULL;
int i;
for (i=1; i<argc && argv[i][0] == '-'; i++)
if (argv[i][1] == 'l') {
if (++i < argc)
lexiconDir = argv[i];
else
return PrintUsage(argv[0]);
} else if (argv[i][1] == 's') {
if (++i < argc) {
xSettingsFile = argv[i];
ReadSettings(lexiconDir, xSettingsFile);
} else
return PrintUsage(argv[0]);
} else if (argv[i][1] == 'o') {
xOptimize = true;
opt = argv[i]+2;
} else if (argv[i][1] == 'f') {
if (++i < argc)
xScope = atof(argv[i]);
else
return PrintUsage(argv[0]);
}
else for (int j=1; argv[i][j]; j++)
switch(argv[i][j]) {
case 'Q': neg(xExtractTesaurus); break;
case 'Z': neg(xExtractKeyWords); break;
case 'A': neg(xPrintAllWords); break;
case 'B': neg(xPrintLemma); break;
case 'C': neg(xPrintCorrectTag); break;
case 'D': neg(xTestInflections); break;
case 'F': neg(xCountFaults); break;
case 'G': neg(xGuessRulesForWords); break;
case 'H': neg(xSelectUnknownLemmas); break;
case 'I': neg(xGenerateInflections); break;
case 'J': neg(xPrintWordInfo); break;
case 'K': neg(xNoCollocations); break;
case 'L': neg(xListMultipleLemmas); break;
case 'M': neg(xPrintAllWordTags); break;
case 'P': neg(xCompoundRequirePrefix); break;
case 'N': neg(xListNewWords); break;
case 'S': neg(xPrintSelectedTag); break;
case 'U': neg(xPrintUnknownLemmas); break;
//jonas case 'a': neg(xAmbiguousNewWords); break;
case 'b': neg(xNoTagging); break; // jonas
case 'c': neg(xMorfCapital); break;
case 'd': neg(xTagTrigramsUsed); break;
case 'e': neg(xEvaluateTagging); break;
case 'f': std::cerr << "this shouldn't happen" << std::endl; break;
case 'g': neg(xGoldenRatio); break;
case 'h': neg(xCheckLexicons); break;
case 'i': neg(xIgnoreCitation); break;
case 'j': xMinLastChars = atoi(argv[i]+j+1); argv[i][j+1]=0; break;
case 'k': neg(xMorfCommonSuffix); break;
case 'l': std::cerr << "this shouldn't happen" << std::endl; break;
case 'm': neg(xTestFeatures); break;
case 'n': neg(xMorfNonCapital); break;
case 'O': neg(xOptimizeImportantParameters); break;
case 'o': std::cerr << "this shouldn't happen" << std::endl; break;
case 'p': neg(xCountPunctuationMarksAsWords); break;
case 'q': xTaggingEquation = atoi(argv[i]+j+1); argv[i][j+1]=0; break;
case 'r': neg(xRandomize); break;
case 's': std::cerr << "this shouldn't happen" << std::endl; break;
case 't': neg(xTakeTime); break;
case 'u': neg(xAnalyzeNewWords); break;
case 'v': neg(xVerbose); break;
case 'w': neg(xNewWordsMemberTaggingOnly); break;
case 'x': neg(xCheckLetters); break;
case 'y': xMaxLastChars = atoi(argv[i]+j+1); argv[i][j+1]=0; break;
case 'z': neg(xReadSettings); break; // jonas
case 'E': neg(xGenerateExtraWordTags); break;
case 'W': neg(xWarnAll); break;
case 'R': neg(xRepeatTest); break;
//jonas case 'X': neg(xSimplifyText); break;
default: return PrintUsage(argv[0]);
}
if (i == argc) {
argv[i] = getenv("DEVELOPERS_TAGGER_OPT_TEXT");
if (!argv[i])
return PrintUsage(argv[0]);
argc++;
}
if (!lexiconDir)
return PrintUsage(argv[0]);
xPrint = xPrintCorrectTag || xPrintSelectedTag || xPrintAllWords;
std::cout.precision(5);
if (xCheckLetters) {
CheckHash();
// doLetterTest();
return 0;
}
DevelopersTagger tagger;
tagger.Load(lexiconDir);
if (xExtractTesaurus) {
tagger.ExtractTesaurusWordTags("/afs/nada.kth.se/misc/tcs/lexicons/riksdan/tesaurus/tesaurus.txt");
return 0;
}
if(xReadSettings) { // jonas
ReadSettings(tagger.LexiconDir(), "settings");
}
if (xExtractKeyWords) {
tagger.LoadTesaurus("/afs/nada.kth.se/misc/tcs/granska/suc/lexicons/tesaurus.wtl",
"/afs/nada.kth.se/misc/tcs/lexicons/riksdan/tesaurus/tesaurus.txt");
std::ifstream in;
tagger.ExtractIndexWords(&argv[i], argc-i);
return 0;
}
Message(MSG_COUNTS, "during loading");
if (xPrintUnknownLemmas)
return 0;
if (xCheckLexicons)
tagger.LexiconCheck();
if (xGenerateExtraWordTags) {
tagger.GenerateExtraWordTags(xSelectUnknownLemmas);
return 0;
}
if (xGenerateInflections) {
tagger.GenerateInflections();
return 0;
}
if (xGuessRulesForWords) {
tagger.GuessRulesForWords();
return 0;
}
if (xTestInflections) {
tagger.TestInflections();
return 0;
}
for (; i<argc; i++) {
std::ifstream in;
in.open(argv[i]);
if(!in) {
std::cerr << "could not open " << argv[i] << std::endl;
continue;
}
in.seekg (0, std::ios::end); // jonas
int inlength = in.tellg(); // jonas
in.seekg (0, std::ios::beg); // jonas
if(inlength < 1000)
inlength = 1000;
tagger.SetStream(&in, inlength);//jonas tagger.SetStream(&in, !strcmp(Extension(argv[i]), "html"));
if (xOptimize) {
tagger.Optimize(opt);
if (xPrint)
tagger.GetText().Print();
} else {
if (strcmp(Extension(argv[i]), "wt")) {
/* do ordinary tagging */
xEvaluateTagging = false;
xTaggedText = false;
xPrintCorrectTag = false;
if (!xPrint)
xPrint = true;
else
xPrintAllWords = true;
tagger.ReadText();
tagger.TagText();
if (xTakeTime)
tagger.PrintTimes();
if (xPrintAllWords || xPrintCorrectTag || xOutputWTL)
tagger.GetText().Print();
in.close();
return 0;
} else { // extension is .wt
xTaggedText = true;
tagger.ReadTaggedText();
}
Message(MSG_COUNTS, "during text reading");
if (xRepeatTest)
RepeatTest(tagger);
else {
tagger.ResetWords();
if(xNoTagging)
tagger.DontTagText(); // use "correct" tags as tagging
else
tagger.TagText();
if (xTakeTime)
tagger.PrintTimes();
if (xListNewWords) {
const Tagger *t = &tagger;
t->NewWords().PrintObjects();
} else {
if (xPrint)
tagger.GetText().Print();
if (xEvaluateTagging)
tagger.EvaluateTagging();
}
}
}
in.close();
}
if (xCheckLexicons)
tagger.PrintStatistics();
Message(MSG_COUNTS, "during tagging");
return 0;
}
