void simplifyPFBlock(const Edges& toUnlink, const PFBlock& block, Blocks& simplifiedBlocks, Nodes& history) {
// take a block, unlink some of the edges and
// create smaller blocks or a simplified blocks
// or if nothing has changed take a copy of the original block
if (toUnlink.size() == 0) {
// no change needed, just make a copy of block
PFBlock newblock(block.elementIds(), block.edges(), simplifiedBlocks.size(), 's'); // will copy edges and ids
PDebug::write("Made {}", newblock);
auto id = newblock.id();
simplifiedBlocks.emplace(id, std::move(newblock));
// update history
makeHistoryLinks(block.elementIds(), {id}, history);
} else {
Edges modifiedEdges;
for (auto edge : block.edges()) { // copying edges
Edge e = edge.second;
if (toUnlink.find(edge.first) != toUnlink.end()) {
e.setLinked(false);
}
modifiedEdges.emplace(e.key(), e);
}
// create new blocks and add into simplifiedBlocks
buildPFBlocks(block.elementIds(), modifiedEdges, 's', simplifiedBlocks, history);
}
}
static bool addBranchBlock(Blocks &blocks, Block &block,
const Instruction &branchDestination,
Block *&branchBlock, BlockEdgeType type) {
/* Prepare to follow one branch of the path.
Returns true if this is a completely new path we haven't handled yet.
branchBlock will be filled with the block for the branch. */
bool needAdd = false;
// See if we have already handled this branch. If not, create a new block for it.
branchBlock = const_cast<Block *>(branchDestination.block);
if (!branchBlock) {
blocks.push_back(Block(branchDestination.address));
branchBlock = &blocks.back();
needAdd = true;
}
// Link the branch with its parent
branchBlock->parents.push_back(&block);
block.children.push_back(branchBlock);
block.childrenTypes.push_back(type);
return needAdd;
}
void puzzle_i()
{
Blocks bs;
Board board(5, 6);
bs.push_back(&(*(new Block()))("***"));
bs.push_back(&(*(new Block()))("***| *| *"));
bs.push_back(&(*(new Block()))("**|**"));
bs.push_back(&(*(new Block()))("*|**"));
bs.push_back(&(*(new Block()))(" **| *|**"));
bs.push_back(&(*(new Block()))("*|*"));
bs.push_back(&(*(new Block()))("***| *"));
bs.push_back(&(*(new Block()))("*|**| *"));
cout << "---------- Puzzle I ----------" << endl;
if (!board.Unblock(bs))
{
cout << "No solution!" << endl;
}
for (auto i = bs.cbegin(); i != bs.cend(); i++)
{
delete (*i);
}
}
// Start solving the problem.
bool Board::Unblock(Blocks bs)
{
count_setblock = 0;
count_checkblock = 0;
count_setcell = 0;
count_checkcell = 0;
// Sort Blocks by block weight
sort(bs.begin(), bs.end(), [](Block *a, Block *b)
{
return (a->weight > b->weight);
});
for (auto i = bs.cbegin(); i != bs.cend(); i++)
{
(*i)->Print("Block " + to_string(i - bs.cbegin()));
}
// Find solution
bool result = RecursiveSetBlock(bs, 0);
cout << "count_setblock = " << count_setblock << endl
<< "count_checkblock = " << count_checkblock << endl
<< "count_setcell = " << count_setcell << endl
<< "count_checkcell = " << count_checkcell << endl;
return result;
}
~CFGCalculator() {
for(Blocks::iterator i = blocks_.begin();
i != blocks_.end();
i++) {
delete i->second;
}
}
void PatchMgr::getBlockCandidates(Scope &scope, Point::Type types, Candidates &ret) {
Blocks blocks;
getBlocks(scope, blocks);
for (Blocks::iterator iter = blocks.begin(); iter != blocks.end(); ++iter) {
if (types & Point::BlockEntry) ret.push_back(Candidate(Location::Block(*iter), Point::BlockEntry));
if (types & Point::BlockDuring) ret.push_back(Candidate(Location::Block(*iter), Point::BlockDuring));
if (types & Point::BlockExit) ret.push_back(Candidate(Location::Block(*iter), Point::BlockExit));
}
}
void constructBlocks(Blocks &blocks, Instructions &instructions) {
/* Create the first block containing the very first instruction in this script.
* Then follow the complete code flow from this instruction onwards. */
assert(blocks.empty());
if (instructions.empty())
return;
blocks.push_back(Block(instructions.front().address));
constructBlocks(blocks, blocks.back(), instructions.front());
}
void PatchMgr::getInsns(Scope &scope, Insns &insns) {
Blocks blocks;
getBlocks(scope, blocks);
for (Blocks::iterator iter = blocks.begin(); iter != blocks.end(); ++iter) {
PatchBlock::Insns tmp;
(*iter)->getInsns(tmp);
for (PatchBlock::Insns::iterator t = tmp.begin(); t != tmp.end(); ++t) {
insns.push_back(InsnLoc_t(*iter, t->first, t->second));
}
}
}
void PFReconstructor::reconstruct() {
// TODO sort m_blocks
// simplify the blocks by editing the links
// each track will end up linked to at most one hcal
// sort the blocks by id to ensure match with python
std::vector<IdType> blockids;
std::vector<IdType> newblockids;
Ids ids = m_pfEvent.mergedElementIds();
// create the blocks of linked ids
auto bBuilder = PFBlockBuilder(ids, m_pfEvent);
m_blocks = bBuilder.blocks();
for (const auto& b : m_blocks) {
blockids.push_back(b.first);
}
#if WITHSORT
std::sort(blockids.begin(), blockids.end());
#endif
// go through each block and see if it can be simplified
// in some cases it will end up being split into smaller blocks
// Note that the old block will be marked as disactivated
for (auto bid : blockids) {
// std::cout<<Id::pretty(bid)<< ":" << bid <<std::endl;
Blocks newBlocks = simplifyBlock(bid);
if (newBlocks.size() > 0) {
for (auto& b : newBlocks) {
IdType id = b.first;
m_blocks.emplace(id, std::move(b.second));
newblockids.push_back(b.first);
}
}
}
blockids.insert(std::end(blockids), std::begin(newblockids), std::end(newblockids));
for (auto bid : blockids) {
PFBlock& block = m_blocks.at(bid);
if (block.isActive()) { // when blocks are split the original gets deactivated
PDebug::write("Processing {}", block);
reconstructBlock(block);
}
}
if (m_unused.size() > 0) {
PDebug::write("unused elements ");
for (auto u : m_unused)
PDebug::write("{},", u);
// TODO warning message
}
}
template<int BlockSize> void compute(Blocks<BlockSize>& blocks)
{
for(size_t i = 0 ; i < blocks.r.size(); ++i)
{
blocks.eval(i);
}
}
void findDeadBlockEdges(Blocks &blocks) {
/* Run through all blocks and find edges that are logically dead and will
* never be taken.
*
* Currently, this is limited to one special case that occurs in scripts
* compiled by the original BioWare NWScript compiler (at least in NWN and
* KotOR): short-circuiting in if (x || y) conditionals. The original BioWare
* compiler has a bug where it generates a JZ instead of a JMP, creating a
* true branch that will never be taken and effectively disabling short-
* circuiting. I.e. both x and y will always be evaluated; when x is true,
* y will still be evaluated afterwards.
*
* We use very simple pattern-matching here. This is enough to find most
* occurances of this case, but not all. */
for (Blocks::iterator b = blocks.begin(); b != blocks.end(); ++b) {
if (!isTopStackJumper(*b) || (b->instructions.size() != 2) || b->parents.empty())
continue;
/* Look through all parents of this block and make sure they fit the
* pattern as well. They also all need to jump to this block with the
* same branch edge (true or false). */
size_t parentEdge = SIZE_MAX;
for (std::vector<const Block *>::const_iterator p = b->parents.begin(); p != b->parents.end(); ++p) {
if (!isTopStackJumper(**p, &*b, &parentEdge)) {
parentEdge = SIZE_MAX;
break;
}
}
if (parentEdge == SIZE_MAX)
continue;
assert(parentEdge < 2);
/* We have now established that
* 1) This block checks whether the top of the stack is == 0
* 2) All parent blocks check whether the top of the stack is == 0
* 3) All parent blocks jump with the same branch edge into this block
*
* Therefore, this block must also always follow the exact same edge.
* This means the other edge is logically dead. */
b->childrenTypes[1 - parentEdge] = kBlockEdgeTypeDead;
}
}
void MarkBlockUsed( const SBlock& p_Block, unsigned int p_unWidth, unsigned int p_unHeight )
{
m_unFirstX += p_unWidth;
if( m_unFirstX + p_unWidth >= m_unWidth )
{
m_unFirstX = 0;
m_unFirstY += p_unHeight;
}
m_vecBlocks.push_back( p_Block );
}
bool IsBlockFree( const SBlock& p_Block )const
{
unsigned int unRight = p_Block.m_unLeft + p_Block.m_unWidth;
unsigned int unBottom = p_Block.m_unTop + p_Block.m_unHeight;
if( unRight > m_unWidth || unBottom > m_unHeight )
{
return false;
}
Blocks::const_iterator IteEnd = m_vecBlocks.end();
for( Blocks::const_iterator Ite = m_vecBlocks.begin();
Ite != IteEnd; ++Ite )
{
if( Ite->m_unLeft < unRight && p_Block.m_unLeft < Ite->m_unLeft + Ite->m_unWidth
&& Ite->m_unTop < unBottom && p_Block.m_unTop < Ite->m_unTop + Ite->m_unHeight )
{
return false;
}
}
return true;
}
void PatchMgr::getBlocks(Scope &scope, Blocks &blocks) {
if (scope.wholeProgram) {
const AddrSpace::ObjMap &objs = as()->objMap();
for (AddrSpace::ObjMap::const_iterator iter = objs.begin(); iter != objs.end(); ++iter) {
iter->second->blocks(std::back_inserter(blocks));
}
}
else if (scope.obj) {
scope.obj->blocks(std::back_inserter(blocks));
}
else if (scope.block) {
blocks.push_back(scope.block);
}
}
void solve() {
int w = 0;
int h = 0;
int nBlocks = 0;
cin >> w >> h >> nBlocks;
Blocks blocks;
blocks.resize(h + 1);
for (int y = 0; y <= h; ++y) {
blocks[y].resize(w + 1);
}
for (int i = 0; i < nBlocks; ++i) {
int x = 0;
int y = 0;
cin >> x >> y;
blocks[y][x] = true;
}
int nSolution = 0;
uint nMinSolutionLength = numeric_limits<unsigned long long>::max();
travelse(0, 0, w, h, blocks, nSolution, 1, nMinSolutionLength);
solutions.push_back(nSolution);
}
void isColl(Blocks& _block) {
if (getBoundingBox().intersects(_block.getBoundingBox())) {
cout << "col" << endl;
_block.setColor(sf::Color::Red);
if (_spriteG.getPosition().y <= _block.getBoundingBoxTop()) {//up
canMoveUp = false;
MarioJumping = false;
if (_spriteG.getPosition().x - 2 < _block.getBoundingBoxLeft() - 12) {
MarioJumping = true;
canMoveRight = false;
}
else if (_spriteG.getPosition().x > _block.getBoundingBoxLeft() + 23) {
MarioJumping = true;
canMoveLeft = false;
}
}
else if (_spriteG.getPosition().y > _block.getBoundingBoxTop() - _block.getBoundingBoxHeight()) {
_velocity.y = 5;
MarioJumping = true;
}
else {
if (_spriteG.getPosition().x < _block.getBoundingBoxLeft() - 12) {//Left
canMoveLeft = false;
}
else if (_spriteG.getPosition().x > _block.getBoundingBoxLeft() + 23) {//right
canMoveRight = false;
}
}
}
else {
canMoveRight = true;
canMoveLeft = true;
canMoveUp = true;
if (canMoveUp == true)
_velocity.y += gravity;
}
}
// This is the core solution
bool Board::RecursiveSetBlock(Blocks &bs, size_t block_index)
{
Block* block = bs[block_index];
size_t xmax = width - block->width;
size_t ymax = height - block->height;
for (size_t x = 0; x <= xmax; x++)
{
for (size_t y = 0; y <= ymax; y++)
{
// if there is a place for block, process.
if (SetBlock(block, x, y))
{
// If the block is the last one, solution found.
if (block_index == bs.size() - 1)
{
cout << "Step: Put block " << block_index << " at [" << x << ", " << y << "]" << endl;
block->Print(width, height, x, y, "Block " + to_string(block_index));
return true;
}
// If not the last one, process other blocks.
if (RecursiveSetBlock(bs, block_index + 1))
{
// If all other blocks are positioned correctly, solution found.
cout << "Step: Put block " << block_index << " at [" << x << ", " << y << "]" << endl;
block->Print(width, height, x, y, "Block " + to_string(block_index));
return true;
}
else
{
// If not able to found a solution for other blocks, rollback current block,
// and continually find next available position for current block.
ClearBlock(block, x, y);
continue;
}
}
}
}
return false;
}
boost::shared_ptr<SegmentDescriptions>
LocalSegmentStore::getSegmentsByBlocks(
const Blocks& blocks,
Blocks& missingBlocks,
bool /*readCosts*/) { // readCosts is ignored.
boost::shared_ptr<SegmentDescriptions> _blocksSegments = boost::make_shared<SegmentDescriptions>();
for (const Block& block : blocks) {
std::map<Block, SegmentDescriptions>::const_iterator it = _segments.find(block);
if (it == _segments.end())
missingBlocks.add(block);
else
for (const SegmentDescription& segment : it->second)
_blocksSegments->add(segment);
}
return _blocksSegments;
}
int main(int argc, char** argv)
{
try {
// init command line parser
util::ProgramOptions::init(argc, argv);
int stack_id = optionStackId.as<int>();
std::string comp_dir = optionComponentDir.as<std::string>();
std::string pg_host = optionPGHost.as<std::string>();
std::string pg_user = optionPGUser.as<std::string>();
std::string pg_pass = optionPGPassword.as<std::string>();
std::string pg_dbase = optionPGDatabase.as<std::string>();
std::cout << "Testing PostgreSQL stores with stack ID " << stack_id << std::endl;
// init logger
logger::LogManager::init();
logger::LogManager::setGlobalLogLevel(logger::Debug);
// create new project configuration
ProjectConfiguration pc;
pc.setBackendType(ProjectConfiguration::PostgreSql);
StackDescription stack;
stack.id = stack_id;
pc.setCatmaidStack(Raw, stack);
pc.setComponentDirectory(comp_dir);
pc.setPostgreSqlHost(pg_host);
pc.setPostgreSqlUser(pg_user);
pc.setPostgreSqlPassword(pg_pass);
pc.setPostgreSqlDatabase(pg_dbase);
PostgreSqlSliceStore sliceStore(pc, Membrane);
// Add first set of slices
boost::shared_ptr<Slice> slice1 = createSlice(10, 0);
boost::shared_ptr<Slice> slice2 = createSlice(10, 1);
boost::shared_ptr<Slice> slice3 = createSlice(10, 2);
Slices slices = Slices();
slices.add(slice1);
slices.add(slice2);
slices.add(slice3);
Block block(0, 0, 0);
sliceStore.associateSlicesToBlock(slices, block);
Blocks blocks;
blocks.add(block);
Blocks missingBlocks;
boost::shared_ptr<Slices> retrievedSlices =
sliceStore.getSlicesByBlocks(blocks, missingBlocks);
// Create conflict set where each slice
ConflictSet conflictSet1;
conflictSet1.addSlice(slice1->hashValue());
conflictSet1.addSlice(slice2->hashValue());
conflictSet1.addSlice(slice3->hashValue());
ConflictSets conflictSets;
conflictSets.add(conflictSet1);
sliceStore.associateConflictSetsToBlock(conflictSets, block);
boost::shared_ptr<ConflictSets> retrievedConflictSets =
sliceStore.getConflictSetsByBlocks(blocks, missingBlocks);
for (const ConflictSet& cs : *retrievedConflictSets) {
std::cout << "ConflictSet hash: " << hash_value(cs);
for (const SliceHash& sh : cs.getSlices()) {
std::cout << " Slice hash: " << sh;
}
std::cout << std::endl;
}
PostgreSqlSegmentStore segmentStore(pc, Membrane);
util::box<unsigned int, 2> segmentBounds(0, 0, 0, 0);
std::vector<double> segmentFeatures;
segmentFeatures.push_back(0.0);
segmentFeatures.push_back(1.0);
segmentFeatures.push_back(2.0);
SegmentDescription segment(0, segmentBounds);
segment.addLeftSlice(slice1->hashValue());
segment.addRightSlice(slice2->hashValue());
segment.setFeatures(segmentFeatures);
boost::shared_ptr<SegmentDescriptions> segments = boost::make_shared<SegmentDescriptions>();
segments->add(segment);
segmentStore.associateSegmentsToBlock(*segments, block);
boost::shared_ptr<SegmentDescriptions> retrievedSegments =
segmentStore.getSegmentsByBlocks(blocks, missingBlocks, false);
} catch (boost::exception& e) {
handleException(e, std::cerr);
}
}
int main( int argc, char *argv[] )
{
int i ;
int ret ;
Alignments alignments ;
Alignments clippedAlignments ;
Blocks blocks ;
Genome genome ;
char *genomeFile = NULL ;
if ( argc < 2 )
{
printf( "%s", usage ) ;
exit( 0 ) ;
}
minimumSupport = 2 ;
minimumEffectiveLength = 200 ;
kmerSize = 23 ;
breakN = 1 ;
minContigSize = 200 ;
prefix = NULL ;
VERBOSE = false ;
outputConnectionSequence = false ;
aggressiveMode = false ;
for ( i = 1 ; i < argc ; ++i )
{
if ( !strcmp( "-b", argv[i] ) )
{
alignments.Open( argv[i + 1]) ;
++i ;
}
else if ( !strcmp( "-o", argv[i] ) )
{
prefix = argv[i + 1] ;
++i ;
}
else if ( !strcmp( "-f", argv[i] ) )
{
genomeFile = argv[i + 1] ;
++i ;
}
else if ( !strcmp( "-ms", argv[i] ) )
{
minimumSupport = atoi( argv[i + 1] ) ;
++i ;
}
else if ( !strcmp( "-ml", argv[i] ) )
{
minimumEffectiveLength = atoi( argv[i + 1] ) ;
++i ;
}
else if ( !strcmp( "-k", argv[i] ) )
{
kmerSize = atoi( argv[i + 1] ) ;
++i ;
}
else if ( !strcmp( "-breakN", argv[i] ) )
{
breakN = atoi( argv[i + 1] ) ;
++i ;
}
else if ( !strcmp( "-minContigSize", argv[i] ) )
{
minContigSize = atoi( argv[i + 1] ) ;
++i ;
}
else if ( !strcmp( "-v", argv[i] ) )
{
VERBOSE = true ;
}
else if ( !strcmp( "-cs", argv[i] ) )
{
outputConnectionSequence = true ;
}
/*else if ( !strcmp( "-aggressive", argv[i] ) )
{
aggressiveMode = true ;
}*/
else if ( !strcmp( "-bc", argv[i] ) )
{
// So far, assume the input is from BWA mem
clippedAlignments.Open( argv[i + 1] ) ;
clippedAlignments.SetAllowSupplementary( true ) ;
++i ;
}
else
{
fprintf( stderr, "Unknown parameter: %s\n", argv[i] ) ;
exit( 1 ) ;
}
}
if ( !alignments.IsOpened() )
{
printf( "Must use -b to specify the bam file." ) ;
return 0 ;
}
if ( prefix != NULL )
{
char buffer[255] ;
sprintf( buffer, "%s.out", prefix ) ;
fpOut = fopen( buffer, "w" ) ;
}
else
{
char buffer[255] ;
prefix = strdup( "rascaf" ) ;
sprintf( buffer, "%s.out", prefix ) ;
fpOut = fopen( buffer, "w" ) ;
}
if ( genomeFile != NULL )
{
genome.Open( alignments, genomeFile ) ;
alignments.Rewind() ;
}
if ( outputConnectionSequence == true && genomeFile == NULL )
{
fprintf( stderr, "Must use -f to specify assembly file when using -cs\n" ) ;
exit( EXIT_FAILURE ) ;
}
// 74619
//printf( "%c\n", genome.GetNucleotide( 74619, 4 ) ) ;
//exit(0) ;
// Build the graph
ret = blocks.BuildExonBlocks( alignments, genome ) ;
alignments.Rewind() ;
fprintf( stderr, "Found %d exon blocks.\n", ret ) ;
if ( clippedAlignments.IsOpened() )
{
fprintf( stderr, "Extend exon blocks with clipped alignments.\n" ) ;
Blocks extendBlocks ;
extendBlocks.BuildExonBlocks( clippedAlignments, genome ) ;
clippedAlignments.Rewind() ;
ret = blocks.ExtendExonBlocks( extendBlocks ) ;
fprintf( stderr, "Found %d exon blocks after extension.\n", ret ) ;
}
blocks.GetAlignmentsInfo( alignments ) ;
alignments.Rewind() ;
ret = blocks.BuildGeneBlocks( alignments, genome ) ;
alignments.Rewind() ;
fprintf( stderr, "Found %d gene blocks.\n", ret ) ;
blocks.BuildGeneBlockGraph( alignments ) ;
if ( clippedAlignments.IsOpened() )
{
blocks.AddGeneBlockGraphByClippedAlignments( clippedAlignments ) ;
}
// Cleaning
blocks.CleanGeneBlockGraph( alignments, genome ) ;
// Scaffolding
Scaffold scaffold( blocks, genome ) ;
//scaffold.Init( blocks ) ;
int componentCnt = scaffold.BuildComponent() ;
fprintf( stderr, "Found %d non-trivial gene block components.\n", componentCnt ) ;
// Possible for parallelization
for ( i = 0 ; i < componentCnt ; ++i )
{
scaffold.ScaffoldComponent( i ) ;
}
scaffold.ScaffoldGenome() ;
// Output the command line
fprintf( fpOut, "command line: " ) ;
char *fullpath = (char *)malloc( sizeof( char ) * 4096 ) ;
for ( i = 0 ; i < argc ; ++i )
{
char c = ' ' ;
if ( i == argc - 1 )
c = '\n' ;
if ( i > 0 && !strcmp( argv[i - 1], "-b" ) )
{
if ( realpath( argv[i], fullpath ) == NULL )
{
fprintf( stderr, "Failed to resolve the path of file %s.\n", argv[i] ) ;
exit( 1 ) ;
}
fprintf( fpOut, "%s%c", fullpath, c ) ;
}
else if ( i > 0 && !strcmp( argv[i - 1], "-f" ) )
{
if ( realpath( argv[i], fullpath ) == NULL )
{
fprintf( stderr, "Failed to resolve the path of file %s.\n", argv[i] ) ;
exit( 1 ) ;
}
fprintf( fpOut, "%s%c", fullpath, c ) ;
}
else
fprintf( fpOut, "%s%c", argv[i], c ) ;
}
free( fullpath ) ;
scaffold.Output( fpOut, alignments ) ;
return 0 ;
}
int main() {
int size = 9; // must be 11 or less
Blocks * blocks = new Blocks(size);
blocks->build();
}
void findDeadBlockEdges(Blocks &blocks) {
/* Run through all blocks and find edges that are logically dead and will
* never be taken.
*
* Currently, this is limited to one special case that occurs in scripts
* compiled by the original BioWare NWScript compiler (at least in NWN and
* KotOR): short-circuiting in if (x || y) conditionals. The original BioWare
* compiler has a bug where it generates a JZ instead of a JMP, creating a
* true branch that will never be taken and effectively disabling short-
* circuiting. I.e. both x and y will always be evaluated; when x is true,
* y will still be evaluated afterwards.
*
* We use very simple pattern-matching here. This is enough to find most
* occurrences of this case, but not all.
*
* For example, this is the control flow diagram for the bytecode, as
* compiled by the original BioWare compiler, for
*
* if ((global_variable == 1) || (global_variable == 3))
*
* .
* |
* V
* .-------------------.
* | CPTOPBP -4 4 |
* | CONSTI 1 |
* | EQII |
* | CPTOPSP -4 4 |
* | JZ |
* '-------------------'
* (true)| |(false)
* | V (1)
* | .--------------------.
* | | CPTOPSP -4 4 |
* | | JZ | (4)
* | '--------------------'
* | (false)| |(true)
* | (2) | | (3)
* V V |
* .-------------------. |
* | CPTOPBP -4 4 | |
* | CONSTI 3 | |
* | EQII | |
* '-------------------' |
* | |
* V |
* .-------------------. |
* | LOGORII -4 4 | |
* | JZ |<-'
* '-------------------'
* (true) | |(false)
* ' '
*
* "CPTOPSP -4 4" takes the top element on the stack and, without
* popping it, pushes it again onto the top, creating a duplicate.
*
* When taking the false branch at (1) (which means that the variable
* *is* equal to 1), we have already established that the top element
* on the stack (which is getting copied a few times, so it's not
* vanishing) is of a certain value. This means that the false branch
* at (2) has to be taken as well. The true branch at (3) can't ever
* be taken, and is therefore logically dead.
*
* Moreover, if the true branch at (3) would have been taken, this
* had resulted in a stack smash, because JZ consumes a stack element,
* and the LOGORII would now be one element short.
*
* Essentially, the whole block at (4) evaluates to a NOP.
*
* How this *should* have been compiled is thusly:
*
* .
* |
* V
* .-------------------.
* | CPTOPBP -4 4 |
* | CONSTI 1 |
* | EQII |
* | CPTOPSP -4 4 |
* | JZ |
* '-------------------'
* (true)| |(false)
* | V
* | .--------------------.
* | | CPTOPSP -4 4 | (5)
* | | JMP |
* | '--------------------'
* | |
* | |
* V |
* .-------------------. |
* | CPTOPBP -4 4 | |
* | CONSTI 3 | |
* | EQII | |
* '-------------------' |
* | |
* V (6) |
* .-------------------. |
* | LOGORII -4 4 | |
* | JZ |<-'
* '-------------------'
* (true) | |(false)
* ' '
*
* In the block at (5), the top element is now copied, and the code
* jumps unconditionally to the LOGORII block at (6). In contrast
* to JZ, JMP does not pop an element from the stack. The LOGORII
* has enough elements to do its comparison.
*
* This is exactly what the OpenKnights compiler does. And this has
* been fixed by BioWare by the time of Neverwinter Nights 2 as well.
*
* The short-circuiting && construct does not seem to have this fault.
*/
for (Blocks::iterator b = blocks.begin(); b != blocks.end(); ++b) {
if (!isTopStackJumper(*b) || (b->instructions.size() != 2) || b->parents.empty())
continue;
/* Look through all parents of this block and make sure they fit the
* pattern as well. They also all need to jump to this block with the
* same branch edge (true or false). */
size_t parentEdge = SIZE_MAX;
for (std::vector<const Block *>::const_iterator p = b->parents.begin(); p != b->parents.end(); ++p) {
if (!isTopStackJumper(**p, &*b, &parentEdge)) {
parentEdge = SIZE_MAX;
break;
}
}
if (parentEdge == SIZE_MAX)
continue;
assert(parentEdge < 2);
/* We have now established that
* 1) This block checks whether the top of the stack is == 0
* 2) All parent blocks check whether the top of the stack is == 0
* 3) All parent blocks jump with the same branch edge into this block
*
* Therefore, this block must also always follow the exact same edge.
* This means the other edge is logically dead. */
b->childrenTypes[1 - parentEdge] = kBlockEdgeTypeDead;
}
}
void addBlock(Block block) {
blocks.push_back(block);
}
/**
* Unpause par2-files
* returns true, if the files with required number of blocks were unpaused,
* or false if there are no more files in queue for this collection or not enough blocks.
* special case: returns true if there are any unpaused par2-files in the queue regardless
* of the amount of blocks; this is to keep par-checker wait for download completion.
*/
bool ParCoordinator::RequestMorePars(NZBInfo* pNZBInfo, const char* szParFilename, int iBlockNeeded, int* pBlockFound)
{
DownloadQueue* pDownloadQueue = DownloadQueue::Lock();
Blocks blocks;
blocks.clear();
int iBlockFound = 0;
int iCurBlockFound = 0;
FindPars(pDownloadQueue, pNZBInfo, szParFilename, &blocks, true, true, &iCurBlockFound);
iBlockFound += iCurBlockFound;
if (iBlockFound < iBlockNeeded)
{
FindPars(pDownloadQueue, pNZBInfo, szParFilename, &blocks, true, false, &iCurBlockFound);
iBlockFound += iCurBlockFound;
}
if (iBlockFound < iBlockNeeded)
{
FindPars(pDownloadQueue, pNZBInfo, szParFilename, &blocks, false, false, &iCurBlockFound);
iBlockFound += iCurBlockFound;
}
if (iBlockFound >= iBlockNeeded)
{
// 1. first unpause all files with par-blocks less or equal iBlockNeeded
// starting from the file with max block count.
// if par-collection was built exponentially and all par-files present,
// this step selects par-files with exact number of blocks we need.
while (iBlockNeeded > 0)
{
BlockInfo* pBestBlockInfo = NULL;
for (Blocks::iterator it = blocks.begin(); it != blocks.end(); it++)
{
BlockInfo* pBlockInfo = *it;
if (pBlockInfo->m_iBlockCount <= iBlockNeeded &&
(!pBestBlockInfo || pBestBlockInfo->m_iBlockCount < pBlockInfo->m_iBlockCount))
{
pBestBlockInfo = pBlockInfo;
}
}
if (pBestBlockInfo)
{
if (pBestBlockInfo->m_pFileInfo->GetPaused())
{
m_ParChecker.PrintMessage(Message::mkInfo, "Unpausing %s%c%s for par-recovery", pNZBInfo->GetName(), (int)PATH_SEPARATOR, pBestBlockInfo->m_pFileInfo->GetFilename());
pBestBlockInfo->m_pFileInfo->SetPaused(false);
pBestBlockInfo->m_pFileInfo->SetExtraPriority(true);
}
iBlockNeeded -= pBestBlockInfo->m_iBlockCount;
blocks.remove(pBestBlockInfo);
delete pBestBlockInfo;
}
else
{
break;
}
}
// 2. then unpause other files
// this step only needed if the par-collection was built not exponentially
// or not all par-files present (or some of them were corrupted)
// this step is not optimal, but we hope, that the first step will work good
// in most cases and we will not need the second step often
while (iBlockNeeded > 0)
{
BlockInfo* pBlockInfo = blocks.front();
if (pBlockInfo->m_pFileInfo->GetPaused())
{
m_ParChecker.PrintMessage(Message::mkInfo, "Unpausing %s%c%s for par-recovery", pNZBInfo->GetName(), (int)PATH_SEPARATOR, pBlockInfo->m_pFileInfo->GetFilename());
pBlockInfo->m_pFileInfo->SetPaused(false);
pBlockInfo->m_pFileInfo->SetExtraPriority(true);
}
iBlockNeeded -= pBlockInfo->m_iBlockCount;
}
}
bool bHasUnpausedParFiles = false;
for (FileList::iterator it = pNZBInfo->GetFileList()->begin(); it != pNZBInfo->GetFileList()->end(); it++)
{
FileInfo* pFileInfo = *it;
if (pFileInfo->GetParFile() && !pFileInfo->GetPaused())
{
bHasUnpausedParFiles = true;
break;
}
}
DownloadQueue::Unlock();
if (pBlockFound)
{
*pBlockFound = iBlockFound;
}
for (Blocks::iterator it = blocks.begin(); it != blocks.end(); it++)
{
delete *it;
}
blocks.clear();
bool bOK = iBlockNeeded <= 0 || bHasUnpausedParFiles;
return bOK;
}
void AbstractAligner::change_blocks_impl(Blocks& blocks) const {
std::sort(blocks.begin(), blocks.end(), BlockSquareLess());
}
CFGBlock* find_block(int ip) {
Blocks::iterator i = blocks_.find(ip);
if(i == blocks_.end()) return 0;
return i->second;
}
BlkModel::BlkModel(const BlkModel& rhs) {
Blocks blocks = const_cast<BlkModel&>(rhs).blocks();
for (Blocks::iterator it = blocks.begin(); it != blocks.end(); ++it)
addBlock(it->first, it->second);
}
