/*
** Format help text for TTY display.
*/
static void help_to_text(const char *zHelp, Blob *pText, int bUsage){
  int i, x;
  char c;

  if( !bUsage && zHelp[0]=='>' ){
    blob_appendf(pText, "Usage:");



    zHelp++;
  }
  for(i=0; (c = zHelp[i])!=0; i++){
    if( c=='%' && strncmp(zHelp+i,"%fossil",7)==0 ){
      if( i>0 ) blob_append(pText, zHelp, i);
      blob_append(pText, "fossil", 6);
      zHelp += i+7;

  }
  @ </dl>
  blob_reset(&buf);
  style_finish_page();
}

/*


** Return true if p is the first line paste the end of



** the previous subcommand.
*/
static int is_subcommand_end(Blob *p, int bAbbrevSubcmd, ReCompiled *pRe){
  if( bAbbrevSubcmd ){
    int i;
    if( re_match(pRe, (unsigned char*)blob_buffer(p), blob_strlen(p)) ){



      return 0;
    }

    if( blob_size(p)<4 ) return 1;
    for(i=0; i<4 && blob_buffer(p)[i]==' '; i++){}
    return i<4;
  }else{
    return blob_buffer(p)[0]=='>';
  }
}

/*
** Input z[] is help text for zTopic.  If zTopic has sub-command zSub,
** then cut out all portions of the original help text that do not
** directly pertain to zSub and write the zSub-relevant parts into

  char *zQSub = re_quote(zSubtopic);
  char *zPattern;
  ReCompiled *pRe = 0;

  if( bAbbrevSubcmd ){
    zPattern = mprintf("   ([a-z]+ ?\\| ?)*%s\\b", zQSub);
  }else{
    zPattern = mprintf(">  ?fossil %s .*\\b%s\\b", zQTop, zQSub);
  }
  fossil_free(zQTop);
  fossil_free(zQSub);
  re_compile(&pRe, zPattern, 0);
  fossil_free(zPattern);
  blob_init(&in, z, -1);
  while( blob_line(&in, &line) ){
    if( re_match(pRe, (unsigned char*)blob_buffer(&line), blob_strlen(&line)) ){

      blob_appendb(pOut, &line);
      n++;
      while( blob_line(&in, &line)





          && !is_subcommand_end(&line,bAbbrevSubcmd,pRe)
      ){

        blob_appendb(pOut, &line);
        n++;


      }

      if( !bAbbrevSubcmd ) break;







    }
  }
  blob_reset(&line);
  re_free(pRe);
  if( n ){
    blob_trim(pOut);
    blob_reset(&in);

        blob_reset(&subsection);
      }
      blob_appendb(pOut, &line);
    }else if( len>7 && !fossil_isspace(zLine[0]) && bSubsectionSeen 
           && sqlite3_strlike("%options:%",blob_str(&line),0)==0 ){
      subsection = line;
    }else if( !bAbbrevSubcmd && len>9
           && (memcmp(zLine,"> fossil ",9)==0 || memcmp(zLine,">  fossil",9)) ){

      subsection = line;
      bSubsectionSeen = 1;
    }else if( bAbbrevSubcmd && len>5 && memcmp(zLine,"   ",3)==0
           && fossil_isalpha(zLine[3]) ){
      subsection = line;
      bSubsectionSeen = 1;
    }else if( len>1 && !fossil_isspace(zLine[0]) && bSubsectionSeen ){

@   --ssl-identity NAME     Set the SSL identity to NAME
@   --systemtrace           Trace calls to system()
@   -U|--user USER          Make the default user be USER
@   --utc                   Display times using UTC
@   --vfs NAME              Cause SQLite to use the NAME VFS
;

/*
** COMMAND: options
**
** Usage: %fossil options [COMMAND] [SUBCOMMAND]
**
** Show available command-line options
**
**    fossil options                  Show command-line options available
**                                    on all commands.
**
**    fossil options COMMAND          Show options available on COMMAND
**
**    fossil options COMMAND SUBCMD   Show options specific to SUBCMD
**
** See also: [[help]], [[usage]]
*/
void options_cmd(void){
  Blob s1, s2, out;
  const char *z;
  const char *zTopic;
  int bAbbrevSubcmd = 0;

  verify_all_options();
  if( g.argc>4 ){
    usage("[COMMAND] [SUBCOMMAND]");
  }
  blob_init(&s1, 0, 0);
  if( g.argc==2 ){
    fossil_print("%s", zOptions);
    return;
  }else{
    int rc;
    const char *zSubtopic = g.argc==4 ? g.argv[3] : 0;
    const CmdOrPage *pCmd = 0;
    zTopic = g.argv[2];
    rc = dispatch_name_search(zTopic, CMDFLAG_COMMAND|CMDFLAG_PREFIX, &pCmd);
    if( rc ){
      if( rc==1 ){
        fossil_print("unknown command: %s\n", zTopic);
      }else{
        fossil_print("ambiguous command prefix: %s\n", zTopic);
      }
      return;
    }
    z = pCmd->zHelp;
    if( z==0 ){
      fossil_fatal("no help available for the %s", pCmd->zName);
    }
    bAbbrevSubcmd = (pCmd->eCmdFlags & CMDFLAG_ABBREVSUBCMD)!=0;
    if( zSubtopic ){
      if( simplify_to_subtopic(z, &s1, zTopic, zSubtopic, bAbbrevSubcmd) ){
        z = blob_str(&s1);
      }else{
        fossil_print("No subcommand \"%s\" for \"%s\".\n", zSubtopic, zTopic);
      }
    }
  }
  blob_init(&s2, 0, 0);
  simplify_to_options(z, &s2, bAbbrevSubcmd, zTopic);
  blob_init(&out, 0, 0);
  help_to_text(blob_str(&s2), &out, 1);
  fossil_print("%s\n", blob_str(&out));
  blob_reset(&out);
  blob_reset(&s1);
  blob_reset(&s2);
}

/*
** COMMAND: usage
**
** Usage: %fossil usage COMMAND [SUBCOMMAND]
**
** Show succinct usage instructions for a Fossil command.
**
** See also:  [[help]], [[options]]
*/
void usage_cmd(void){
  int rc;
  const char *zTopic;
  const char *zSubtopic;
  const CmdOrPage *pCmd = 0;
  Blob s1, s2, out;
  const char *z;
  int bAbbrevSubcmd = 0;

  verify_all_options();
  if( g.argc<3 || g.argc>4 ){
    usage("COMMAND [SUBCOMMAND]");
  }
  zTopic = g.argv[2];
  zSubtopic = g.argc==4 ? g.argv[3] : 0;
  rc = dispatch_name_search(zTopic, CMDFLAG_COMMAND|CMDFLAG_PREFIX, &pCmd);
  if( rc ){
    int i, n;
    const char *az[5];
    if( rc==1 ){
      fossil_print("unknown command: %s\n", zTopic);
    }else{
      fossil_print("ambiguous command prefix: %s\n", zTopic);
    }
    fossil_print("Did you mean one of these TOPICs:\n");
    n = dispatch_approx_match(zTopic, 5, az);
    for(i=0; i<n; i++){
      fossil_print("  *  %s\n", az[i]);
    }
    return;
  }
  bAbbrevSubcmd = (pCmd->eCmdFlags & CMDFLAG_ABBREVSUBCMD)!=0;
  z = pCmd->zHelp;
  if( z==0 ){
    fossil_fatal("no help available for the %s", pCmd->zName);
  }
  blob_init(&s1, 0, 0);
  blob_init(&s2, 0, 0);
  if( zSubtopic!=0 ){
    if( simplify_to_subtopic(z, &s1, zTopic, zSubtopic, bAbbrevSubcmd) ){
      z = blob_str(&s1);
    }else{
      fossil_print("No subcommand \"%s\" for \"%s\".\n", zSubtopic, zTopic);
    }
  }
  if( simplify_to_usage(z, &s2, zTopic, bAbbrevSubcmd) ){
    z = blob_str(&s2);
  }
  blob_init(&out, 0, 0);
  help_to_text(z, &out, 1);
  fossil_print("%s\n", blob_str(&out));
  blob_reset(&out);
  blob_reset(&s1);
  blob_reset(&s2);
}

/*
** COMMAND: help
**
** Usage: %fossil help [OPTIONS] [TOPIC] [SUBCOMMAND]
**
** Display information on how to use TOPIC, which may be a command, webpage, or
** setting.  Webpage names begin with "/".  If TOPIC is omitted, a list of

      return;
    }
    z = g.argv[0];
    fossil_print(
      "Usage: %s help TOPIC\n"
      "Things to try:\n\n"
      "   %s help help\n"
      "   %s help options\n"
      "   %s help -a\n"
      "   %s search -h TOPIC\n\n"
      "Other common values for TOPIC:\n\n",
      z, z, z, z, z);
    command_list(CMDFLAG_1ST_TIER,verboseFlag,useHtml);
    if( !verboseFlag ) version_cmd();
    return;

  blob_init(&subtext1, 0, 0);
  blob_init(&subtext2, 0, 0);
  blob_init(&s3, 0, 0);
  if( zSubtopic!=0 ){
    if( simplify_to_subtopic(z, &subtext1, zTopic, zSubtopic, bAbbrevSubcmd) ){
      z = blob_str(&subtext1);
    }else{
      fossil_print("No subtopic \"%s\" for \"%s\".\n", zTopic, zSubtopic);
      if( strstr(z, "Usage:")!=0 || strstr(z, "\n>  ?fossil")!=0 ){
        bUsage = 1;
      }

    }
  }
  if( bUsage ){
    if( simplify_to_usage(z, &subtext2, zTopic, bAbbrevSubcmd) ){
      z = blob_str(&subtext2);
    }else{
      bUsage = 0;

  }
  blob_init(&txt, 0, 0);
  if( bRaw ){
    blob_append(&txt, z, -1);
  }else if( useHtml ){
    help_to_html(z, &txt);
  }else{
    help_to_text(z, &txt, bUsage);
  }
  if( blob_strlen(&txt)>0 ) fossil_print("%s\n", blob_str(&txt));
  blob_reset(&txt);
  blob_reset(&subtext1);
  blob_reset(&subtext2);
}

**   --rename-trunk NAME          Use NAME as name of exported trunk branch
**   -R|--repository REPO         Export the given REPOSITORY
**
** See also: import
*/
/*
** COMMAND: export*


**
** This command is deprecated.  Use "fossil git export" instead.
*/
void export_cmd(void){
  Stmt q, q2, q3;
  Bag blobs, vers;
  unsigned int unused_mark = 1;