void move_and_count( int dsource, int ddest, int ecx )
{
if ( ecx <= 0 )
return;
if ( dsource > 0 ) {
// ADD ESI, dsource
Code_counter += 6;
}
if ( !is_svga ) {
if ( ddest > 0 ) {
// ADD EDI, ddest
Code_counter += 6;
}
count_block( ecx );
} else {
int p1, p2, o1;
linear_address += ddest; // Skip to next block
p1 = linear_address >> 16;
o1 = linear_address & 0xFFFF;
p2 = (linear_address+ecx) >> 16;
if ( p1 != ibitblt_svga_page ) {
// Set page
// MOV EAX, ?, CALL EBX
Code_counter += 7;
ibitblt_svga_page = p1;
}
Code_counter += 5; // mov edi, ????
if ( p1 == p2 ) {
count_block( ecx );
} else {
int nbytes;
nbytes = 0xFFFF-o1+1;
count_block( nbytes );
// set page
// MOV EAX, 0
Code_counter += 7; // mov eax,???? call ebx
ibitblt_svga_page = p2;
Code_counter += 5; // mov edi, ????
nbytes = ecx - nbytes;
if (nbytes > 0 )
count_block( nbytes );
}
linear_address += ecx;
}
}
int ls_l(char *str, t_ls *ls, int nb)
{
t_file *eof;
struct stat file;
if ((eof = malloc(sizeof(t_ls))) == NULL)
return (-1);
eof = ls->first;
if (nb != 1)
my_printf("total %d\n", count_block(str) / 2);
while (eof != NULL)
{
if (eof->file[0] != '.')
make_it_happen(file, eof->file);
if (eof->file[0] == '.' && nb == 1)
make_it_happen(file, eof->file);
eof = eof->next;
}
return (0);
}
void reader::read_infercars(const ProblemInstance& cfg, std::vector<Genome>& genome) {
std::ifstream input(cfg.get_blk_file().c_str());
if(!input) {
std::cerr << "Unable to open " << cfg.get_blk_file() << std::endl;
exit(1);
}
std::string gene;
std::vector<std::string> chromosome(cfg.get_count_genomes());
std::vector<std::string> sign(cfg.get_count_genomes());
std::vector<int> start_block(cfg.get_count_genomes());
std::vector<int> end_block(cfg.get_count_genomes());
std::vector<int> count_block(cfg.get_count_genomes());
while(!input.eof()) {
std::string line;
std::getline(input, line);
line = reader::trim(line);
if (line.empty()) {
if (gene.empty()) {
continue;
}
bool ambig = false;
for(int i = 0; i < count_block.size(); ++i) {
if (count_block[i] != 1) {
ambig = true;
break;
}
}
if (ambig) {
std::clog << "Ambiguous block: " << gene << std::endl;
continue;
}
for(int i = 0; i < count_block.size(); ++i) {
if (count_block[i] == 1) {
int sign_ = (sign[i] == "+")? +1: -1;
genome[i].insert(gene, chromosome[i], (start_block[i] + end_block[i]) / 2, sign_, std::min(start_block[i], end_block[i]), std::max(start_block[i], end_block[i]));
}
}
gene.clear();
} else if (line[0] == '#') {
continue;
} else if(line[0] == '>') {
gene = line.substr(1);
std::fill(count_block.begin(), count_block.end(), 0);
} else {
line[line.find(".")] = ' ';
line[line.find(":")] = ' ';
line[line.find("-")] = ' ';
std::istringstream istr(line);
std::string genome_name;
istr >> genome_name;
if (!cfg.member_name(genome_name)) {
std::cerr << "Unknown genome name: " << genome_name << std::endl;
continue;
}
size_t k = cfg.get_number(genome_name);
istr >> chromosome[k] >> start_block[k] >> end_block[k] >> sign[k];
++count_block[k];
}
}
input.close();
}
int gen_hufftable_wsq(HUFFCODE **ohufftable, unsigned char **ohuffbits,
unsigned char **ohuffvalues, short *sip, const int *block_sizes,
const int num_sizes)
{
int i, j;
int ret;
int adjust; /* tells if codesize is greater than MAX_HUFFBITS */
int *codesize; /* code sizes to use */
int last_size; /* last huffvalue */
unsigned char *huffbits; /* huffbits values */
unsigned char *huffvalues; /* huffvalues */
int *huffcounts; /* counts for each huffman category */
int *huffcounts2; /* counts for each huffman category */
HUFFCODE *hufftable1, *hufftable2; /* hufftables */
if((ret = count_block(&huffcounts, MAX_HUFFCOUNTS_WSQ,
sip, block_sizes[0], MAX_HUFFCOEFF, MAX_HUFFZRUN)))
return(ret);
for(i = 1; i < num_sizes; i++) {
if((ret = count_block(&huffcounts2, MAX_HUFFCOUNTS_WSQ,
sip+block_sizes[i-1], block_sizes[i],
MAX_HUFFCOEFF, MAX_HUFFZRUN)))
return(ret);
for(j = 0; j < MAX_HUFFCOUNTS_WSQ; j++)
huffcounts[j] += huffcounts2[j];
free(huffcounts2);
}
if((ret = find_huff_sizes(&codesize, huffcounts, MAX_HUFFCOUNTS_WSQ))){
free(huffcounts);
return(ret);
}
free(huffcounts);
if((ret = find_num_huff_sizes(&huffbits, &adjust, codesize,
MAX_HUFFCOUNTS_WSQ))){
free(codesize);
return(ret);
}
if(adjust){
if((ret = sort_huffbits(huffbits))){
free(codesize);
free(huffbits);
return(ret);
}
}
if((ret = sort_code_sizes(&huffvalues, codesize, MAX_HUFFCOUNTS_WSQ))){
free(codesize);
free(huffbits);
return(ret);
}
free(codesize);
if((ret = build_huffsizes(&hufftable1, &last_size,
huffbits, MAX_HUFFCOUNTS_WSQ))){
free(huffbits);
free(huffvalues);
return(ret);
}
build_huffcodes(hufftable1);
if((ret = check_huffcodes_wsq(hufftable1, last_size))){
fprintf(stderr, "ERROR: This huffcode warning is an error ");
fprintf(stderr, "for the encoder.\n");
free(huffbits);
free(huffvalues);
free(hufftable1);
return(ret);
}
if((ret = build_huffcode_table(&hufftable2, hufftable1, last_size,
huffvalues, MAX_HUFFCOUNTS_WSQ))){
free(huffbits);
free(huffvalues);
free(hufftable1);
return(ret);
}
free(hufftable1);
*ohuffbits = huffbits;
*ohuffvalues = huffvalues;
*ohufftable = hufftable2;
return(0);
}
