void flashSportDevice(ModuleIndex module, const char *filename)
{
pausePulses();
watchdogSetTimeout(60*60*100/*1h*/);
lcd_clear();
displayProgressBar(STR_WRITING);
sportFirmwareUpdate(module, filename);
watchdogSetTimeout(100/*1s*/);
resumePulses();
}
void backupEeprom()
{
char filename[60];
uint8_t buffer[1024];
FIL file;
lcd_clear();
displayProgressBar(STR_WRITING);
// reset unexpectedShutdown to prevent warning when user restores EEPROM backup
g_eeGeneral.unexpectedShutdown = 0;
eeDirty(EE_GENERAL);
eeCheck(true);
// create the directory if needed...
DIR folder;
FRESULT result = f_opendir(&folder, EEPROMS_PATH);
if (result != FR_OK) {
if (result == FR_NO_PATH)
result = f_mkdir(EEPROMS_PATH);
if (result != FR_OK) {
POPUP_WARNING(SDCARD_ERROR(result));
return;
}
}
// prepare the filename...
char * tmp = strAppend(filename, EEPROMS_PATH "/eeprom");
tmp = strAppendDate(tmp, true);
strAppend(tmp, EEPROM_EXT);
// open the file for writing...
f_open(&file, filename, FA_WRITE | FA_CREATE_ALWAYS);
for (int i=0; i<EESIZE; i+=1024) {
UINT count;
eepromReadBlock(buffer, i, 1024);
f_write(&file, buffer, 1024, &count);
updateProgressBar(i, EESIZE);
SIMU_SLEEP(100/*ms*/);
}
f_close(&file);
//set back unexpectedShutdown
g_eeGeneral.unexpectedShutdown = 1;
eeDirty(EE_GENERAL);
eeCheck(true);
}
void flashBootloader(const char * filename)
{
FIL file;
f_open(&file, filename, FA_READ);
uint8_t buffer[1024];
UINT count;
lcd_clear();
displayProgressBar(STR_WRITING);
static uint8_t unlocked = 0;
if (!unlocked) {
unlocked = 1;
unlockFlash();
}
for (int i=0; i<BOOTLOADER_SIZE; i+=1024) {
watchdogSetTimeout(100/*1s*/);
if (f_read(&file, buffer, 1024, &count) != FR_OK || count != 1024) {
POPUP_WARNING(STR_SDCARD_ERROR);
break;
}
if (i==0 && !isBootloaderStart((uint32_t *)buffer)) {
POPUP_WARNING(STR_INCOMPATIBLE);
break;
}
for (int j=0; j<1024; j+=FLASH_PAGESIZE) {
writeFlash(CONVERT_UINT_PTR(FIRMWARE_ADDRESS+i+j), (uint32_t *)(buffer+j));
}
updateProgressBar(i, BOOTLOADER_SIZE);
SIMU_SLEEP(30/*ms*/);
}
if (unlocked) {
lockFlash();
unlocked = 0;
}
f_close(&file);
}
/**
* filters, transforms, and indexes file using ngrams to the index
*
* file name - name of file to process
* wikiindex - the judy arrays to store the index of the wiki in
*/
void indexWiki(char* inFileName, Pvoid_t *wikiIndex, int* articleCount) {
//-------------------- initialization --------------------//
bool articleIndex[lastNgram] = {0}; // boolean array of what trigrams are in an article
struct stemmer * currentStemmer = create_stemmer();
// file for writing the titles to
FILE* titleFile = NULL;
if (writeFiles) {
titleFile = fopen("title_file", "w");
if (NULL == titleFile) {
fprintf(stderr, "Error open title file: %m\n");
exit(1);
}
}
// initializes the libxml library
LIBXML_TEST_VERSION
xmlTextReaderPtr wikiReader; //the reader for the document
wikiReader = xmlReaderForFile(inFileName, NULL, XML_PARSE_RECOVER+XML_PARSE_NOWARNING+XML_PARSE_NOERROR+XML_PARSE_HUGE);
if (NULL == wikiReader) {
//fprintf(stderr, "%s %s\n", "Failed to open ", wikiFileName);
fprintf(stderr, "Error opening XML wiki: %m\n");
exit(1);
}
// for progress bar
int percent = 0;
long fileSize = getFileSize(inFileName);
// initialization for currentArticle and its componens
article currentArticle;
currentArticle.title = g_string_sized_new(256);
currentArticle.body = g_string_sized_new(786432); //768*1024
//-------------------- index the wiki --------------------//
optionalPrint ("%s", "Adding collection to index.\n");
optionalPrint ("%d", (int)(fileSize / 1048576));
optionalPrint (" MB in file\n");
displayProgressBar (xmlTextReaderByteConsumed(wikiReader), fileSize, &percent);
//prime the loop
currentArticle.title->len = 0;
currentArticle.body->len = 0;
xmlTextReaderRead(wikiReader);// at a <page> tag, drop in
xmlTextReaderRead(wikiReader);// at a <page> tag, drop in
// reads from xml file until file is finished, adds articles to index, and writes tittles to file
// processes one article per iteration
while (getArticle (wikiReader, ¤tArticle)) {
currentArticle.articleNumber = *articleCount;
*articleCount = *articleCount + 1;
// filter / transform text
removeMarkup(currentArticle.body);
stemText(currentArticle.body, currentStemmer); //ngramming.h
// index the text
indexText(currentArticle.body, articleIndex); //ngramming.h
addToIndex(articleIndex, wikiIndex, currentArticle.articleNumber);
//adds titles to title file
if (writeFiles) {fprintf(titleFile, "%s\n", currentArticle.title->str);}
//re-prime the loop
currentArticle.title->len = 0;
currentArticle.body->len = 0;
displayProgressBar (xmlTextReaderByteConsumed(wikiReader), fileSize, &percent);
}
optionalPrint ("\n%s", "Finished indexing. \n");
optionalPrint ("%lu", (long)(xmlTextReaderByteConsumed(wikiReader)/1048576));
optionalPrint ("MB consumed\n");
optionalPrint ("%d %s %d %s", *articleCount, "articles found", (int) currentArticle.body->allocated_len, "length allocated for article body\n");
// clean up of structures needed to process wiki
if (writeFiles) {fclose (titleFile);}
free_stemmer(currentStemmer);
xmlFreeTextReader(wikiReader);
xmlCleanupParser();
//g_string_free(currentArticle.title, TRUE);
//g_string_free(currentArticle.body, TRUE); //malloc fail if this is uncommented ?!
}
std::vector<SetOfFormulasPtr>
FaultLocalization::allDiagnosis(Formula *TF,
std::vector<ProgramTrace*> traces,
YicesSolver *yices) {
std::vector<SetOfFormulasPtr> MCSes;
int progress = 0;
int total = traces.size();
// Working formula
Formula *WF = new Formula(TF);
// For each E in WF, E tagged as soft do
unsigned z = 0;
std::vector<BoolVarExprPtr> AV;
std::map<BoolVarExprPtr, ExprPtr> AVMap;
std::vector<ExprPtr> clauses = WF->getExprs();
for(ExprPtr e : clauses) {
if (e->isSoft()) {
// AI is a new auxiliary var. created
std::ostringstream oss;
oss << z++;
BoolVarExprPtr ai = Expression::mkBoolVar("a_"+oss.str());
ai->setInstruction(e->getInstruction());
ai->setLine(e->getLine());
AV.push_back(ai);
AVMap[ai] = e;
ExprPtr notai = Expression::mkNot(ai);
//notai->setWeight(e->getWeight());
notai->setLine(e->getLine());
notai->setSoft();
WF->add(notai);
// Remove E and add EA as hard
ExprPtr ea = Expression::mkOr(e, ai);
WF->remove(e);
ea->setHard();
WF->add(ea);
}
}
if (AV.empty()) {
delete WF;
std::cout << "No MaxSMT solution!\n";
if (options->verbose()) {
std::cout << "==============================================\n";
}
return MCSes;
}
yices->init();
yices->addToContext(WF);
for(ProgramTrace *E : traces) {
if (options->verbose()) {
displayProgressBar(progress, total);
}
// At this point there is only WF in the context
yices->push();
// Assert as hard the error-inducing input formula
ExprPtr eiExpr = E->getProgramInputsFormula(TF);
eiExpr->setHard();
yices->addToContext(eiExpr);
if (options->dbgMsg()) {
std::cout << "-- Error-inducing Input: ";
eiExpr->dump();
std::cout << std::endl;
}
// Assert as hard the golden output (if any)
// (= return_var golden_output)
Value *goldenOutput = E->getExpectedOutput();
if (goldenOutput) {
BasicBlock *lastBB = &targetFun->back();
Instruction *lastInst = &lastBB->back();
if (ReturnInst *ret= dyn_cast<ReturnInst>(lastInst)) {
Value *retVal = ret->getReturnValue();
if (retVal) {
ExprPtr retExpr = Expression::getExprFromValue(retVal);
ExprPtr goExpr = Expression::getExprFromValue(goldenOutput);
ExprPtr eqExpr = Expression::mkEq(retExpr, goExpr);
eqExpr->setHard();
yices->addToContext(eqExpr);
if (options->dbgMsg()) {
std::cout << "-- Golden ouput: ";
eqExpr->dump();
std::cout << std::endl;
}
}
}
}
// Compute a MCS
SetOfFormulasPtr M = allMinMCS(yices, AV, AVMap);
if (!M->empty()) {
SetOfFormulasPtr M2 = avToClauses(M, AVMap);
MCSes.push_back(M2);
if (options->printMCS()) {
std::cout << "\n" << M2 << "\n" << std::endl;
}
} else {
//if (options->verbose() || options->dbgMsg()) {
std::cout << "Empty MCS!\n";
//}
}
// Backtrack to the point where there
// was no Pre/Post-conditions in the formula
yices->pop();
// Progress bar
progress++;
}
yices->clean();
delete WF;
if (options->verbose()) {
displayProgressBar(progress, total);
std::cout << std::endl;
}
return MCSes;
}
