FileDataList splitDiffToFiles(const QByteArray &data)
{
FileDataList ret;
QString strData = data;
QString splitExpression;
if (data.contains("==== ") && data.contains(" ====\n")) {
// Perforce diff
splitExpression = "==== ([^\\n\\r]+) - ([^\\n\\r]+) ====";
} else if (data.contains("--- ") && data.contains("\n+++ ")) {
// Unified contextual diff
splitExpression = "\\-\\-\\- ([^\\n\\r]*)"
"\\n\\+\\+\\+ ([^\\n\\r]*)";
} else if (data.contains("*** ") && data.contains("\n--- ")) {
// Copied contextual diff
splitExpression = "\\*\\*\\* ([^\\n\\r]*) [0-9\\-]* [0-9:\\.]*[^\\n\\r]*"
"\\n\\-\\-\\- ([^\\n\\r]*) [0-9\\-]* [0-9:\\.]*[^\\n\\r]*";
} else {
ret.append(FileData("<not a diff>", data));
return ret;
}
int splitIndex = 0, previousSplit = -1;
QRegExp splitExpr(splitExpression);
QString filename, content;
// The algorithm works like this:
// On the first match we only get the filename of the first patch part
// On the second match (if any) we get the diff content, and the name of the next file patch
while (-1 != (splitIndex = splitExpr.indexIn(strData,splitIndex))) {
if (!filename.isEmpty()) {
QString content = strData.mid(previousSplit, splitIndex - previousSplit);
ret.append(FileData(filename, content.toLatin1()));
}
// If the first index in not at the beginning of the file, then we know there's content
// we're about to skip, which is common in commit diffs, so we get that content and give it
// a 'fake' filename.
if (previousSplit == -1 && splitIndex > 0 && filename.isEmpty()) {
QString content = strData.left(splitIndex);
ret.append(FileData("<Header information>", content.toLatin1()));
}
filename = splitExpr.cap(1);
previousSplit = splitIndex;
++splitIndex;
}
// Append the last patch content
if (!filename.isEmpty()) {
QString content = strData.mid(previousSplit);
ret.append(FileData(filename, content.toLatin1()));
}
return ret;
}
void CAfficheMesPol::OnCorrelationCalculdans()
{
char ch[30];
CString ch0;
FILE *Fichier;
CFileDialog FileData(FALSE,"*.xls",NULL,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,"EXCEL (*.xls)|*.xls||",this);
if (FileData.DoModal()==IDOK)
{
if (Fichier=fopen(FileData.GetPathName(),"w"))
{
SetCursor(LoadCursor(0,IDC_WAIT));
fprintf(Fichier,"Coefficient de correlation des paramètres sur les classe n°%d et n°%d\n",class1,class2);
for (int i=0;i<PolyMc.NPAR-1;i++)
{
for(int j=i+1;j<PolyMc.NPAR;j++)
{
sprintf(ch,"%1.4f",Correlation(i,j));
ch0=ch;
ch0=ch0.Left(ch0.Find("."))+","+ch0.Right(ch0.GetLength()-ch0.Find(".")-1);
fprintf(Fichier,DialPara->m_choisi[i]+" & "+DialPara->m_choisi[j]+";"+ch0+"\n");
}
}
fclose(Fichier);
SetCursor(LoadCursor(0,IDC_ARROW));
}
}
}
FString FMacErrorReport::FindCrashedAppPath() const
{
TArray<uint8> Data;
if(FFileHelper::LoadFileToArray(Data, *(ReportDirectory / TEXT("Report.wer"))))
{
CFStringRef CFString = CFStringCreateWithBytes(NULL, Data.GetData(), Data.Num(), kCFStringEncodingUTF16LE, true);
FString FileData((NSString*)CFString);
CFRelease(CFString);
static const TCHAR AppPathLineStart[] = TEXT("AppPath=");
static const int AppPathIdLength = ARRAY_COUNT(AppPathLineStart) - 1;
int32 AppPathStart = FileData.Find(AppPathLineStart);
if(AppPathStart >= 0)
{
FString PathData = FileData.Mid(AppPathStart + AppPathIdLength);
int32 LineEnd = -1;
if(PathData.FindChar( TCHAR('\r'), LineEnd ))
{
PathData = PathData.Left(LineEnd);
}
if(PathData.FindChar( TCHAR('\n'), LineEnd ))
{
PathData = PathData.Left(LineEnd);
}
return PathData;
}
}
else
{
UE_LOG(LogStreaming, Error, TEXT("Failed to read file '%s' error."),*(ReportDirectory / TEXT("Report.wer")));
}
return "";
}
void FilePoller::addFileToTrack(
const std::string& fileName,
Cob yCob,
Cob nCob,
Condition condition) {
if (ThreadProtector::inPollerThread()) {
LOG(ERROR) << "Adding files from a callback is disallowd";
return;
}
std::lock_guard<std::mutex> lg(filesMutex_);
fileDatum_[fileName] = FileData(yCob, nCob, condition);
initFileData(fileName, fileDatum_[fileName]);
}
HRESULT CDownload::OnData(CString& strSrcURL, BYTE* pBytes, DWORD dwSize)
{
if (pBytes)
FileData(pBytes, dwSize);
else
{
HRESULT hr = (HRESULT)dwSize;
bool bError = FAILED(hr);
if (bError && hr != E_ABORT)
CMessageBox::Message(String("%s (0x%lx)\nError downloading %s.", HRString(hr), hr, strSrcURL));
FileEnd(bError);
}
return S_OK;
}
FileUtils::FileData FileUtils::getFileData(const char* fileName)
{
DebugLog::print( "FileUtils::getFileData(%s)", fileName );
AAsset* asset = AAssetManager_open(g_aassetManager, (const char *) fileName, AASSET_MODE_UNKNOWN);
if (NULL == asset) {
DebugLog::print("Failed !");
return FileData();
}
long size = AAsset_getLength(asset);
FileData res = findFreeFileDataSlot(size);
res.size = size;
AAsset_read (asset, res.bytes, size);
AAsset_close(asset);
return res;
}
ui8 * getCachedFile(ResourceID && rid)
{
BOOST_FOREACH(auto & file, cache)
{
if (file.name == rid)
return file.getCopy();
}
// Still here? Cache miss
if (cache.size() > cacheSize)
cache.pop_front();
cache.push_back(FileData());
auto data = CResourceHandler::get()->loadData(rid);
cache.back().name = ResourceID(rid);
cache.back().size = data.second;
cache.back().data = data.first.release();
return cache.back().getCopy();
}
void CAfficheMesPol::OnParzenCalculdetous()
{
long parzen0[256];
long parzen1[256];
char ch[15];
CString ch0;
FILE *Fichier;
if(!Parzen)
{
if(!Definirh()) return;
}
CFileDialog FileData(FALSE,"*.xls",NULL,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,"EXCEL (*.xls)|*.xls||",this);
if (FileData.DoModal()==IDOK)
{
if (Fichier=fopen(FileData.GetPathName(),"w"))
{
SetCursor(LoadCursor(0,IDC_WAIT));
fprintf(Fichier,"recouvrement des classes n°%d et n°%d en %% \n",class1,class2);
fprintf(Fichier,"paramètre de parzen: %d\n",Hparam);
for (int i=0;i<PolyMc.NPAR;i++)
{
CalculParzen(i,parzen0,parzen1,ch);
ch0=ch;
ch0=ch0.Left(ch0.Find("."))+","+ch0.Right(ch0.GetLength()-ch0.Find(".")-1);
fprintf(Fichier,DialPara->m_choisi[i]+";"+ch0+"\n");
}
fclose(Fichier);
SetCursor(LoadCursor(0,IDC_ARROW));
}
}
}
int CFileSystem::validatePool(const std::string& path)
{
if(!directoryExists(path)) {
LOG_ERROR("Pool directory doesn't exist: %s", path.c_str());
return 0;
}
int res=0;
std::list <std::string>dirs;
dirs.push_back(path);
int maxdirs=257; //FIXME: unknown dirs in pool will break bar
int finished=0;
IHash* md5=new HashMD5();
while(!dirs.empty()) {
struct dirent* dentry;
DIR* d;
const std::string dir=dirs.front();
dirs.pop_front();
d=opendir(dir.c_str());
while ( (dentry=readdir(d))!=NULL) {
LOG_PROGRESS(finished, maxdirs);
std::string absname=dir;
absname += PATH_DELIMITER;
absname += dentry->d_name;
if (dentry->d_name[0]!='.') { //don't check hidden files / . / ..
#ifndef WIN32
if ((dentry->d_type & DT_DIR)!=0) { //directory
#else
struct stat sb;
stat(absname.c_str(), &sb);
if((sb.st_mode & S_IFDIR)!=0) {
#endif
dirs.push_back(absname);
} else {
FileData filedata=FileData();
int len=absname.length();
if (len<36) { //file length has at least to be <md5[0]><md5[1]>/<md5[2-30]>.gz
LOG_ERROR("Invalid file: %s", absname.c_str());
} else {
std::string md5str="";
md5str.push_back(absname.at(len-36)); //get md5 from path + filename
md5str.push_back(absname.at(len-35));
md5str.append(absname.substr(len-33, 30));
md5->Set(md5str);
for(unsigned i=0; i<16; i++) {
filedata.md5[i]=md5->get(i);
}
if (!fileIsValid(&filedata, absname)) { //check if md5 in filename is the same as in filename
LOG_ERROR("Invalid File in pool: %s",absname.c_str());
} else {
res++;
}
}
}
}
}
finished++;
closedir(d);
}
delete md5;
LOG_PROGRESS(finished, maxdirs, true);
LOG("");
return res;
}
bool CFileSystem::isOlder(const std::string& filename, int secs)
{
struct stat sb;
if (stat(filename.c_str(),&sb)<0) {
return true;
}
time_t t;
#ifdef WIN32
SYSTEMTIME pTime;
FILETIME pFTime;
GetSystemTime(&pTime);
SystemTimeToFileTime(&pTime, &pFTime);
t = FiletimeToTimestamp(pFTime);
#else
time(&t);
#endif
LOG_DEBUG("%s is %d seconds old, redownloading at %d",filename.c_str(), (int)(t - sb.st_ctime), secs);
return (t<sb.st_ctime+secs);
}
bool CFileSystem::fileExists(const std::string& filename)
{
struct stat buffer;
return stat(filename.c_str(), &buffer) == 0;
}
bool CFileSystem::parseTorrent(const char* data, int size, IDownload* dl)
{
struct be_node* node=be_decoden(data, size);
//#ifdef DEBUG
// be_dump(node);
//#endif
if(node==NULL) {
LOG_ERROR("couldn't parse torrent");
return false;
}
if (node->type!=BE_DICT) {
LOG_ERROR("Error in torrent data");
be_free(node);
return false;
}
int i;
struct be_node* infonode=NULL;
for (i = 0; node->val.d[i].val; ++i) { //search for a dict with name info
if ((node->type==BE_DICT) && (strcmp(node->val.d[i].key,"info")==0)) {
infonode=node->val.d[i].val;
break;
}
}
if (infonode==NULL) {
LOG_ERROR("couldn't find info node in be dict");
be_free(node);
return false;
}
for (i = 0; infonode->val.d[i].val; ++i) { //fetch needed data from dict and fill into dl
struct be_node*datanode;
datanode=infonode->val.d[i].val;
switch(datanode->type) {
case BE_STR: //current value is a string
if ((strcmp("name",infonode->val.d[i].key)==0) && (dl->name.empty())) { //set filename if not already set
dl->name=datanode->val.s;
} else if (!strcmp("pieces", infonode->val.d[i].key)) { //hash sum of a piece
const int count = be_str_len(datanode)/20; //one sha1 sum is 5 * 4 bytes long
for (int i=0; i<count; i++) {
struct IDownload::piece piece;
const unsigned char* data=(unsigned char*)&datanode->val.s[i*20];
piece.sha=new HashSHA1();
if (!piece.sha->Set(data, 20)) {
LOG_ERROR("Error setting sha1");
}
piece.state=IDownload::STATE_NONE;
dl->pieces.push_back(piece);
}
}
break;
case BE_INT: //current value is a int
if (strcmp("length",infonode->val.d[i].key)==0) { //filesize
dl->size=datanode->val.i;
} else if (!strcmp("piece length",infonode->val.d[i].key)) { //length of a piece
dl->piecesize=datanode->val.i;
LOG_DEBUG("dl->piecesize: %d", dl->piecesize);
}
break;
default:
break;
}
}
LOG_DEBUG("Parsed torrent data: %s %d", dl->name.c_str(), dl->piecesize);
be_free(node);
return true;
}
bool CFileSystem::dumpSDP(const std::string& filename)
{
std::list<FileData*> files;
files.clear();
if (!parseSdp(filename, files))
return false;
LOG_INFO("md5 (filename in pool) crc32 size filename");
std::list<FileData*>::iterator it;
HashMD5 md5;
for(it=files.begin(); it!=files.end(); ++it) {
md5.Set((*it)->md5, sizeof((*it)->md5));
LOG_INFO("%s %.8X %8d %s",md5.toString().c_str(), (*it)->crc32, (*it)->size, (*it)->name.c_str());
}
return true;
}
void ProcessPreprocessedFile(istream &in, const char *input_file)
{
Assert(g_working_directory && g_base_directory);
// read our entire input into a buffer.
Buffer file_buf;
ReadInStream(in, &file_buf);
// table with contents read so far for
HashTable<String*,FileData,String> file_table;
// name of the original file which was being parsed, from which we will
// get whether this is a C or a C++ file.
const char *base_file = NULL;
char *pos = (char*) file_buf.base;
FileData *cur_data = NULL;
while (*pos) {
if (*pos == '#' && *(pos+1) == ' ') {
// found a preprocessor line directive.
// currently we just parse lines of the format '# line "file" ...
// eat the '#'
pos++;
char *end_pos = NULL;
long line = strtol(pos, &end_pos, 10);
Assert(line >= 1);
Assert(end_pos);
char *start_quote = strchr(end_pos, '"');
Assert(start_quote);
char *end_quote = strchr(start_quote + 1, '"');
Assert(end_quote);
char *end_line = strchr(pos, '\n');
Assert(end_line && end_line > end_quote);
if (base_file == NULL) {
// just mark the first # line directive we see as the base file.
base_file = start_quote + 1;
}
*end_quote = 0;
String *file = String::Make(NormalizeFile(start_quote + 1));
Vector<FileData> *entries = file_table.Lookup(file, true);
if (entries->Empty()) {
entries->PushBack(FileData());
cur_data = &entries->Back();
cur_data->contents = new Buffer();
cur_data->cur_line = 1;
}
else {
Assert(entries->Size() == 1);
cur_data = &entries->Back();
}
// insert enough newlines so that we've caught up with the # line.
while ((long) cur_data->cur_line < line) {
cur_data->contents->Append("\n", 1);
cur_data->cur_line++;
}
// in some cases the # line directive will actually rewind the
// apparent line to an earlier line, e.g.:
// # 250 "foo.c"
// something
// else
// # 250 "foo.c"
// finally
// in this case we'll replace the earlier newlines with spaces,
// getting the string 'something else finally' at line 250.
char *last_pos = (char*) cur_data->contents->pos - 1;
while ((long) cur_data->cur_line > line) {
while (*last_pos != '\n') last_pos--;
*last_pos = ' ';
cur_data->cur_line--;
}
pos = end_line + 1;
continue;
}
if (cur_data == NULL) {
// we can get here if the input is not actually preprocessed.
// make data for the input file itself.
Assert(input_file);
String *file = String::Make(NormalizeFile(input_file));
Vector<FileData> *entries = file_table.Lookup(file, true);
Assert(entries->Empty());
entries->PushBack(FileData());
cur_data = &entries->Back();
cur_data->contents = new Buffer();
cur_data->cur_line = 1;
}
char *end_line = strchr(pos, '\n');
if (end_line == NULL) {
cur_data->contents->Append(pos, strlen(pos));
break;
}
cur_data->contents->Append(pos, end_line - pos + 1);
cur_data->cur_line++;
pos = end_line + 1;
}
// figure out which of the files we read need to be added to the dbs.
Transaction *query = new Transaction();
HashIterate(file_table)
QueryFileData(query, file_table.ItKey(), file_table.ItValueSingle());
SubmitTransaction(query);
// add those files we found in the query.
Transaction *dump = new Transaction();
HashIterate(file_table)
DumpFileData(query, dump, file_table.ItKey(), file_table.ItValueSingle());
SubmitTransaction(dump);
delete query;
delete dump;
HashIterate(file_table)
delete file_table.ItValueSingle().contents;
}
// try to read an item
bool readData(RVNGInputStreamPtr input, long endPos,
FileData &dt, std::string &/*error*/)
{
long actPos = input->tell();
dt = FileData();
if (actPos >= endPos) return false;
long val = (long) libwps::readU16(input);
dt.m_type = int((val & 0xFF00)>>8);
dt.m_id = (val & 0xFF);
if (dt.m_type & 5)
{
dt.m_type = -1;
return false;
}
dt.m_value = 0;
// what is the meaning of dt.m_type & 0xF
// maybe :
// 0x1/0x4 -> never seem
// 0x2 -> set for the main child ?
// 0x8 -> signed/unsigned ? set/unset for bool ?
switch (dt.m_type>>4)
{
case 0:
return true;
case 1:
if (actPos+4 > endPos) break;
if (dt.m_type == 0x12)
{
dt.m_value = libwps::readU8(input);
input->seek(1, librevenge::RVNG_SEEK_CUR);
}
else
dt.m_value = libwps::readU16(input);
return true;
case 2:
{
if (dt.m_type == 0x2a) // special case : STR4 + long
{
if (actPos+10 > endPos) break;
for (int i = 0; i < 4; i++) dt.m_text += (char) libwps::readU8(input);
dt.m_value = libwps::read32(input);
return true;
}
if (actPos+6 > endPos) break;
dt.m_value = libwps::read32(input);
return true;
}
case 8:
{
if (actPos+4 > endPos) break;
long extraSize = (long) libwps::readU16(input);
long newEndPos = actPos+2+extraSize;
if ((extraSize%2) || newEndPos > endPos) break;
// can either be a list of data or a structured list, so we stored the information
dt.m_beginOffset = actPos+4;
dt.m_endOffset = newEndPos;
dt.m_input = input;
input->seek(newEndPos, librevenge::RVNG_SEEK_SET);
return true;
}
default:
break;
}
dt.m_type = -1;
return false;
}
bool CSdp::download()
{
if (downloaded) //allow download only once of the same sdp
return true;
filename=fileSystem->getSpringDir() + PATH_DELIMITER+"packages"+PATH_DELIMITER;
LOG_DEBUG("%s",filename.c_str());
if (!fileSystem->directoryExists(filename)) {
fileSystem->createSubdirs(filename);
}
int count=0;
filename += this->md5 + ".sdp";
const std::string tmpFile = filename + ".tmp";
std::list<FileData*> files;
bool rename = false;
if (!fileSystem->fileExists(filename)) { //.sdp isn't avaiable, download it
IDownload dl(tmpFile);
dl.addMirror(url + "/packages/" + this->md5 + ".sdp");
httpDownload->download(&dl);
fileSystem->parseSdp(tmpFile,files); //parse downloaded file
rename = true;
} else {
fileSystem->parseSdp(filename,files); //parse downloaded file
}
std::list<FileData*>::iterator it;
HashMD5 md5= HashMD5();
FileData tmp=FileData();
int i=0;
for(it = files.begin(); it!=files.end(); ++it) { //check which file are available on local disk -> create list of files to download
i++;
md5.Set((*it)->md5, sizeof((*it)->md5));
std::string file;
fileSystem->getPoolFilename(md5.toString(), file);
if (!fileSystem->fileExists(file)) { //add non-existing files to download list
count++;
(*it)->download=true;
} else {
(*it)->download=false;
}
if (i%10==0) {
LOG_DEBUG("\r%d/%d checked",i,(int)files.size());
}
}
LOG_DEBUG("\r%d/%d need to download %d files",i,(unsigned int)files.size(),count);
std::string root = fileSystem->getSpringDir();
root += PATH_DELIMITER;
root += "pool";
root += PATH_DELIMITER;
if (!createPoolDirs(root)) {
LOG_ERROR("Creating pool directories failed");
count = 0;
}
if (count>0) {
downloaded=downloadStream(this->url+"/streamer.cgi?"+this->md5,files);
LOG_DEBUG("Sucessfully downloaded %d files: %s %s",count,shortname.c_str(),name.c_str());
} else {
LOG_DEBUG("Already downloaded: %s", shortname.c_str());
downloaded=true;
}
for(it = files.begin(); it!=files.end(); ++it) { //free memory
delete *it;
}
if ((rename) && (!fileSystem->Rename(tmpFile, filename))) {
LOG_ERROR("Couldn't rename %s to %s", tmpFile.c_str(), filename.c_str());
}
return downloaded;
}
