/*** putEeprom ** ** Parameters: ** eeprom - pointer to a flash memory page acting as emulated EEPROM ** address - location to be written ** data - data to be written ** ** Return Value: ** Returns true if the operation was successful, false otherwise ** ** Errors: ** none ** ** Description: ** Searches through emulated EEPROM page for valid address then ** invalidates that location and writes the address and data ** to a new unused location. */ BOOL putEeprom(eeSeg * eeprom, uint32_t address, uint8_t data) { eeSeg tempSeg; int i; uint32_t nextAvalible; //Check if address exists for(i=0; i < _EEPROM_PAGE_SIZE; i++) { //Check if eeSeg is valid and address matches if(getValid(eeprom[i]) && !getTaken(eeprom[i]) && getAddress(eeprom[i]) == address) { //If data is same do nothing if(data == getData(eeprom[i])) { return fTrue; } //If data is different invalidate eeSeg else { tempSeg = eeprom[i]; tempSeg.temp.valid = 0; writeFlashWord((void*)&eeprom[i],tempSeg.data); // If data is 0xFF return //if(data == 0xFF) { // printf(" and data is 0xFF so done.\n\r"); // return fTrue; //} } } //If empty eeSeg found save location and break else if(getValid(eeprom[i]) && getTaken(eeprom[i])) { nextAvalible = i; break; } } //If I == max size no valid segments exist if(i == _EEPROM_PAGE_SIZE) { return fFalse; } //Pack address with data and write to flash tempSeg = pack(address,data); writeFlashWord((void*)&eeprom[i],tempSeg.data); return fTrue; }
/*** getEeprom ** ** Parameters: ** eeprom - pointer to flash memory acting as emulated eeprom ** address - location to be read ** data - data to be read ** ** Return Value: ** Returns true or false wether the operation was successful ** or not. ** ** Errors: ** none ** ** Description: ** Searches through emulated eeprom for valid address and ** returns data. If no address can be found the funtion ** will return false and set data pointer to 0xFF */ BOOL getEeprom(eeSeg * eeprom, uint32_t address,uint8_t * data) { int i; //Check if address exists for(i=0; i < _EEPROM_PAGE_SIZE; i++) { //Check if eeSeg is valid and address matches if(getValid(eeprom[i]) && !getTaken(eeprom[i]) && getAddress(eeprom[i]) == address) { //Set data to pointer and return *data = getData(eeprom[i]); return fTrue; } else if(getValid(eeprom[i]) && getTaken(eeprom[i])) { break; } } //If address not found return 0xFF *data = 0xFF; return fFalse; }
/*** putBuffer ** ** Parameters: ** eeprom - pointer to flash memory acting as emulated eeprom ** buffer - pointer to buffer ** ** Return Value: ** Returns true or false wether the operation was successful ** or not. ** ** Errors: ** none ** ** Description: ** Searches through emulated eeprom for valid addresses ** then writes data to buffer using address as the index */ uint32_t putBuffer(eeSeg * eeprom, uint8_t * buffer) { uint16_t tempAddress; int i; //Initialize each byte in buffer to 0xFF for(i=0; i < _EEPROM_PAGE_SIZE; i++) { buffer[i] = 0xFF; } //Find all valid addresses and load them to buffer for(i=0; i < _EEPROM_PAGE_SIZE; i++) { if(getValid(eeprom[i]) && !getTaken(eeprom[i])) { tempAddress = getAddress(eeprom[i]); buffer[tempAddress] = getData(eeprom[i]); } } }
/*** putBuffer ** ** Parameters: ** eeprom - pointer to flash memory acting as emulated EEPROM ** buffer - pointer to buffer ** ** Return Value: ** Returns true if the operation was successful, false otherwise ** ** Errors: ** none ** ** Description: ** Searches through emulated EEPROM for valid addresses ** then writes data to buffer using address as the index ** buffer must be big enough to hold all addresses (even ** those that aren't used) i.e. MAX_ADDRESS_DEFAULT big. */ uint32_t putBuffer(uint8_t * buffer) { uint16_t tempAddress; int i, j; //Initialize each byte in buffer to 0xFF for(i=0; i < max_address; i++) { buffer[i] = 0xFF; } //Find all valid addresses and load them to buffer for(j=0; j < _EEPROM_PAGE_COUNT; j++) { for(i=0; i < _EEPROM_PAGE_SIZE; i++) { if(getValid((eeSeg)eedata_addr[j][i]) && !getTaken((eeSeg)eedata_addr[j][i])) { tempAddress = getAddress((eeSeg)eedata_addr[j][i]); buffer[tempAddress] = getData((eeSeg)eedata_addr[j][i]); } } } }
void BCPattern::matchAnchored(const Expr& pattern, PC start, PC end, Result& result) { auto pos = pattern.begin(); for (auto inst = start; inst != end; ) { // Detect a match. if (pos == pattern.end()) { result.m_start = start; result.m_end = inst; return; } auto const op = peek_op(inst); // Skip pattern-globally ignored opcodes. if (m_ignores.count(op)) { inst = next(inst); continue; } // Check for alternations whenever we fail to match. auto nomatch = [&] { if (!pos->hasAlt()) return result.erase(); // Pop the capture if we made one. if (pos->shouldCapture()) { result.m_captures.pop_back(); } for (auto const& atom : pos->getAlt()) { // Construct the full alternate pattern. auto alt = Expr { atom }; alt.insert(alt.end(), std::next(pos), pattern.end()); auto res = result; // Match on the alternate. matchAnchored(alt, inst, end, res); if (res.found()) { result = res; result.m_start = start; return; } } return result.erase(); }; // Capture the atom if desired. if (pos->shouldCapture()) { result.m_captures.push_back(inst); } // Check for shallow match. if (pos->op() != op) { return nomatch(); } auto filter = pos->getFilter(); // Check for deep match if desired. if (filter && !filter(inst, result.m_captures)) { return nomatch(); } if ((pos->op() == Op::JmpZ || pos->op() == Op::JmpNZ)) { // Match the taken block, if there is one. auto off = instrJumpOffset(inst); assert(off); auto res = result; matchAnchored(pos->getTaken(), inst + *off, end, res); if (!res.found()) { return nomatch(); } // Grab the captures. result.m_captures = res.m_captures; } if (pos->hasSeq()) { // Match the subsequence if we have one. auto res = result; matchAnchored(pos->getSeq(), next(inst), end, res); if (!res.found()) { return nomatch(); } // Set the PC. result.m_captures = res.m_captures; inst = res.m_end; } else { // Step the PC. inst = next(inst); } // Step the pattern. ++pos; } // Detect a terminal match. if (pos == pattern.end()) { result.m_start = start; result.m_end = end; } }