Fossil

  }
}

/*
** Flags for grep_buffer()
*/
#define GREP_EXISTS    0x001    /* If any match, print only the name and stop */
#define GREP_QUIET     0x002    /* Return code only */

/*
** Run a "grep" over a text file
*/
static int grep_buffer(
  ReCompiled *pRe,
  const char *zName,
  const char *z,
  u32 flags
){
  int i, j, n, ln, cnt;
  for(i=j=ln=cnt=0; z[i]; i=j+1){
    for(j=i; z[j] && z[j]!='\n'; j++){}
    n = j - i;
    ln++;
    if( re_match(pRe, (const unsigned char*)(z+i), j-i) ){
      cnt++;
      if( flags & GREP_EXISTS ){
        if( (flags & GREP_QUIET)==0 ) fossil_print("%S\n", zName);
        break;
      }
      if( (flags & GREP_QUIET)==0 ){
        fossil_print("%S:%d:%.*s\n", zName, ln, n, z+i);
      }
    }
  }
  return cnt;
}

/*
** COMMAND: test-grep

  }
  re_free(pRe);
}

/*
** COMMAND: grep
**
** Usage: %fossil grep [OPTIONS] PATTERN FILENAME ...
**
** Attempt to match the given POSIX extended regular expression PATTERN
** over all historic versions of FILENAME.  For details of the supported
** RE dialect, see https://fossil-scm.org/fossil/doc/trunk/www/grep.md
**
** Options:
**
**     -c|--count                 Suppress normal output; instead print a count
**                                of the number of matching files
**     -H|--checkin-hash          Show the check-in hash rather than
**                                file artifact hash for each match
**     -i|--ignore-case           Ignore case
**     -l|--files-with-matches    List only hash for each match
**     --once                     Stop searching after the first match
**     -s|--no-messages           Suppress error messages about nonexistant
**                                or unreadable files
**     -v|--invert-match          Invert the sense of matching.  Show only
**                                files that have no matches. Implies -l
**     --verbose                  Show each file as it is analyzed
*/
void re_grep_cmd(void){
  u32 flags = 0;
  int bVerbose = 0;
  ReCompiled *pRe;
  const char *zErr;
  int ignoreCase = 0;
  Blob fullName;
  int ckinHash = 0;
  int ii;
  int nMatch = 0;
  int bNoMsg;
  int cntFlag;
  int bOnce;
  int bInvert;
  int nSearch = 0;

  if( find_option("ignore-case","i",0)!=0 ) ignoreCase = 1;
  if( find_option("files-with-matches","l",0)!=0 ) flags |= GREP_EXISTS;
  if( find_option("verbose",0,0)!=0 ) bVerbose = 1;
  ckinHash = find_option("checkin-hash","H",0)!=0;
  if( find_option("quiet","q",0) ) flags |= GREP_QUIET|GREP_EXISTS;
  bNoMsg = find_option("no-messages","s",0)!=0;
  bOnce = find_option("once",0,0)!=0;
  bInvert = find_option("invert-match","v",0)!=0;
  if( bInvert ){
    flags |= GREP_QUIET|GREP_EXISTS;
  }
  cntFlag = find_option("count","c",0)!=0;
  if( cntFlag ){
    flags |= GREP_QUIET|GREP_EXISTS;
  }
  db_find_and_open_repository(0, 0);
  verify_all_options();
  if( g.argc<4 ){
    usage("REGEXP FILENAME ...");
  }
  zErr = re_compile(&pRe, g.argv[2], ignoreCase);
  if( zErr ) fossil_fatal("%s", zErr);

  add_content_sql_commands(g.db);
  for(ii=3; ii<g.argc; ii++){
    const char *zTarget = g.argv[ii];
    if( nMatch ){
      if( (flags & GREP_QUIET)!=0 ) break;
      if( bOnce ) break;
    }
    if( file_tree_name(zTarget, &fullName, 0, 1) ){
      int fnid = db_int(0, "SELECT fnid FROM filename WHERE name=%Q",
                        blob_str(&fullName));
      if( !fnid ){
        if( bNoMsg ) continue;
        if( file_size(zTarget, ExtFILE)<0 ){
          fossil_fatal("no such file: %s", zTarget);
        }
        fossil_fatal("not a managed file: %s", zTarget);
      }else{
        Stmt q;

        db_prepare(&q,
          "SELECT content(ux), %w FROM ("
          "  SELECT A.uuid AS ux, B.uuid AS ckin, min(event.mtime) AS mx"
          "    FROM mlink, blob A, blob B, event"
          "   WHERE mlink.mid=event.objid"
          "     AND mlink.fid=A.rid"
          "     AND mlink.mid=B.rid"
          "     AND mlink.fnid=%d"
          "   GROUP BY A.uuid"
          ") ORDER BY mx DESC;",
          ckinHash ? "ckin" : "ux",
          fnid
        );
        while( db_step(&q)==SQLITE_ROW ){
          const char *zHash = db_column_text(&q,1);
          const char *zContent = db_column_text(&q,0);
          if( bVerbose ) fossil_print("%S:\n", zHash);
          nSearch++;
          nMatch += grep_buffer(pRe, zHash, zContent, flags);
          if( bInvert && cntFlag==0 ){
            if( nMatch==0 ){
              fossil_print("%S\n", zHash);
              if( bOnce ) nMatch = 1;
            }else{
              nMatch = 0;
            }
          }
          if( nMatch ){
            if( (flags & GREP_QUIET)!=0 ) break;
            if( bOnce ) break;
          }
        }
        db_finalize(&q);
      }
    }
  }
  if( cntFlag ){
    if( bInvert ){
      fossil_print("%d\n", nSearch-nMatch);
    }else{
      fossil_print("%d\n", nMatch);
    }
  }
}