root/06/devel-old/algos.cc

// File: algos.cc

//   Copyright (C) 2001-6 Ulrich Goertz (u@g0ertz.de)

//   This is part of Kombilo, a go database program.

//   This program is free software; you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation; either version 2 of the License, or
//   (at your option) any later version.

//   This program is distributed in the hope that it will be useful,
//   but WITHOUT ANY WARRANTY; without even the implied warranty of
//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//   GNU General Public License for more details.

//   You should have received a copy of the GNU General Public License
//   along with this program (see doc/license.txt); if not, write to the Free Software
//   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//   The GNU GPL is also currently available at
//   http://www.gnu.org/copyleft/gpl.html

#include <iostream>
#include <fstream>
using namespace std;

#include "algos.h"

// ---------------------------------------------------------------------------------------


string retrieve_datap0(PyObject* datapath) {
}

string retrieve_datap1(PyObject* datapath) {
}

Algorithm::Algorithm(int bsize) {
  boardsize = bsize;
}


Algo_finalpos::Algo_finalpos(int bsize) : Algorithm(bsize) {
  finalpos = 0;
  finalposIndex = -1;
  finalposSize = 0;
  fp = 0;
  fpIndex = -1;
}

Algo_finalpos::~Algo_finalpos() {
  delete [] finalpos;
}


void Algo_finalpos::initialize_process(int l) {
  finalposSize = l*100;
  finalpos = new char[finalposSize];
  finalposIndex = 0;
}

void Algo_finalpos::newgame_process() {
  fp = new char[100];
  for(int i=0; i<100; i++) fp[i] = 255;
}

void Algo_finalpos::AB_process(int x, int y) {
  fp[y/2 + 10*(x/2)] &= ~(1 << (2*(x%2 + 2*(y%2))));
}

void Algo_finalpos::AW_process(int x, int y) {
  fp[y/2 + 10*(x/2)] &= ~(1 << (2*(x%2 + 2*(y%2))+1));
}

void Algo_finalpos::AE_process(int x, int y, char removed) {
}

void Algo_finalpos::endOfNode_process() {
}

void Algo_finalpos::B_process(int x, int y, PyObject* cap) {
  fp[y/2 + 10*(x/2)] &= ~(1 << (2*(x%2 + 2*(y%2))));
}

void Algo_finalpos::W_process(int x, int y, cap) {
  fp[y/2 + 10*(x/2)] &= ~(1 << (2*(x%2 + 2*(y%2))+1));
}

void Algo_finalpos::branchpoint_process() {
}

void Algo_finalpos::endOfVariation_process() {
}

void Algo_finalpos::endgame_process() {
  if (finalposIndex > finalposSize-100) printf("OOPS\n"); // FIXME (remove or throw exception)
  for(int i=0; i<100; i++) finalpos[finalposIndex++] = fp[i];
  delete [] fp;
}

void Algo_finalpos::finalize_process(PyObject* datap) {
  String fn = retrieve_datap0(datap) + "/finalpos" + retrieve_datap1(datap) + ".db"; // FIXME: linux specific!?
  ofstream file(fn, ios::out|ios::trunc|ios::binary) // FIXME: careful with ios::trunc
  file.write(finalpos, finalposSize);
  file.close();
}


int Algo_finalpos::duplicateCheck(sli, datapath) { // FIXME argument types
  if (!strcmp(datapath, "")) {
    for(int i=0; i<100; i++)
      if (finalpos[sli*100+i] != fp[i])
        return 0;
    return 1;
  }
  return 0; // FIXME

//   if (strcmp(currentDatap,datap)) {
//     delete [] currentDatap;
//     currentDatap = new char[strlen(datap)+1];
//     strcpy(currentDatap, datap);
// 
//     char* currentFP = new char[];
// 
//     try {
//       file = open(os.path.join(datap[0], 'finalpos'+datap[1]+'.db'), 'rb');
//       while (1) {
//  try self.currentFP.fromfile(file, 1000000);
//  except EOFError break;
//       }
//       file.close();
//     }
//     except return 0;
//   }
//   
//   for(int i=0; i<100; i++)
//     if (currentFP[sli*100+i] != fp[i])
//       return 0;
//   return 1;   
}

int Algo_finalpos::retrieve_db(PyObject* datap) {
  String fn = retrieve_datap0(datap) + "/finalpos" + retrieve_datap1(datap) + ".db"; // FIXME: linux specific!?
  ifstream file (fn, ios::in|ios::binary|ios::ate);
  if (file.is_open()) {
    ifstream::pos_type size = file.tellg();
    delete [] finalpos;
    finalpos = new char[size];
    file.seekg (0, ios::beg);
    file.read (memblock, size);
    file.close();
    return 1;
  }
  else cout << "Unable to open file";
  return 0;
}


Algo_finalpos::search(patternList, options, db, progBar, progStart, progEnd) {

  int ctr = 0;

  possiblePatterns = range(patternList.size());
  index = db.start();
  int counter = 0;
  if (!self.retrieve_db(db.datapath)) {
    printf("error\n"); // FIXME
    return;
  }

  while (index != -1) {   // FIXME: db.start/next should return -1 instead of None; algosPY entsprechend aendern
    counter++;
    if (progBar && !(counter % 10))
      progBar.redraw((progEnd-progStart)*counter/len(db.current) + progStart);

    matchList = [];

    for(N in possiblePatterns) {
                       
      Pattern pattern = patternList.get(N);
      for(int a0=pattern.left; a0 <= pattern.right; a0++) {
  for(int a1 = pattern.top; a1 <= pattern.bottom; a1++) {
    int matches = 1;
                                    
    int pIndex = 2*(a1%2) + (a0%2);
    char* patternBits = pattern.bits[pIndex]; // FIXME?
    int pbIndex = 0;
          int fpIndex = index*100 + a1/2 + (a0/2)*10;

    for(int x=0; x<patternBits[0]; x++) {
      char start = patternBits[pbIndex+1];
            char length = patternBits[pbIndex+2];
      fpIndex += start;
      pbIndex += 2;
      for(int y=0; y<length; y++) {
        pbIndex++;
        if (patternBits[pbIndex] & finalpos[fpIndex]) {
    matches = 0;
    break;
        }
        fpIndex++;
      }
      if (!matches) break;
      fpIndex += 10 - start - length;
    }                
    if (matches) matchList.append((N,(a0,a1))); // FIXME
  }
      }
    }

    if (matchList) db.makeCurrentCandidate(matchList);
    else db.discardCurrent();

    index = db.next();
  }
}






Algo_movelist::Algo_movelist(int bsize) : Algorithm(bsize) {
}

Algo_movelist::~Algo_movelist() {
  delete [] finalposC;
}

void Algo_movelist:: initialize_process(int l) {

  mainlistArr = vector<char>();
  posTable = vector<long>();
                    
  finalposCSize = l*50;
  finalposC = new char[finalposCSize];
  finalposCIndex = 0;
}                                         

void Algo_movelist::newgame_process() {

  movelist = vector<char>;

  fpCSize = 50;
  fpC = new char[fpCSize];
  fpCIndex = 0;
  for(int i=0; i<fpCSize; i++) fpC[i] = 0;
}
        
void Algo_movelist::AB_process(int x, int y) {
  // FIXME : safety check movelistIndex > movelistSize?
  movelist.push_back((char)x);
  movelist.push_back((char)(y | BLACK));
}
        

void Algo_movelist::AW_process(int x, int y) {
  movelist.push_back((char)x);
  movelist.push_back((char)(y | WHITE));
}


void Algo_movelist::AE_process(int x, int y, char removed) {
  movelist.push_back((char)x);
  if (removed == 'B') movelist.push_back((char)(y | REMOVE | BLACK));
  else if (removed == 'W') movelist.push_back((char)(y | REMOVE | WHITE));
  else printf("oops\n");  // FIXME
}

void Algo_movelist::endOfNode_process() {
  if (movelist.size()>1) {
    if (movelist[movelist.size()-2] & ENDOFNODE) {
      movelist.push_back(ENDOFNODE);
      movelist.push_back(0);
    }
    else movelist[movelist.size()-2] |= ENDOFNODE; // FIXME: funktioniert das so?
  }
}

void Algo_movelist::B_process(int x, int y, cap) {
  if (!movelist.size()) {
    movelist.push_back(ENDOFNODE);
    self.movelist.push_back(0);
  }
  movelist.push_back(x);
  movelist.push_back(y | BLACK);

  for(x, y in cap) { // FIXME
    movelist.push_back(x);
    movelist.push_back(y | REMOVE | WHITE);
    self.fpC[y/4 + 5*(x/2)] |= 1 << (x%2 + 2*(y%4));
  }
}
                
void Algo_movelist::W_process(int x, int y, cap) {
  if (!movelist.size()) {
    movelist.push_back(ENDOFNODE);
    movelist.push_back(0);
  }
  movelist.push_back(x);
  movelist.push_back(y | WHITE);

  for(x, y in cap) {
    movelist.push_back(x);
    movelist.push_back(y | REMOVE | BLACK);
    self.fpC[y/4 + 5*(x/2)] |= 1 << (x%2 + 2*(y%4));
  }
}

void Algo_movelist::branchpoint_process() {
  movelist.push_back(BRANCHPOINT);
  movelist.push_back(0);
}

void Algo_movelist::endOfVariation_process() {
  movelist.push_back(ENDOFVARIATION);
  movelist.push_back(0);
}

void Algo_movelist::endgame_process() {
  posTable.append(len(self.mainlistArr));
  mainlistArr.push_back(255);
  mainlistArr.push_back(255);
  for(int i=0; i<movelist.size(); i++)
    mainlistArr.push_back(movelist[i]);
  
  for(int i=0; i<fpCSize; i++)
    finalposC[finalposCIndex++] = fpC[i];

  delete [] fpC;
  fpCIndex = -1;
  fpCSize = 0;
}

void Algo_movelist::finalize_process(datap) {
  String fn = retrieve_datap0(datap) + "/posTable" + retrieve_datap1(datap) + ".db"; // FIXME: linux specific!?
  ofstream file(fn, ios::out|ios::trunc|ios::binary) // FIXME: careful with ios::trunc
  file.write(posTable, posTableSize); // FIXME: posTable is vector, posTableSize does not exist
  file.close();
  
  fn = datap0 + "/lists" + datap1 + ".db"; // FIXME: linux specific!?
  file(fn, ios::out|ios::trunc|ios::binary) // FIXME: careful with ios::trunc
  file.write(mainlistArr, mainlistArrSize); // FIXME: mainlistArr is vector!, mainlistArrSize does not exist
  file.close();
  
  fn = datap0 + "/finalposC" + datap1 + ".db"; // FIXME: linux specific!?
  file(fn, ios::out|ios::trunc|ios::binary) // FIXME: careful with ios::trunc
  file.write(finalposC, finalposCSize);
  file.close();
}

void Algo_movelist::retrieve_db(datap) {

  String fn = retrieve_datap0(datap) + "/finalposC" + retrieve_datap1(datap) + ".db"; // FIXME: linux specific!?
  ifstream file (fn, ios::in|ios::binary|ios::ate);
  if (file.is_open()) {
    ifstream::pos_type size = file.tellg();
    delete [] finalposC;
    finalposC = new char[size];
    file.seekg (0, ios::beg);
    file.read (memblock, size);
    file.close();
  }
  else {
    cout << "Unable to open file";
    return 0;
  }
  fn = retrieve_datap0(datap) + "/lists" + retrieve_datap1(datap) + ".db"; // FIXME: linux specific!?
  ifstream file (fn, ios::in|ios::binary|ios::ate);
  if (file.is_open()) {
    ifstream::pos_type size = file.tellg();
    delete [] mainlistArr;
    mainlistArr = new char[size];
    file.seekg (0, ios::beg);
    file.read (memblock, size);
    file.close();
  }
  else {
    cout << "Unable to open file";
    return 0;
  }
  fn = retrieve_datap0(datap) + "/posTable" + retrieve_datap1(datap) + ".db"; // FIXME: linux specific!?
  ifstream file (fn, ios::in|ios::binary|ios::ate);
  if (file.is_open()) {
    ifstream::pos_type size = file.tellg();
    delete [] posTable;
    posTable = new char[size]; // FIXME: not a char array???
    file.seekg (0, ios::beg);
    file.read (memblock, size);
    file.close();
    return 1;
  }
  else {
    cout << "Unable to open file";
    return 0;
  }
  return 0;
}



void Algo_movelist::search(patternList, options, db, 
         continuations, contLabelsIndex, contLabels,
         progBar, progStart, progEnd) {

  int numOfHits = 0;
  int self_numOfSwitched = 0;
  int Bwins = 0;
  int Wwins = 0;

  int movelimit = 1000;
  int showColorSwap = 1;

  if (options.has_key('movelimit')) movelimit = options['movelimit'];
  if (options.has_key('showcolorswap')) showColorSwap = options['showcolorswap'];

  if (!retrieve_db(db.datapath)) {
    printf("error\n"); // FIXME
    return;
  }
            
  int index = db.start();
  int gameCounter = 0;
        
  while (index != -1) {

    gameCounter++;
    if (progBar && !(gameCounter % 10))
      progBar.redraw((progEnd-progStart)*gameCounter/len(db.current) + progStart);
            
    result = [];
    numOfSwitched = 0;
    branchpoints = [];

    // movelist = mainlistArr;
    int movelistIndex = posTable[index] + 2;

    int endMovelist = movelistIndex;
    while (endMovelist < mainlistArr.size() && mainlistArr[endMovelist] != 255)
      endMovelist += 2;
        
    dicts = {};
    contList = {};
    contListIndex = {};
    dictsNO = {};
    Xinterv = {};
    Yinterv = {};

    for (m in db.getCurrentMatchlist()) {
      d = {};
      dNO = 0;
      Pattern p = patternList.get(m[0]);
      for(int i=0; i<p.sizeX; i++) {
  for(int j=0; j<p.sizeY; j++) {
    char p_ij = p.getInitial(i,j);
    if (p_ij != '.') d[(i+m[1][0],j+m[1][1])] = p_ij;
    if (p_ij == 'X' or p_ij == 'O') dNO++;
  }
      }

      dicts[m] = d;
      dictsNO[m] = dNO;

      contList[m] = [];
      for (x, y, color in p.contList)
  contList[m].append((x+m[1][0], y+m[1][1], color));

      contListIndex[m] = 0;
      Xinterv[m] = (m[1][0], m[1][0] + p.sizeX);
      Yinterv[m] = (m[1][1], m[1][1] + p.sizeY);
    }
    
    int counter = 0;
            
    while (movelistIndex < endMovelist && counter <= self.movelimit) {

      if (mainlistArr[movelistIndex] & BRANCHPOINT) {
  self.branchpoints.append((deepcopy(dicts), deepcopy(dictsNO),
          deepcopy(contList), deepcopy(contListIndex), counter));
  movelistIndex += 2;
  continue;
      }
      else if (mainlistArr[movelistIndex] & ENDOFVARIATION) {
  if (!patternList.nextMove) {
    for(m in dicts.keys())
      if (dicts[m].has_key('found')) {
        Pattern p = patternList.get(m[0]); // FIXME: besser pointer uebergeben?
        if (p.colorSwitch) numOfSwitched++;
        if (p.colorSwitch && showColorSwap)
    result.append((dicts[m]['found'], '-'));
        else result.append((dicts[m]['found'], ''));
      }
  }
  dicts, dictsNO, contList, contListIndex, counter = self.branchpoints.pop();
  movelistIndex += 2;
  continue;
      }
      
      int endOfNode = mainlistArr[movelistIndex] & ENDOFNODE;

      int x = mainlistArr[movelistIndex] & 31;
      int y = mainlistArr[movelistIndex+1] & 31;

      char co;
      char invco;

      if (!(mainlistArr[movelistIndex+1] & REMOVE) && (mainlistArr[movelistIndex+1] & (BLACK | WHITE))) {
  if (mainlistArr[movelistIndex+1] & BLACK) {
    co = 'X';
    invco = 'O';
  }
  else {
    co = 'O';
    invco = 'X';
  }

  for(m in dicts.keys()) {
    if (Xinterv[m][0] <= x && x < Xinterv[m][1] && Yinterv[m][0] <= y && y < Yinterv[m][1]) {
      if (dicts[m].has_key('found')) {
        hit, label, contLabelsIndex, switched = patternList.updateContinuations(m[0], x, y, invco,
                          Xinterv[m], Yinterv[m],
                          dicts[m]['found'], counter,
                          continuations, contLabels,
                          contLabelsIndex,
                          db.getCurrentWinner());
        if (!hit) {
    del dicts[m];
    del dictsNO[m];
    continue;
        }
        
        numOfSwitched += switched; // FIXME: CHECK, was: patternList[m[0]].colorSwitch

        if (switched && showColorSwap)
    // FIXME: CHECK,was: (patternList[m[0]].colorSwitch or colorSwitch) and showColorSwap:
    result.append((dicts[m]['found'], label + '-'));
        else result.append((dicts[m]['found'], label));
        del dicts[m];
        del dictsNO[m];
        continue;     // with for m in dicts.keys()
      }
      else if (dicts[m].has_key('foundInitial')) {
        if ((x, y, co) == contList[m][contListIndex[m]]) {
    contListIndex[m]++;
    if (contListIndex[m] == len(contList[m])) {
      dicts[m]['found'] = counter;
      del dicts[m]['foundInitial'];
    }
        }
        else {
    if (dicts[m].has_key('dontRestore')) {
      del dicts[m];
      continue;
    }
    else {
      contListIndex[m] = 0;
      del dicts[m]['foundInitial'];
    }
        }
      }
                    
      if (!dicts[m].has_key((x,y))) {
        if (!(self.finalposC[index*50 + y/4 + 5*(x/2)] & (1 << (x%2 + 2*(y%4))))) {

    if (!contListIndex[m]) {
      del dicts[m];
      continue;
    }
                else dicts[m]['dontRestore'] = 1;
        }
        else {
    dicts[m][(x,y)] = '.';
    dictsNO[m]++;
        }
      }
      else if (dicts[m][(x,y)] == lower(invco)) {
        if (!(self.finalposC[index*50 + y/4 + 5*(x/2)] & (1 << (x%2 + 2*(y%4))))) {
    if (!contListIndex[m]) {
      del dicts[m];
      continue;
    }
    else dicts[m]['dontRestore'] = 1;
        }
        else dictsNO[m]++;
      }
      else if (dicts[m][(x,y)] == co) {
        del dicts[m][(x,y)];
        dictsNO[m]--;
      }
    }
  }
      }
      else if (mainlistArr[movelistIndex+1] & REMOVE) {
  if (mainlistArr[movelistIndex+1] & BLACK) {
    co = 'X';
    invco = 'O';
  }
  else if mainlistArr[movelistIndex+1] & WHITE {
    co = 'O';
    invco = 'X';
  }
  else printf("oops\n"); // FIXME

  for (m in dicts.keys()) {
    if (!dicts[m].has_key('found')) {
      if (Xinterv[m][0] <= x && x < Xinterv[m][1] && Yinterv[m][0] <= y && y < Yinterv[m][1]) {
        if (dicts[m].has_key('foundInitial')) {
    int ii = contListIndex[m];
    while (ii < len(contList[m]) && contList[m][ii][2] == '-' &&
           (x != contList[m][ii][0] || y != contList[m][ii][1]))
      ii++;
    if (ii < len(contList[m]) && contList[m][ii][2] == '-') {
      help = contList[m][ii];
      contList[m][ii] = contList[m][contListIndex[m]];
      contlist[contListIndex[m]] = help;

      contListIndex[m]++;
    }
    else {
      if (dicts[m].has_key('dontRestore')) {
        del dicts[m];
        continue;
      }
      else {
        contListIndex[m] = 0;
        del dicts[m]['foundInitial'];
      }
    }
        }
        if (!dicts[m].has_key((x,y))) {
    dicts[m][(x,y)] = co;
    dictsNO[m]++;
        }
        else if (dicts[m][(x,y)] == lower(invco)) {
    dictsNO[m]--;
        }
        else if (dicts[m][(x,y)] == '.') {
    del dicts[m][(x,y)];
    dictsNO[m]--;
        }
      }
    }
  }
      }

      if (endOfNode) {
  for (m in dicts.keys()) {
    if (!dictsNO[m] && !dicts[m].has_key('found') && !dicts[m].has_key('foundInitial'))
      if (contListIndex[m] == len(contList[m])) dicts[m]['found'] = counter;
      else dicts[m]['foundInitial'] = counter;
  }
  
  counter++;
      }
                    
      if (dicts=={} && !self.branchpoints) break;
      movelistIndex += 2;
    }

    if (!patternList.nextMove) {
      for (m in dicts.keys()) {
  Pattern p = patternList.get(m[0]);
  if (dicts[m].has_key('found')) {
    if (p.colorSwitch) numOfSwitched++;
    if (p.colorSwitch && showColorSwap) result.append((dicts[m]['found'], '-'));
    else result.append((dicts[m]['found'], ''));
  }
      }
    }

    if (result) {
      numOfHits += len(result);
      self_numOfSwitched += numOfSwitched;
            
      if (db.getCurrentWinner() == 'B') {
  Bwins += len(result) - numOfSwitched;
  Wwins += Wwins + numOfSwitched;
      }
      else if (db.getCurrentWinner() == 'W') {
  Bwins += numOfSwitched;
  Wwins += len(result) - numOfSwitched;
      }
      result.sort();
      db.makeCurrentHit(join([str(x[0])+x[1] for x in result], ', '));
    }
    else db.discardCurrent();

    index = db.next();
  }
  return numOfHits, Bwins, Wwins, self.numOfSwitched;
}
    

// Algo_hash::Algo_hash(int bsize, plist, char* fname) : ALgorithm(bsize) {
//   poslist = [[0,0] + p for p in plist];
//   filename = new char[strlen(fname)+1];
//   strcpy(filename, fname);
// }
// 
// Algo_hash::~Algo_hash() {
//   delete [] filename;
// }
// 
// void Algo_hash::initialize_process(l) {
//   hash_global = hashTable(l, self.filename);
//   gameCtr = 0;
// }
//         
// void Algo_hash::newgame_process() {
// 
//   for (p in self.poslist) {
//     p[0] = 0;
//     p[1] = 0;
//   }
// 
//   hash_global.newCtr(gameCtr);
//   branchpoints = [];
// }
// 
// void Algo_hash::AB_process(int x, int y) {
//   for (p in self.poslist) {
//     if (p[2] <= x && x <= p[4] && p[3] <= y && y <= p[5]) {
//       p[0]++;
//       p[1] += hashTable.hash_value[(x,y)];
//     }
//   }
// }
// 
// void Algo_hash::AW_process(int x, int y) {
//   for (p in self.poslist) {
//     if (p[2] <= x && x <= p[4] && p[3] <= y && y <= p[5]) {
//       p[0]++;
//       p[1] -= hashTable.hash_value[(x,y)];
//     }
//   }
// }                 
// 
// void Algo_hash::AE_process(int x, int y, char removed) {
//   int epsilon;
//   if (removed == 'B') epsilon = -1;
//   else epsilon = 1;
//   
//   for (p in self.poslist) {
//     if (p[2] <= x && x <= p[4] && p[3] <= y && y <= p[5]) {
//       p[0]--;
//       p[1] += epsilon * hashTable.hash_value[(x,y)];
//     }
//   }
// }
// 
// void Algo_hash::endOfNode_process() {
//   for(p in self.poslist)
//     if (p[0] <= p[6]) self.hash_global.append(p[1]);
// }
// 
// void Algo_hash::B_process(int x, int y, cap) {
//   self.move_process(x, y, cap, 1);
// }
// 
// void Algo_hash::W_process(int x, int y, cap) {
//   self.move_process(x, y, cap, -1);
// }
// 
// void Algo_hash::move_process(int x, int y, cap, epsilon) {
//   for (p in self.poslist)
//     if (p[2] <= x && x <= p[4] && p[3] <= y && y <= p[5]) {
//       p[0]++;
//       p[1] += epsilon * hashTable.hash_value[(x,y)];
//     }
//   
//   for (c in cap) {
//     for(p in self.poslist) 
//       if (p[2] <= c[0] && c[0] <= p[4] && p[3] <= c[1] && c[1] <= p[5]) {
//  p[0] -= 1;
//  p[1] += epsilon * hashTable.hash_value[c];
//       }
//   }
// }
// 
// void Algo_hash::branchpoint_process() {
//   branchpoints.append(deepcopy(self.poslist));
// }
// 
// void Algo_hash::endOfVariation_process() {
//   poslist = self.branchpoints.pop();
// }
// 
// void Algo_hash::endgame_process() {
//   gameCtr++;
// }
//  
// void Algo_hash::finalize_process(PyObject* datap) {
//   hash_global.newCtr(gameCtr);
//   hash_global.sortedOutput(datap);
// }
// 
// 
// long Algo_hash::compute_hashkey(Pattern pattern, type) {
// 
//   int numOfStones = 0;
// 
//   a0,b0,a1,b1, maxNumOfStones = type;
//   long hashkey = 0;
//             
//   for(int i=a0, i<a1+1; i++) {
//     for(int j=b0; j<b1+1; j++) {
//       if (pattern.data[i-pattern.anchors[0][0]][j-pattern.anchors[0][1]] in ['x', 'o', '*'])
//  return NOT_HASHABLE;
//       else if (pattern.data[i-pattern.anchors[0][0]][j-pattern.anchors[0][1]] == 'X') {
//  hashkey += hashTable.hash_value[(i,j)];
//  numOfStones += 1;
//       }
//       else if (pattern.data[i-pattern.anchors[0][0]][j-pattern.anchors[0][1]] == 'O') {
//  hashkey -= hashTable.hash_value[(i,j)];
//  numOfStones += 1;
//       }
//     }
//     if numOfStones > maxNumOfStones: return NOT_HASHABLE;
//   }
//   return hashkey;
// }
// 
// int Algo_hash::retrieve_db(PyObject* datap) {
//  String fn = ... filename ...; // FIXME
//  ifstream file (fn, ios::in|ios::binary|ios::ate);
//  if (file.is_open()) {
//    ifstream::pos_type size = file.tellg();
//    delete [] hash;
//    hash = new char[size]; // FIXME: not a char array?
//    file.seekg (0, ios::beg);
//    file.read (memblock, size);
//    file.close();
//  }
//   else {
//    cout << "Unable to open file";
//    return 0;
//  }
//  String fn = ... filename + "T" ...; // FIXME
//  ifstream file (fn, ios::in|ios::binary|ios::ate);
//  if (file.is_open()) {
//    ifstream::pos_type size = file.tellg();
//    delete [] hashT;
//    hashT = new char[size];
//    file.seekg (0, ios::beg);
//    file.read (memblock, size);
//    file.close();
//  }
//   else {
//    cout << "Unable to open file";
//    return 0;
//  }
//   return 0;
// }
// 
// void Algo_hash::search(patternList, options, db, progBar, progStart, progEnd) {
//   for(int i=0; i<patternList.size(); i++) {
//     Pattern pattern = patternList.get(i);
//     pattern_hashkeys = {};
//             
//     for(int a0=pattern.left; a0<=pattern.right; a0++) {
//       for(int a1=pattern.top; a1<=pattern.bottom; a1++) {
//  pattern_hashkeys[(a0,a1)] = [];
//  for(p in self.poslist) {
//    if (a0 <= p[2] && a0+pattern.sizeX >= p[4] a1 <= p[3] && a1+pattern.sizeY >= p[5]) {
//      hk = self.compute_hashkey(pattern, p[2:]);
// 
//      if (hk != NOT_HASHABLE) pattern.hashkeys[(a0,a1)].append([hk]);
//    }
//  }
//  if (!pattern.hashkeys[(a0,a1)]) return;
//       }
//     }
//   }
//         
//   if (!self.retrieve_db(db.datapath)) {
//     printf("error\n"); // FIXME
//     return;
//   }
//         
//   for(int N=0; N<patternList.size(); N++) {
//     Pattern pattern = patternList.get(N);
//             
//     for(int a0=pattern.left; a0<=pattern.right; a0++) {
//       for(int a1=pattern.top; a1<=pattern.bottom; a1++) {
//             
//  for(int hk=0; hk<len(pattern.hashkeys[(a0,a1)]); hk++) {
// 
//    int hashkey = pattern.hashkeys[(a0,a1)][hk][0];
//    int start = 0;
//    int end = len(self.hashT)/2;
//                   
//    int hash_start;
//    int hash_end;
// 
//    while (start < end) {
//      int help = self.hashT[2*((start+end)/2)];
//      if (help == hashkey) {
//        hash_start = self.hashT[2*((start+end)/2)+1];
//        if (2*((start+end)/2)+3 >= len(self.hashT)) hash_end = len(hash);
//        else hash_end = self.hashT[2*((start+end)/2)+3];
// 
//        pattern.hashkeys[(a0,a1)][hk].extend([hash_start, hash_start, hash_end]);
//        break;