root/06/devel-old/agl.cc

abstractGameList::abstractGameList(int bs, PyObject* pBar) {
  boardsize = bs;
  if (boardsize==19) bsize = 0;
  if (boardsize==13) bsize = 1;
  if (boardsize==9) bsize = 2;

  vector<SGFDatabase> DBlist[3];
  Bwins = Wwins = Owins = 0;
  
  references = new map ...;
  sort = None;
  gameIndex = new vector<pair<int, int> >;

  showFilename = 1;
  showDate = 0;

  perDB = 1;
  criterion = "";
  reverse = 0; 

  progBar = pBar;
  stopAddDBVar = 0;
}

void abstractGameList::readReferences(char* basepath) throw(IOError) {
                
  ref_file = open(os.path.join(basepath, 'references'));

  if (!ref_file) throw IOerror();
  r_list = ref_file.readlines();
  ref_file.close();
        
        abbr = {}
        found_abbr = 0
        found_data = 0
        for line in r_list:

            if line and line[0] == '#': continue
        
            if not found_abbr:
                if line[:7] != '---Abbr': continue
                else:
                    found_abbr = 1
                    continue
                
            if found_abbr and not found_data:
                if strip(line):
                    s = split(line)
                    abbr[s[0]] = join(s[1:], ' ')

            if found_abbr and not found_data:
                if line[:7] != '---Data': continue
                else:
                    found_data = 1
                    continue
                
            if found_data and strip(line):
                s = split(line)
                if abbr.has_key(s[1]):
                    if self.references.has_key(s[0]):
                        self.references[s[0]] += ', ' + abbr[s[1]] + ' ' + join(s[2:], ' ')
                    else:
                        self.references[s[0]] = abbr[s[1]] + ' ' + join(s[2:], ' ')
}

pair<int,int> abstractGameList::getIndex(int i) {
  if (i < gameIndex.size()) return gameIndex[i];
  else return pair<int,int>(-1, -1);
}


pair<char*,int> abstractGameList::getFilename(int index1) {
  pair<int,int> p = getIndex(index1);
  index = DBlist[bsize][p.first].current[p.second];
  return self.DBlist[bsize][p.first].getFilename(index);
}
    

int abstractGameList::getMoveno(int index) {
  pair<int,int> p = self.getIndex(index);
  int moveno;

  if (DBlist[bsize][p.first].results.size() > p.second) {
    s = DBlist[bsize][p.first].results[p.second];
    int i = 0;
    while (i<strlen(s) && s[i] in digits) i++;
    moveno = int(s[:i]);
  }
  else moveno = 0;
  return moveno;
}

    
char* abstractGameList::getString(int index) {
  pair<int,int> p = self.getIndex(index);
  int DBindex = p.first;
  int indexWithinCurrent = p.second;

  int indexWithinDB = DBlist[bsize][DBindex].current[indexWithinCurrent];

  if (DBindex == -1) return "";
        
  l = DBlist[bsize][DBindex].namelist[indexWithinDB];
  sl = char[1000];
  
  if (references.has_key(l[4])) sl.append('* ');
  
  if (showFilename) sl.append(l[0]+': ');

  sl.append(l[2] + ' - ' + l[1] + ' (' + l[3] + '), ');
  if (self.showDate) sl.append(l[5]+', ');
  if (results...) sl.append(join(self.DBlist[`self.boardsize`][DBindex].results[indexWithinCurrent], ''));
  return sl; // FIXME ... strcpy to string of right size
}


vector<char*> abstractGameList::getAllStrings() {
  return [self.getString(i) for i in range(self.numOfGames())];
}


char* abstractGameList::getGameInfo(int index) {
  pair<int,int> p = getIndex(index);
  int DBindex = p.first;
  int indexWithinCurrent = p.second;

  pair<char*, int> q = getFilename(index);

  try {
    f = open(q.first);
    sgf = f.read();
    f.close();
    Node node = Cursor(sgf, 1).getRootNode(q.second); // FIXME: node should be the node itself, not the data dict
  }
  catch(...) return "";

  char* t = new char[];
        
  if (node.has_key("PW")) strcat(t, node.getstr("PW", 0));
  else strcat(t, " ?");
  if (node.has_key("WR")) strcat(t, node.getstr("WR", 0));
  
  strcat(t, " - ");

  if (node.has_key("PB")) strcat(t, node.getstr("PB", 0));
  else strcat(t, " ?");
  if (node.has_key("BR")) strcat(t, node.getstr("BR", 0));

  if (node.has_key("RE")) strcat(t, node.getstr("RE", 0));
  if (node.has_key('KM')) {
    strcat(t, " (Komi ");
    strcat(t, node.getstr("KM", 0));
    strcat(t, ")");
  }
  if (node.has_key("HA")) {
    strcat(t, " (Hcp ");
    strcat(t, node.getstr("HA", 0));
    strcat(t, ")");
  }

  strcat(t, "\n");

  if (node.has_key("EV")) {
    strcat(t, node.getstr("EV", 0));
    strcat(t, ", ");
  }
  if (node.has_key("RO")) {
    strcat(t, node.getstr("RO", 0));
    strcat(t, ", ");
  }
  if (node.has_key("DT")) {
    strcat(t, node.getstr("DT", 0));
    strcat(t, "\n");
  }

  if (node.has_key("GC")) {
    char* s = node.getstr("GC", 0);
    char* gc = new char[strlen(s)+1];
    int gcIndex = 0
      for(int i=0; i<strlen(s); i++) 
        if (s[i] != '\n' && s[i] != '\r') gc[gcIndex++] = s[i];
        else gc[gcIndex++] = ' ';
    gc[gcIndex] = 0;
    strcat(t, gc);
    delete [] gc;
  }

  char* t2 = new char[];
  try {
    t2 = 'Commentary in ' +\
      self.references[self.DBlist[`self.boardsize`][DBindex].namelist[self.DBlist[`self.boardsize`][DBindex].current[indexWithinCurrent]][4]];
  }
  catch() else t2 = '';

  strcpy ...;
  delete [] t;
  delete [] t2;
  return t, t2;
}


void abstractGameList::changeBoardSize(int bs) {
  boardsize = bs;
  if (boardsize==19) bsize = 0;
  if (boardsize==13) bsize = 1;
  if (boardsize==9) bsize = 2;
  
  Bwins 0;
  Wwins = 0;
  Owins = 0;

  references = {};
  gameIndex.clear();
  
  for(db in self.DBlist[`self.boardsize`]) {
    success = db.loadDB();
    if (success != 1) ...;
  }
  
  updateGameIndex();
        
  for bs in [9, 13, 19] {
    if (bs != self.boardsize)
      for(db in self.DBlist[`bs`])
        db.clear();
  }
}

              
void abstractGameList::reset() {
        
  vector<>::iterator it;
  for(it = DBlist[bsize].begin(); it != DBlist[bsize].end(); it++) {
    if (!db.disabled) {
      db.current = array('L', range(len(db.namelist)));
      db.results = [''] * len(db.namelist);
    }
    else {
      db.current = array('L');
      db.results = [];
    }
  }
  updateGameIndex();
}


char* abstractGameList::sortCrit(int index, int c) {
  pair<int,int> p = getIndex(index);
  return DBlist[bsize][p.first].namelist[DBlist[bsize][p.first].current[p.second]][c];
}


void abstractGameList::updateGameIndex(int sortList) {
        
  gameIndex.clear();

  int c = 0;
  if (criterion == "PW") c = 2;
  if (criterion == "PB") c = 1;
  if (criterion == "DT") c = 5;
  
  if ((perDB && c == 0) || !sortlist)
    for (i in range(len(self.DBlist[`self.boardsize`]))) {
      db = self.DBlist[`self.boardsize`][i];
      if db.disabled: continue;
      self.gameIndex.extend([(i, j) for j in range(len(db.current))]);
    }
  else { 
    if (perDB) 
      for i in range(len(self.DBlist[`self.boardsize`])) {
        db = self.DBlist[`self.boardsize`][i];
        if db.disabled: continue;
        
        helpList = [];
        helpList.extend([(db.namelist[j][c], j) for j in range(len(db.namelist))]);
        helpList.sort();
        
        self.gameIndex.extend([(i, j) for dummy, j in helpList]);
      }
    else {
      srt = [];
      for i in range(len(self.DBlist[`self.boardsize`])) {
        db = self.DBlist[`self.boardsize`][i];
        if db.disabled: continue;
        srt.extend([(db.namelist[j][c], i, j) for j in range(len(db.namelist))]);
      }
      srt.sort();
      self.gameIndex = [(i, j) for dummy, i, j in srt];
    }
  }
  
  if (reverse && sortList) self.gameIndex.reverse();

  Bwins = Wwins = Owins = 0;
  for (db in DBlist[bsize]) {
    if db.disabled: continue;
    s = join([db.namelist[db.current[i]][3] for i in range(len(db.current))], '');
    Bwins = count(s, 'B');
    Wwins = count(s, 'W');
    Owins = len(s) - Bwins - Wwins;
  }
}


int abstractGameList::numOfGames() {
  int num = 0;
  for (db in self.DBlist[`self.boardsize`]) {
    if (db.disabled) continue;
    num += db.current.size();
  }
  return num;
}


void abstractGameList::toggleDisabled(int DBIndex, int disabled) {
  DBlist[bsize][DBIndex].disabled = disabled;
  updateGameIndex();
}


char* abstractGameList::saveData() {

  char result[1000];
  for (bs=0; bs<3; bs++) {
    for (db in self.DBlist[bs]) {
      if (db.disabled)
        result.append('dD|%' + bs + '|%' + db.sgfpath + '|%' + db.datapath[0] +\
                      '|%' + db.datapath[1] +'\n');
      else
        result.append('d|%' + bs + '|%' + db.sgfpath + '|%' + db.datapath[0] +\
                      '|%' + db.datapath[1] +'\n');
    }
  }
  return strcpy(result, '');
}
 

void abstractGameList::addDB(char* sgfpath, pair<char*,int> datap, PyObject* messages, int recProcess,
                             int algos, char* filenames, int sloppySGF, int duplicateCheck, 
                             int strictDuplicateCheck) {
  stopAddDBVar = 0;

  if (!recProcess) addOneDB((messages, datap, algos, filenames,
                             sloppySGF, duplicateCheck, strictDuplicateCheck), sgfpath, None);
  else os.path.walk(sgfpath, self.addOneDB,
                    (messages, datap, algos, filenames,
                     sloppySGF, duplicateCheck, strictDuplicateCheck));
}
        
    def addOneDB(self, arguments, dbpath, dummy):        # dummys needed for os.path.walk
        if self.stopAddDBVar: return

        messages, datap, algos, filenames,\
                  sloppySGF, duplicateCheck, strictDuplicateCheck = arguments 
        if datap[1] == '#': datap = (dbpath, '')
        else:
            try:
                flist = glob.glob(os.path.join(datap[0], 'namelist*.db'))
                i = 1
                
                while 1:
                    if not os.path.normpath(os.path.join(datap[0], 'namelist' + `i` + '.db')) in flist:
                        break
                    i += 1
            except IOError:
                messages.insert('end', 'Error: ' + datap[0] + 'cannot be used as database path.\n')
                return

            datap = (datap[0], `i`)

        for db in self.DBlist[`self.boardsize`]:
            if dbpath == db.sgfpath:
                messages.insert('end', 'Error: The database ' + dbpath + ' is already in the list.\n')
                return

        newDB = SGFDatabase(self.boardsize, self.progBar)
        if newDB.loadDB(dbpath, datap) != 1:
            try:
                
                newDB.process(dbpath, datap, algos, filenames, messages,
                              sloppySGF, duplicateCheck, strictDuplicateCheck, self)
            except IOError: # FIXME
                messages.insert('Error',
                                'A fatal error occured when processing ' + dbpath + '. Please send a bug report.\n')
                return

        self.DBlist[`self.boardsize`].append(newDB)
        self.updateGameIndex()
        messages.insert('end', 'Added ' + dbpath + '.\n')


    def removeDB(self, toBeRemoved, messages):
        for ii in toBeRemoved:
            i = int(ii)
            datap = self.DBlist[`self.boardsize`][i].datapath
            dbpath = self.DBlist[`self.boardsize`][i].sgfpath
            filelist = []
            for algo in ALL_ALGOS.keys():
                if self.DBlist[`self.boardsize`][i].algos & algo:
                    filelist.extend(ALL_ALGOS[algo].filelist)
            del self.DBlist[`self.boardsize`][i]

            deletionFailed = 0
            for filename in filelist:
                try:
                    os.remove(os.path.join(datap[0], filename+datap[1]+'.db'))
                except:
                    deletionFailed = 1
            if deletionFailed: messages.insert('end', 'I/O Error: Could not delete the database files.\n')
            messages.insert('end', 'Removed ' + dbpath + '\n')
        self.updateGameIndex()    
        self.reset()


    def reprocessDB(self, toBeReprocessed, messages, algos=None, filenames='*.sgf',
                    sloppySGF=1, duplicateCheck=1, strictDuplicateCheck=0):
        failed = []
        if not toBeReprocessed: return
        
        for i in toBeReprocessed:
            if algos is None: thisAlgos = self.DBlist[`self.boardsize`][i].algos
            else: thisAlgos = algos
            
            sgfpath = self.DBlist[`self.boardsize`][i].sgfpath
            datap = self.DBlist[`self.boardsize`][i].datapath
            filelist = []
            for algo in ALL_ALGOS.keys():
                if self.DBlist[`self.boardsize`][i].algos & algo:
                    filelist.extend(ALL_ALGOS[algo].filelist)
            del self.DBlist[`self.boardsize`][i]

            deletionFailed = 0
            for filename in filelist:
                try:
                    os.remove(os.path.join(datap[0], filename+datap[1]+'.db'))
                except:
                    deletionFailed = 1
            if deletionFailed:
                messages.insert('end','I/O Error: Could not delete the database files.\n')

            newDB = SGFDatabase(self.boardsize, self.progBar)
            try:
                newDB.process(sgfpath, datap, thisAlgos, filenames, messages,
                              sloppySGF, duplicateCheck, strictDuplicateCheck, self)
            except IOError: # FIXME
                messages.insert('end', 'Error: A fatal error occurred when processing ' + sgfpath + '.\n')
                failed.append(i)
                continue
            try:
                file = open(os.path.join(datap[0], 'namelist'+datap[1]+'.db'))
                file.close()
            except:
                self.reset()
                failed.append(i)
                continue
            
            self.DBlist[`self.boardsize`][i:i] = [newDB]

        self.reset()
        return failed


    def loadDB(self, sgfpath, datapath, boardsize, disabled=0, sortList=0, insertWhere=-1):
        newDB = SGFDatabase(boardsize, self.progBar)
        if boardsize == self.boardsize:
            success = newDB.loadDB(sgfpath, datapath, disabled)
            if success != 1: return success
        else:
            newDB.sgfpath = sgfpath
            newDB.datapath = datapath
            newDB.disabled = disabled
        if insertWhere == -1: self.DBlist[`boardsize`].append(newDB)
        else: self.DBlist[`boardsize`][insertWhere:insertWhere] = [newDB]

        self.updateGameIndex(sortList)
        return 1

    # --- searching -----------------------------------------------------------------

    def search(self, pattern, options={}, sortLabelsByFrequency=0,
               continuations={}, contLabels = None):


        if options.has_key('nextmove'): nextMoveVar = options['nextmove']
        else: nextMoveVar = 0
        if options.has_key('fixedcolor'): fixedColorVar = options['fixedcolor']
        else: fixedColorVar = 0

        print nextMoveVar
        patternList = PatternList(pattern, fixedColorVar, nextMoveVar)

        if contLabels is None:
            contLabels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L' ,'M' ,'N',
                          'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'Y', 'Z', 'a', 'b', 'c', 'd',
                          'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
                          's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2', '3', '4', '5', '6',
                          '7', '8', '9']
        contLabelsIndex = 0

        numOfHits, Bwins, Wwins, numSwitched = 0, 0, 0, 0

        startTime = time.time()
        numOfGames = self.numOfGames()
        doneSoFar = 0
        
        for db in self.DBlist[`self.boardsize`]:
            if db.disabled or len(db.current)==0: continue
            progStart = doneSoFar
            progSpan = len(db.current)*1.0/numOfGames
            progFirstInt = 0.3
            doneSoFar += progSpan

            a0 = Algo_hash_full_corners(self.boardsize)
            if not a0.search(patternList, options, db, self.progBar,
                             progStart, progStart+progFirstInt*progSpan):
                progFirstInt = 0.5
                a1 = Algo_finalpos(self.boardsize)
                a1.search(patternList, options, db, self.progBar,
                          progStart, progStart+progFirstInt*progSpan)

            intervals = 0

            # if numOfStones in pattern is large (in proportion to pattern size), use intervals
            # this is probably in particular useful for central patterns
            # final tuning will have to be done with the C++ implementations

            if intervals: # FIXME: decide which algo to use for second stage here
                a2 = Algo_intervals(self.boardsize)
                nh, bw, ww, sw = a2.search(patternList, options, db,
                                           continuations, contLabelsIndex, contLabels,
                                           self.progBar, progStart+progFirstInt*progSpan,
                                           progStart+progSpan)

            else:
                a2 = Algo_movelist(self.boardsize)
                nh, bw, ww, sw = a2.search(patternList, options, db,
                                           continuations, contLabelsIndex, contLabels,
                                           self.progBar, progStart+progFirstInt*progSpan, progStart+progSpan)

            numOfHits += nh
            Bwins += bw
            Wwins += ww
            numSwitched += sw

        if sortLabelsByFrequency:
            contList = [ (continuations[k]['B']+continuations[k]['W'], k) for k in continuations.keys()
                         if continuations[k]['N'] != '?' ]
            contList.sort()
            contList.reverse()
            contLabelsIndex = 0
            t = []
            for dummy, k in contList:
                t.append(continuations[k]['N'])
                continuations[k]['N'] = contLabels[contLabelsIndex]
                contLabelsIndex += 1
            trans = maketrans(join(t, ''), join(contLabels[:contLabelsIndex], ''))
            for db in self.DBlist[`self.boardsize`]:
                s1 = join(db.results, '|%')
                s2 = translate(s1, trans)
                db.results = split(s2, '|%')

        self.updateGameIndex()
        if self.progBar: self.progBar.redraw(1.0)
        if self.progBar: self.progBar.write('%1.1f seconds' % (time.time() - startTime))

        return numOfHits, bw, ww, sw, continuations
    

    def doGISearch(self, pbVar, pwVar, pVar, evVar, frVar, toVar, awVar, refVar,
                   caseInsensitive):


        if not self.numOfGames(): return

        if caseInsensitive:
            pbVar = lower(pbVar)
            pwVar = lower(pwVar)
            pVar = lower(pVar)
            evVar = lower(evVar)
            awVar = lower(awVar)
        
        if frVar:
            if not (re.match('\d\d\d\d-\d\d-\d\d', frVar) or re.match('\d\d\d\d-\d\d', frVar) \
                    or re.match('\d\d\d\d', frVar)):
                frVar = ''

        if toVar:
            if re.match('\d\d\d\d-\d\d-\d\d', toVar) or re.match('\d\d\d\d-\d\d', toVar) or re.match('\d\d\d\d', toVar):
                toVar += 'Z'
            else:
                toVar = ''

        if not (pbVar or pwVar or pVar or evVar or frVar or toVar or awVar or refVar): return
        
        ctr = 0
        currentTime = time.time()

        oldfilename = ''

        for DBIndex in range(len(self.DBlist[`self.boardsize`])):
            db = self.DBlist[`self.boardsize`][DBIndex]
            
            index = 'start' # we can't do index = db.next() at the end of the loop, so we need this 
            
            while 1:
                if index != 'start': index = db.next()
                else: index = db.start()
                if index is None: break

                g = db.namelist[index]

                ctr = ctr + 1
                if ctr % 10 == 0:
                    if self.progBar: self.progBar.redraw(ctr*1.0/self.numOfGames())
                
                if caseInsensitive:
                    if pwVar and find(lower(g[2]), pwVar) == -1: continue
                    if pbVar and find(lower(g[1]), pbVar) == -1: continue
                    if pVar and find(lower(g[2]), pVar) == -1 \
                       and find(lower(g[1]), pVar) == -1: continue
                
                    if frVar or toVar:
                        date = g[5]
                    
                        if frVar and not date >= frVar: continue
                        if toVar and not date <= toVar: continue

                    if refVar and not self.references.has_key(g[4]): continue

                    if evVar or awVar:
                        filename, gameNumber = db.getFilename(index)

                        if not oldfilename == filename:
                            oldfilename = filename
                            try:
                                file = open(filename)
                                sgf = file.read()
                                file.close()
                            except IOError:
                                showwarning('IO Error', 'File not found: ' + filename)
                                continue
                            newfile = 1
                        else: newfile = 0
                        
                        if gameNumber == -1:         # no collection, so we get away without parsing the SGF file
                            sgf = lower(sgf)
                            if awVar and find(sgf, awVar) == -1: continue

                            ok = 1
                            for var,tag in [(evVar,'ev[')]:          # note that we have already lower'ed sgf!
                                if var:
                                    v_begin = find(sgf, tag)
                                    if v_begin == -1: ok = 0
                                    else:
                                        v_text = sgf[v_begin: find(sgf, ']', v_begin)]
                                        if find(v_text, var) == -1: ok = 0
                            if not ok: continue

                        else:
                            if newfile:
                                try:
                                    c = Cursor(sgf, 1)
                                except:
                                    showwarning('Error', 'SGF error in file ' + filename)
                                    continue
                            node = c.getRootNode(gameNumber)

                            ok = 1
                            for var,tag in [(evVar,'EV')]:
                                if var and not (node.has_key(tag) and find(lower(node[tag][0]), var) != -1):
                                    ok = 0
                            if not ok: continue

                            if awVar:
                                c.game(gameNumber)
                                s = lower(c.outputVar(c.currentN))
                                if find(s, awVar) == -1: continue
                else:        
                    if pwVar and find(g[2], pwVar) == -1: continue
                    if pbVar and find(g[1], pbVar) == -1: continue
                    if pVar and find(g[2], pVar) == -1 \
                       and find(g[1], pVar) == -1: continue

                    if frVar or toVar:
                        date = g[5]
                    
                        if frVar and not date >= frVar: continue
                        if toVar and not date <= toVar: continue

                    if refVar and not self.references.has_key(g[4]): continue

                    if evVar or awVar:
                        filename, gameNumber = db.getFilename(index)

                        if not oldfilename == filename:
                            oldfilename = filename
                            try:
                                file = open(filename)
                                sgf = file.read()
                                file.close()
                            except IOError:
                                showwarning('IO Error', 'File not found: ' + filename)
                                continue
                            newfile = 1
                        else:
                            newfile = 0
                            
                        if gameNumber == -1:   

                            if awVar and find(sgf, awVar) == -1: continue

                            ok = 1
                            for var,tag in [(evVar,'EV[')]:
                                if var:
                                    v_begin = find(sgf, tag)
                                    if v_begin == -1: ok = 0
                                    else:
                                        v_text = sgf[v_begin: find(sgf, ']', v_begin)]
                                        if find(v_text, var) == -1: ok = 0
                            if not ok: continue

                        else:
                            if newfile:
                                try: c = Cursor(sgf, 1)
                                except:
                                    showwarning('Error', 'SGF error in file ' + filename)
                                    continue
                                
                            node = c.getRootNode(gameNumber)
                            
                            ok = 1
                            for var,tag in [(evVar,'EV')]:
                                if var and not (node.has_key(tag) and find(node[tag][0], var) != -1):
                                    ok = 0
                            if not ok: continue

                            if awVar:
                                c.game(gameNumber)
                                s = c.outputVar(c.currentN)
                                if find(s, awVar) == -1: continue
                                
                db.makeCurrentHit('')
                
        self.updateGameIndex()
  
        if self.progBar:
            self.progBar.redraw(1)
            self.progBar.write('%1.1f seconds' % (time.time() - currentTime))


    def doSigSearch(self, l):

        if not self.numOfGames(): return

        sig_list = []
        for f in Pattern.flips:                # we cannot use symmetrizeSig here because of the wildcards
            k1 = [ f(x[0], x[1]) for x in l] 
            k2 = []
            for i in range(6):
                if chr(l[i][0]+ord('a')) == '.': k2.append('..')
                else:
                    k2.append(chr(k1[i][0]+ord('a')))
                    k2.append(chr(k1[i][1]+ord('a')))

            s = join(k2, '')
            if not s in sig_list: sig_list.append(s)

        sp_list = [re.compile(s) for s in sig_list]

        ctr = 0
        if self.progBar: self.progBar.clear()
        currentTime = time.time()

        for db in self.DBlist[`self.boardsize`]:
            index = db.start()
            while not index is None:
                ctr = ctr + 1
                if ctr % 100 == 0:
                    if self.progBar: self.progBar.redraw(ctr*1.0/self.numOfGames())

                for sp in sp_list:
                    if sp.match(db.namelist[index][4]):
                        db.makeCurrentHit('')
                        break
                index = db.next()
                
        self.updateGameIndex()            
        if self.progBar:
            self.progBar.redraw(1)
            self.progBar.write('%1.1f seconds' % (time.time() - currentTime))