home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / gnushogi-1.1 / src / pattern.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-04-22  |  17.0 KB  |  731 lines
  1. /*
  2.  * pattern.c - C source for GNU SHOGI
  3.  *
  4.  * Copyright (c) 1993 Matthias Mutz
  5.  *
  6.  * GNU SHOGI is based on GNU CHESS
  7.  *
  8.  * Copyright (c) 1988,1989,1990 John Stanback
  9.  * Copyright (c) 1992 Free Software Foundation
  10.  *
  11.  * This file is part of GNU SHOGI.
  12.  *
  13.  * GNU Shogi is free software; you can redistribute it and/or modify
  14.  * it under the terms of the GNU General Public License as published by
  15.  * the Free Software Foundation.
  16.  *
  17.  * GNU Shogi is distributed in the hope that it will be useful,
  18.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20.  * GNU General Public License for more details.
  21.  *
  22.  * You should have received a copy of the GNU General Public License
  23.  * along with GNU Shogi; see the file COPYING.  If not, write to
  24.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  25.  */
  26.  
  27. #include "gnushogi.h"
  28.  
  29. #include "pattern.h"
  30.  
  31.  
  32. OpeningPattern *Patterns;
  33.  
  34. #ifdef NONDSP
  35. static long allocated_bytes;
  36. #endif
  37.  
  38.  
  39.  
  40. #define is_digit(c) ((c) >= '0' && (c) <= '9')
  41. #define is_alfa(c) ((c) >= 'a' && (c) <= 'z' || (c) >= 'A' && (c) <= 'Z')
  42.  
  43. #define eos(s) (*s == '\0' || *s == '\n')
  44.  
  45.  
  46. /* skip blanks and comments in brackets */
  47.  
  48. static void skipbb(char **s) 
  49.  { while (**s == ' ' || **s == '|' || **s == '[') { 
  50.      if ( **s == '[' ) 
  51.        while (**s != ']') (*s)++; 
  52.      (*s)++; 
  53.    } \
  54.  }  
  55.                         
  56. /* skip unsigned numbers */
  57.  
  58. static void skipi(char **s)
  59.  { 
  60.    while ( is_digit(**s) ) 
  61.      (*s)++;
  62.    skipbb(s);
  63.  }
  64.  
  65.  
  66. inline
  67. static
  68. short
  69. ScanPiece (char **s, small_short *side, small_short *piece, small_short *square)
  70. {
  71.   short isp, isw, c, r;
  72.   
  73.   /* determine promotion status */
  74.   if ( **s == '+' )
  75.     isp = true, (*s)++;
  76.   else
  77.     isp = false;
  78.   /* determine side and piece */
  79.   for (c = 0; c < NO_PIECES; c++)
  80.     if ((isw = (**s == pxx[c])) || **s == qxx[c])
  81.       {
  82.     *piece = isp ? promoted[c] : unpromoted[c];
  83.     *side  = isw;
  84.     (*s)++; 
  85.     break;
  86.       } 
  87.   if (c == NO_PIECES) 
  88.     return(1);
  89.   if ( **s == '*' )
  90.     {
  91.       /* piece is captured */ 
  92.       (*s)++;
  93.       *square = NO_SQUARES + *piece;
  94.     }
  95.   else
  96.     {        
  97.       /* determine column */
  98.       for (c = 0; c < NO_COLS; c++)
  99.         if (**s == cxx[c])
  100.           {
  101.         (*s)++; 
  102.         break;
  103.           }
  104.       if (c == NO_COLS) 
  105.         return(1);
  106.       /* determine row */
  107.       for (r = 0; r < NO_ROWS; r++)
  108.         if (**s == rxx[r])
  109.           {
  110.         (*s)++;
  111.         break;
  112.           }
  113.       if (r == NO_ROWS) return(1);
  114.       /* determine square */
  115.       *square = r*NO_COLS + c;
  116.     }
  117.   skipbb(s); 
  118.   return(0);
  119. }
  120.  
  121.  
  122. short
  123. string_to_board_color
  124.  (char *s)
  125.  
  126. {
  127.   skipbb(&s); 
  128.   while ( !eos(s))
  129.     { small_short side, piece, square;
  130.       if ( ScanPiece(&s, &side, &piece, &square) )
  131.     return(1);
  132.       else
  133.     {             
  134.       if ( square >= NO_SQUARES )
  135.         {
  136.           Captured[side][piece]++;
  137.         }
  138.       else
  139.         {
  140.           Pindex[square] = ++PieceCnt[side];                 
  141.           PieceList[side][Pindex[square]] = square;
  142.           color[square] = side;
  143.           board[square] = piece;
  144.         }
  145.     }
  146.     }
  147.   return(0); 
  148. }
  149.  
  150.  
  151. short
  152. string_to_patternfields
  153.  (char *s, PatternFields *patternfields)
  154.  
  155. {
  156.   patternfields->n = 0;
  157.   skipbb(&s); 
  158.   while ( !eos(s) )
  159.     { short c, r, isp, isw;
  160.       PatternField *field;
  161.       field = &patternfields->field[patternfields->n];
  162.       if ( ScanPiece(&s, &field->side, &field->piece, &field->square) )
  163.     return(1);
  164.       else
  165.     if (patternfields->n++ == MAX_PATTERN) 
  166.       return(1);
  167.     }
  168.   return(0); 
  169. }
  170.                            
  171.  
  172. char *patternfile = PATTERNFILE;
  173.                
  174.  
  175.  
  176. static
  177. short
  178. ScanSequencePattern (char *s, PatternSequence **sequence)
  179. {         
  180.     PatternSequence *pattern;
  181.     if ( *sequence = pattern = (PatternSequence *) malloc (sizeof(PatternSequence)) ) {
  182. #ifdef NONDSP
  183.       allocated_bytes += sizeof(PatternSequence);
  184. #endif
  185.       pattern->next_pattern = NULL;
  186.       pattern->reachedGameCnt[black] = MAXMOVES;  
  187.       pattern->reachedGameCnt[white] = MAXMOVES;  
  188.       pattern->n = 0;
  189.       skipbb(&s); /* skip blanks and comments */
  190.       while ( is_digit(*s) )
  191.         {                             
  192.       pattern->next[pattern->n] = atoi(s);
  193.           pattern->n++;
  194.       skipi(&s);
  195.         }
  196.       if ( string_to_patternfields(s,&pattern->patternfields) )
  197.         return(1);
  198.       else
  199.         return(0);
  200.     } else {
  201.       ShowMessage("cannot allocate pattern space...");
  202.       return(1);
  203.     }
  204. }
  205.                                        
  206.  
  207.  
  208. void
  209. GetOpeningPatterns ()
  210.  
  211. { 
  212.     FILE *fd;
  213.     char s[256];
  214.     OpeningPattern *p, *q;
  215.     short count = 0;
  216.  
  217. #ifdef NONDSP                                      
  218.     allocated_bytes = 0;
  219. #endif
  220.  
  221.     if ( (fd = fopen (patternfile, "r")) == NULL )
  222.     fd = fopen ("gnushogi.pattern", "r");       
  223.  
  224.     if ( fd != NULL )
  225.       {
  226.     PatternSequence **current_pattern = NULL; 
  227.     Patterns = p = q = NULL;
  228.     while ( fgets (s, 256, fd) != NULL )
  229.       {
  230.         if ( *s == '#' )
  231.           { /* comment, skip line */
  232.           } 
  233.         else if ( is_alfa(*s) )
  234.           {
  235.         if ( p = (OpeningPattern *) malloc (sizeof(OpeningPattern)) )
  236.           { char *pn, *ps;
  237. #ifdef NONDSP
  238.                   allocated_bytes += sizeof(OpeningPattern);
  239. #endif
  240.             if ( Patterns == NULL )
  241.               Patterns = q = p;
  242.             else
  243.               q = q->next = p;
  244.             p->next = NULL;
  245.             p->n = 0;
  246.             p->sequence = NULL;
  247.             current_pattern = &p->sequence;
  248.                     for (pn=p->name,ps=s; !eos(ps); pn++,ps++)
  249.             *pn = *ps;
  250.                     *pn = '\0';
  251.           }
  252.         else
  253.           {
  254.             ShowMessage("cannot allocate opening sequence space...");
  255.             exit(1);
  256.           }
  257.           }
  258.         else
  259.           {
  260.         if ( ScanSequencePattern(s,current_pattern) )
  261.           {
  262.             ShowMessage("error in pattern sequence...");
  263.             exit(1);
  264.           }
  265.         else
  266.           {  
  267.             current_pattern = &(*current_pattern)->next_pattern;
  268.             p->n++;
  269.             count++;
  270.           }
  271.           }
  272.       }
  273. #ifdef NONDSP
  274.     printf("Pattern used %d entries, %ld bytes allocated.\n",
  275.             count, allocated_bytes);
  276. #endif  
  277.     fclose(fd);
  278.       }
  279. #ifdef NONDSP
  280.     else
  281.       {     
  282.         printf("no pattern file '%s'",patternfile);
  283.       }      
  284. #endif
  285.  
  286. }
  287.                             
  288.  
  289.  
  290.  
  291. void
  292. ShowOpeningPatterns ()
  293.  
  294. { OpeningPattern *root = Patterns;
  295.   while (root != NULL)
  296.     { short i;
  297.       PatternSequence *sequence;
  298.       printf("Opening line: %s number of patterns %d\n",root->name,root->n);
  299.       for (i=0,sequence = root->sequence; sequence; i++,sequence = sequence->next_pattern)
  300.     { short j;
  301.       printf("%d successor patterns:",sequence->n);
  302.       for (j = 0; j < sequence->n; j++) {
  303.         printf(" %d",sequence->next[j]);
  304.       }
  305.       printf(" pattern %d:\n",i);
  306.           DisplayPattern(&sequence->patternfields);
  307.     }
  308.       root = root->next;
  309.     }
  310. }
  311.  
  312.  
  313.  
  314. short
  315. piece_to_pattern_distance 
  316.   (short side, short piece, short pside, PatternFields *pattern)
  317.  
  318. /*
  319.  * Determine the minimum number of moves from the current position
  320.  * to a specific pattern for a specific piece.
  321.  * Consider the "side" piece of the pattern.
  322.  * The pattern should match for "pside".
  323.  */
  324. {
  325.   short nP, P[4], nB, B[4]; /* at most 4 pieces of same kind */
  326.   short i, j, r, dd, occupied, mindd, c[4], d[4];
  327.   
  328.   /*
  329.    * If pside == white, a black piece in the pattern should match
  330.    * a white piece on board, and vice versa. Furthermore, if
  331.    * pside == white, reversed pattern should match board.
  332.    */
  333.  
  334.   /* special pawn handling */     
  335.  
  336.   if ( piece == pawn ) {
  337.     mindd = occupied = 0; 
  338.     for ( i = 0; i < pattern->n; i++ ) {
  339.       PatternField field = pattern->field[i];
  340.       if ( (field.side == side) && (field.piece == pawn) ) {
  341.     short t = field.square;
  342.         short pcol = column(t);                    
  343.     dd = CANNOT_REACH;
  344.         for ( j = 0; j <= PieceCnt[side ^ pside]; j++) {
  345.       short sq = (short)PieceList[side ^ pside][j];
  346.       if ( board[sq] == pawn ) {
  347.         if ( pside == white ) sq = NO_SQUARES - 1 - sq;
  348.             if ( column(sq) == pcol ) {
  349.           dd = piece_distance (side, pawn, sq, t);
  350. #ifdef TEST_PATTERN
  351.               printf("update %d pawn from %d to %d is %d\n", side, sq, t, dd);
  352. #endif                                       
  353.           if ( dd != CANNOT_REACH ) {
  354.         /* Increment distance if pattern field is occupied */
  355.         short psq, pc;
  356.               if ( pside == black ) {
  357.               psq = t;
  358.           pc = field.side;
  359.         } else {
  360.           psq = (NO_SQUARES - 1 - t);
  361.           pc = ~field.side;
  362.         }
  363.         if ( (color[psq] == pc) && (board[psq] != pawn) ) {
  364. #ifdef TEST_PATTERN
  365.                   printf("square %d is occupied\n", psq);
  366. #endif                                       
  367.           ++occupied;            
  368.         }
  369.           }
  370.               break;
  371.         } 
  372.       }
  373.         }
  374.         if ( dd == CANNOT_REACH )
  375.       return (CANNOT_REACH);
  376.     else
  377.       mindd += dd;
  378.       }
  379.     }
  380.     return (mindd + occupied);
  381.   }
  382.  
  383.   /* 
  384.    * Determine list of "side" "piece"s in pattern. 
  385.    */
  386.  
  387.   for ( occupied = nP = i = 0; i < pattern->n; i++ ) {
  388.         PatternField field = pattern->field[i];
  389.     if ( (field.side == side) && (field.piece == piece) ) {
  390.       short psq, pc;
  391.       P[nP] = field.square;
  392. #ifdef TEST_PATTERN
  393.           printf("pattern %d piece %d on square %d\n",side,piece,P[nP]);
  394. #endif
  395.       nP++;
  396.       /* Increment distance if pattern field is occupied */
  397.           if ( pside == black ) {
  398.         psq = field.square;
  399.             pc = field.side;
  400.           } else {
  401.         psq = (NO_SQUARES - 1 - field.square);
  402.         pc = field.side ^ 1;
  403.           }
  404.       if ( (color[psq] == pc) && (board[psq] != field.piece) ) {
  405. #ifdef TEST_PATTERN
  406.             printf("square %d is occupied\n", psq);
  407. #endif                                       
  408.         ++occupied;            
  409.       }
  410.     }
  411.   }
  412.  
  413.   if ( nP == 0 )
  414.     return (0);
  415.  
  416. #ifdef TEST_PATTERN
  417.   printf("finding in pattern %d pieces %d of side %d\n", nP, piece, side);
  418. #endif
  419.  
  420.   /* 
  421.    * Determine list of "side ^ pside" "piece"s on board. 
  422.    */
  423.  
  424.   for ( nB = 0, i = 0; i <= PieceCnt[side ^ pside]; i++ ) {
  425.     short sq = PieceList[side ^ pside][i];
  426.     if ( board[sq] == piece ) {
  427.       B[nB] = (pside == black) ? sq : (NO_SQUARES - 1 - sq);
  428. #ifdef TEST_PATTERN
  429.       printf("%d piece %d on square %d\n",side,piece,B[nB]);
  430. #endif
  431.       nB++;
  432.     }
  433.   }
  434.  
  435. #ifdef TEST_PATTERN
  436.   printf("found on board %d pieces %d of side %d\n", nB, piece, side);
  437. #endif
  438.  
  439.   if ( nP > nB ) {
  440.       return (CANNOT_REACH);
  441.   }
  442.  
  443.   /* Determine best assignment from board piece to pattern piece */
  444.  
  445.   r = 0; c[0] = -1; mindd = CANNOT_REACH;
  446.  
  447.   while ( (r >= 0) && (mindd != 0) ) {
  448.  
  449.     if ( ++c[r] == nB ) {
  450.     r--;
  451.     } else {
  452.     for ( i = 0; i < r; i++ )
  453.       if ( c[i] == c[r] )
  454.         break;
  455.     if ( i == r ) {
  456.       d[r] =  piece_distance (side, piece, B[c[r]], P[r]);
  457. #ifdef TEST_PATTERN
  458.           printf("update d[%d] from  %d to %d is %d\n", r, B[c[r]], P[r], d[r]);
  459. #endif
  460.       if ( d[r] == CANNOT_REACH ) {
  461.         /* r--; */
  462.       } else {
  463.         if ( ++r == nP ) {
  464.         for (dd = i = 0; i < nP; i++)
  465.           dd += d[i];
  466.         if ( (dd < mindd) || (mindd == CANNOT_REACH) ) {
  467.           mindd = dd;        
  468. #ifdef TEST_PATTERN
  469.                   printf("update min %d\n", mindd);
  470. #endif
  471.         }
  472.         r--;
  473.         } else
  474.         c[r] = -1;
  475.       }
  476.     }
  477.     }
  478.  
  479.   }
  480.                
  481.   if ( mindd == CANNOT_REACH )
  482.     return (CANNOT_REACH);
  483.   else
  484.     return (mindd + occupied);
  485.  
  486. }
  487.  
  488.  
  489. short
  490. pattern_distance (short pside, PatternFields *pattern)
  491.  
  492. /*
  493.  * Determine the minimum number of moves for the pieces from
  494.  * the current position to reach a pattern.
  495.  * The result is CANNOT_REACH, if there is no possible sequence
  496.  * of moves.
  497.  */
  498.  
  499. {
  500.    short side, piece, d, n;
  501.  
  502. #ifdef TEST_PATTERN
  503.    printf("\nchecking pattern for pside=%d\n\n",pside);
  504. #endif
  505.  
  506.    for ( n = side = 0; side <= 1 && n != CANNOT_REACH; side++ )
  507.      for ( piece = pawn; piece <= king; piece++ ) {
  508.     d = piece_to_pattern_distance (side, piece, pside, pattern);
  509.     if ( d == CANNOT_REACH) {
  510.       n = CANNOT_REACH; break;
  511.     } else
  512.       n += d;
  513.      }
  514.  
  515. #ifdef TEST_PATTERN
  516.    printf("\ndistance to pattern is %d\n\n",n);
  517. #endif
  518.  
  519.    return (n);
  520.     
  521. }
  522.  
  523.  
  524. short
  525. board_to_pattern_distance 
  526.   (short pside, OpeningPattern *opattern, short pmplty, short GameCnt)
  527.  
  528. /*
  529.  * Determine the maximal difference of the number of moves from the pattern 
  530.  * to the initial position and to the current position.
  531.  * Differences are weighted, i.e. the more closer a position is to a pattern
  532.  * the more valuable is a move towards the pattern.
  533.  * Patterns, which are at least "pmplty" halfmoves away, are not counted.
  534.  */
  535.  
  536. {
  537.    short d, dist, diff;
  538.    short maxdiff = 0;
  539.    PatternSequence *sequence;
  540.  
  541.    for ( sequence = opattern->sequence; sequence; sequence = sequence->next_pattern )
  542.      if ( ((d = sequence->distance[pside]) != CANNOT_REACH) && (pmplty > d) )
  543.        { 
  544.          if ( (dist = pattern_distance (pside, &sequence->patternfields)) != CANNOT_REACH )
  545.            { 
  546.          /* "dist" is the distance of the current board position to the pattern.
  547.           * "d - dist" is the difference between the current distance and the 
  548.           * initial distance. Compute "diff" as the weighted difference.
  549.           */
  550.          if ( (diff = (d - dist) * (pmplty - d)) > maxdiff )
  551.         maxdiff = diff;
  552.          /* A reached pattern should not be considered in the future (if GameCnt >= 0) */
  553.          if ( dist == 0 && GameCnt >= 0)
  554.         sequence->reachedGameCnt[pside] = GameCnt;
  555.            }
  556.        }
  557.       
  558.    return (maxdiff);
  559.     
  560. }
  561.  
  562.  
  563.  
  564. void
  565. DisplayPattern (PatternFields *pattern)
  566.  
  567. {
  568.   small_short pboard[NO_SQUARES], pcolor[NO_SQUARES];
  569.   short sq, i, r, c;
  570.  
  571.   for (sq = 0; sq < NO_SQUARES; sq++)
  572.     {
  573.       pboard[sq] = no_piece;
  574.       pcolor[sq] = neutral;
  575.     }
  576.  
  577.   for (i = 0; i < pattern->n; i++)
  578.     {
  579.       PatternField *field = &pattern->field[i];
  580.       pboard[field->square] = field->piece;
  581.       pcolor[field->square] = field->side; 
  582.     }
  583.  
  584.   for (r = NO_ROWS-1; r >= 0; r--)
  585.     {
  586.       for (c = 0; c < NO_COLS; c++)
  587.         {
  588.       sq = r*NO_COLS + c;
  589.       i = pboard[sq];
  590.       if ( i == no_piece )
  591.         printf(" -");
  592.       else
  593.         printf("%c%c",is_promoted[i]?'+':' ',pcolor[sq]?pxx[i]:qxx[i]);
  594.         }
  595.       printf("\n");
  596.     }
  597.  
  598.   printf("\n");
  599.  
  600. }                 
  601.  
  602.  
  603. static
  604. void
  605. RemoveReachable (short pside, OpeningPattern *p, short n)
  606. {
  607.   short i,j;
  608.   PatternSequence *sequence;
  609.  
  610.   /* Adjust to sequence pattern j */
  611.   for (i=0,sequence=p->sequence; i<n; i++)
  612.     sequence=sequence->next_pattern;
  613.  
  614.   /* do not perform visited link twice */
  615.   if ( sequence->visited )
  616.       return;
  617.   else
  618.       sequence->visited = true;
  619.  
  620.   /* Declare links unreachable */
  621.   for (j=0; j<sequence->n; j++)
  622.     RemoveReachable(pside,p,sequence->next[j]);
  623.  
  624.   /* Declare unreachable */
  625.   sequence->distance[pside] = CANNOT_REACH;
  626.  
  627. #ifdef DEBUG_PATTERN
  628.   printf("removing %d\n",n);
  629. #endif
  630.  
  631. }      
  632.  
  633.  
  634. OpeningPattern 
  635. *locate_opening_pattern(short pside, char *s, short GameCnt)
  636.  
  637. { 
  638.    OpeningPattern *p;
  639.    PatternSequence *sequence;
  640.    short i, j, removed;
  641. #ifdef DEBUG_PATTERN
  642.    short n = 0, m = 0;
  643. #endif    
  644.  
  645.   /* 
  646.    * Look for opening pattern name in the list of opening patterns.
  647.    */
  648.  
  649.    for ( p = Patterns; p != NULL; p = p->next )
  650.      {                    
  651.        if ( strcmp(s,p->name) == 0 )
  652.          break;
  653.      }
  654.  
  655.    if ( p == NULL )
  656.      return(NULL);     
  657.  
  658. #ifdef DEBUG_PATTERN                             
  659.    printf("%s uses opening line %s\n",ColorStr[pside],p->name);
  660. #endif
  661.  
  662.   /*
  663.    * Determine patterns which can be reached from the current
  664.    * board position. Only patterns which can be reached will be
  665.    * checked in the following search.
  666.    */
  667.  
  668.    for ( i=0,sequence=p->sequence; sequence; i++,sequence=sequence->next_pattern )
  669.      {
  670.        sequence->distance[pside] = pattern_distance(pside,&sequence->patternfields);
  671.        sequence->visited = false;
  672.        /* Actually reached patterns need not to be observed. */
  673.        if ( sequence->distance[pside] == 0 ) {
  674.      sequence->distance[pside] = CANNOT_REACH;
  675. #ifdef DEBUG_PATTERN
  676.          printf("pattern %d removed because reached\n",i);
  677. #endif
  678.        } else if ( GameCnt >= 0 && GameCnt >= sequence->reachedGameCnt[pside] ) {
  679.      sequence->distance[pside] = CANNOT_REACH; 
  680. #ifdef DEBUG_PATTERN
  681.          printf("pattern %d removed because reached at GameCnt %d below current %d\n",
  682.             i,sequence->reachedGameCnt[pside],GameCnt);
  683. #endif
  684.        }
  685.        if ( sequence->reachedGameCnt[pside] >= GameCnt )
  686.          sequence->reachedGameCnt[pside] = MAXMOVES;
  687.      }            
  688.   /*
  689.    * Remove reachable patterns from search, which are successors of
  690.    * reachable patterns. So, only the next pattern of a pattern sequence
  691.    * is observed. 
  692.    */                    
  693.  
  694.    for (sequence=p->sequence; sequence; sequence=sequence->next_pattern)
  695.      if ( sequence->distance[pside] != CANNOT_REACH ) {
  696.        for (j=0; j<sequence->n; j++) {
  697. #ifdef DEBUG_PATTERN
  698.          printf("removing successors for link %d\n",sequence->next[j]);
  699. #endif
  700.  
  701.          RemoveReachable(pside,p,sequence->next[j]);  
  702.        }
  703.      }
  704.  
  705.   /*
  706.    * Look, whether there is still a reachable pattern.
  707.    */
  708.  
  709.    for ( sequence=p->sequence; sequence; sequence=sequence->next_pattern )
  710.      if ( sequence->distance[pside] != CANNOT_REACH )
  711.        {
  712. #ifdef DEBUG_PATTERN
  713.          for (n=0,m=0,sequence=p->sequence; sequence; sequence=sequence->next_pattern,n++)
  714.             if ( sequence->distance[pside] != CANNOT_REACH )
  715.           m++;
  716.      printf("%d reachable %s patterns out of %d patterns\n",
  717.             m,ColorStr[pside],n);
  718. #endif
  719.          return(p);
  720.        }
  721.  
  722. #ifdef DEBUG_PATTERN
  723.    printf("all %s patterns out of %d patterns (%d reachable) removed\n",
  724.         ColorStr[pside],n,m);
  725. #endif
  726.  
  727.    return (NULL);
  728. }
  729.  
  730.  
  731.