C++ pr_indent函数代码示例

void dump_leaf (
	tree_s	*tree,
	leaf_s	*leaf,
	unint	indent)
{
	rec_s	*end = &leaf->l_rec[leaf->l_num];
	rec_s	*r;
	char	*c;
	unsigned	i;
	//unsigned	j;

//FN;
	if (!leaf) return;

	pr_indent(indent);
	printf("leaf: num keys = %d end = %d total = %d current = %u\n",
			leaf->l_num, leaf->l_end, leaf->l_total,
			free_space(leaf));
	fflush(stdout);
	for (r = leaf->l_rec, i = 0; r < end; r++, i++) {
		c = (char *)leaf + r->r_start;
		pr_indent(indent);
		printf("\t%4d. %16llx %4d:%4d ",
			i, r->r_key, r->r_start, r->r_len);

		dump_rec(tree, r->r_key, c, r->r_len);

		printf("\n");
		fflush(stdout);
	}
	fflush(stdout);
}

static void pr_cosine(FILE *fp,int indent,const char *title,t_cosines *cos,
		      gmx_bool bMDPformat)
{
  int j;
  
  if (bMDPformat) {
    fprintf(fp,"%s = %d\n",title,cos->n);
  }
  else {
    indent=pr_title(fp,indent,title);
    (void) pr_indent(fp,indent);
    fprintf(fp,"n = %d\n",cos->n);
    if (cos->n > 0) {
      (void) pr_indent(fp,indent+2);
      fprintf(fp,"a =");
      for(j=0; (j<cos->n); j++)
	fprintf(fp," %e",cos->a[j]);
      fprintf(fp,"\n");
      (void) pr_indent(fp,indent+2);
      fprintf(fp,"phi =");
      for(j=0; (j<cos->n); j++)
	fprintf(fp," %e",cos->phi[j]);
      fprintf(fp,"\n");
    }
  }
}

void pr_header(FILE *fp,int indent,char *title,t_tpxheader *sh)
{
  if (available(fp,sh,title))
    {
      indent=pr_title(fp,indent,title);
      pr_indent(fp,indent);
      fprintf(fp,"bIr    = %spresent\n",sh->bIr?"":"not ");
      pr_indent(fp,indent);
      fprintf(fp,"bBox   = %spresent\n",sh->bBox?"":"not ");
      pr_indent(fp,indent);
      fprintf(fp,"bTop   = %spresent\n",sh->bTop?"":"not ");
      pr_indent(fp,indent);
      fprintf(fp,"bX     = %spresent\n",sh->bX?"":"not ");
      pr_indent(fp,indent);
      fprintf(fp,"bV     = %spresent\n",sh->bV?"":"not ");
      pr_indent(fp,indent);
      fprintf(fp,"bF     = %spresent\n",sh->bF?"":"not ");
      
      pr_indent(fp,indent);
      fprintf(fp,"natoms = %d\n",sh->natoms);
      pr_indent(fp,indent);
      fprintf(fp,"step   = %d\n",sh->step);
      pr_indent(fp,indent);
      fprintf(fp,"t      = %e\n",sh->t);
      pr_indent(fp,indent);
      fprintf(fp,"lambda = %e\n",sh->lambda);
    }
}

static void pr_groups(FILE *fp,int indent,const char *title,
                      gmx_groups_t *groups,
                      gmx_bool bShowNumbers)
{
    int grpnr[egcNR];
    int nat_max,i,g;

    pr_grps(fp,indent,"grp",groups->grps,groups->grpname,bShowNumbers);
    pr_strings(fp,indent,"grpname",groups->grpname,groups->ngrpname,bShowNumbers);

    (void) pr_indent(fp,indent);
    fprintf(fp,"groups          ");
    for(g=0; g<egcNR; g++)
    {
       printf(" %5.5s",gtypes[g]);
    }
    printf("\n");

    (void) pr_indent(fp,indent);
    fprintf(fp,"allocated       ");
    nat_max = 0;
    for(g=0; g<egcNR; g++)
    {
        printf(" %5d",groups->ngrpnr[g]);
        nat_max = max(nat_max,groups->ngrpnr[g]);
    }
    printf("\n");

    if (nat_max == 0)
    {
        (void) pr_indent(fp,indent);
        fprintf(fp,"groupnr[%5s] =","*");
        for(g=0; g<egcNR; g++)
        {
            fprintf(fp,"  %3d ",0);
        }
        fprintf(fp,"\n");
    }
    else
    {
        for(i=0; i<nat_max; i++)
        {
            (void) pr_indent(fp,indent);
            fprintf(fp,"groupnr[%5d] =",i);
            for(g=0; g<egcNR; g++)
            {
                fprintf(fp,"  %3d ",
                        groups->grpnr[g] ? groups->grpnr[g][i] : 0);
            }
            fprintf(fp,"\n");
        }
    }
}

static void pr_branch(struct mtree *mt, struct branch *branch, int indent)
{
	int i;
	struct twig *twig = branch->twig;

	pr_indent(indent);
	printf("branch: blknum=%lld seqnum=%lld num_twigs=%d\n",
		branch->blknum, branch->seqnum, branch->num_twigs);
	for (i = 0; i < branch->num_twigs; i++, twig++) {
		pr_indent(indent);
		printf("%d. %8lld: %8lld\n", i, twig->blknum, twig->key);
		pr_block(mt, twig->blknum, indent+1);
	}
}

static int pr_blocka_title(FILE *fp,int indent,const char *title,t_blocka *block)
{
  int i;

  if (available(fp,block,indent,title))
    {
      indent=pr_title(fp,indent,title);
      (void) pr_indent(fp,indent);
      (void) fprintf(fp,"nr=%d\n",block->nr);
      (void) pr_indent(fp,indent);
      (void) fprintf(fp,"nra=%d\n",block->nra);
    }
  return indent;
}

static void pr_leaf(struct leaf *leaf, int indent)
{
	int i;
	struct record *rec = (struct record *)leaf->data;

	pr_indent(indent);
	printf("leaf: blknum=%lld seqnum=%lld num_recs=%d end=%d\n",
		leaf->blknum, leaf->seqnum, leaf->num_recs, leaf->end);
	for (i = 0; i < leaf->num_recs; i++, rec++) {
		pr_indent(indent);
		printf("%8lld: %*s\n", rec->key, rec->size,
			(char *)(&leaf->data[rec->offset]));
	}
}

void pr_symtab(FILE *fp,int indent,char *title,t_symtab *symtab)
{
  int i,j,nr;
  t_symbuf *symbuf;
  
  if (available(fp,symtab,title))
    {
      indent=pr_title_n(fp,indent,title,symtab->nr);
      i=0;
      nr=symtab->nr;
      symbuf=symtab->symbuf;
      while (symbuf!=NULL)
        {
          for (j=0; (j < symbuf->bufsize) && (j < nr); j++)
            {
              if(fp)
              {
                  pr_indent(fp,indent);
                  fprintf(fp,"%s[%d]=\"%s\"\n",title,i++,symbuf->buf[j]);
              }
            }
          nr-=j;
          symbuf=symbuf->next;
        }
      assert(nr==0);
    }
}

void pr_int64(FILE *fp, int indent, const char *title, gmx_int64_t i)
{
    char buf[STEPSTRSIZE];

    pr_indent(fp, indent);
    fprintf(fp, "%-30s = %s\n", title, gmx_step_str(i, buf));
}

void list_xtc(const char *fn)
{
    t_fileio  *xd;
    int        indent;
    char       buf[256];
    rvec      *x;
    matrix     box;
    int        nframe, natoms, step;
    real       prec, time;
    gmx_bool   bOK;

    xd = open_xtc(fn, "r");
    read_first_xtc(xd, &natoms, &step, &time, box, &x, &prec, &bOK);

    nframe = 0;
    do
    {
        sprintf(buf, "%s frame %d", fn, nframe);
        indent = 0;
        indent = pr_title(stdout, indent, buf);
        pr_indent(stdout, indent);
        fprintf(stdout, "natoms=%10d  step=%10d  time=%12.7e  prec=%10g\n",
                natoms, step, time, prec);
        pr_rvecs(stdout, indent, "box", box, DIM);
        pr_rvecs(stdout, indent, "x", x, natoms);
        nframe++;
    }
    while (read_next_xtc(xd, natoms, &step, &time, box, x, &prec, &bOK));
    if (!bOK)
    {
        fprintf(stderr, "\nWARNING: Incomplete frame at time %g\n", time);
    }
    sfree(x);
    close_xtc(xd);
}

void pr_rvecs_of_dim(FILE *fp, int indent, const char *title, const rvec vec[], int n, int dim)
{
    const char *fshort = "%12.5e";
    const char *flong  = "%15.8e";
    const char *format;
    int         i, j;

    if (getenv("GMX_PRINT_LONGFORMAT") != nullptr)
    {
        format = flong;
    }
    else
    {
        format = fshort;
    }

    if (available(fp, vec, indent, title))
    {
        indent = pr_title_nxn(fp, indent, title, n, dim);
        for (i = 0; i < n; i++)
        {
            pr_indent(fp, indent);
            fprintf(fp, "%s[%5d]={", title, i);
            for (j = 0; j < dim; j++)
            {
                if (j != 0)
                {
                    fprintf(fp, ", ");
                }
                fprintf(fp, format, vec[i][j]);
            }
            fprintf(fp, "}\n");
        }
    }
}

void pr_rvecs(FILE *fp,int indent,const char *title,rvec vec[],int n)
{
  const char *fshort = "%12.5e";
  const char *flong  = "%15.8e";
  const char *format;
  int i,j;

  if (getenv("LONGFORMAT") != NULL)
    format = flong;
  else
    format = fshort;
    
  if (available(fp,vec,indent,title)) {  
    indent=pr_title_nxn(fp,indent,title,n,DIM);
    for (i=0; i<n; i++) {
      (void) pr_indent(fp,indent);
      (void) fprintf(fp,"%s[%5d]={",title,i);
      for (j=0; j<DIM; j++) {
	if (j != 0) 
	  (void) fprintf(fp,", ");
	(void) fprintf(fp,format,vec[i][j]);
      }
      (void) fprintf(fp,"}\n");
    }
  }
}

/*! \brief Callback used by list_tng_for_gmx_dump. */
static void list_tng_inner(const char *fn,
                           gmx_bool    bFirstFrame,
                           real       *values,
                           gmx_int64_t step,
                           double      frame_time,
                           gmx_int64_t n_values_per_frame,
                           gmx_int64_t n_atoms,
                           real        prec,
                           gmx_int64_t nframe,
                           char       *block_name)
{
    char                 buf[256];
    int                  indent = 0;

    if (bFirstFrame)
    {
        sprintf(buf, "%s frame %" GMX_PRId64, fn, nframe);
        indent = 0;
        indent = pr_title(stdout, indent, buf);
        pr_indent(stdout, indent);
        fprintf(stdout, "natoms=%10" GMX_PRId64 "  step=%10" GMX_PRId64 "  time=%12.7e",
                n_atoms, step, frame_time);
        if (prec > 0)
        {
            fprintf(stdout, "  prec=%10g", prec);
        }
        fprintf(stdout, "\n");
    }
    pr_reals_of_dim(stdout, indent, block_name, values, n_atoms, n_values_per_frame);
}

STATIC void node_dump(Linear_s *t, Blknum_t blknum, int indent)
{
	Buf_s	*buf;
	Node_s	*node;
	Blknum_t overflow;

	if (!blknum) return;
	buf = t_get(t, blknum);
	node = buf->d;
	Hrec_s	rec;
	unint	i;

	if (Dump_buf) {
		pr_buf(buf, indent);
	}
	pr_head(node, indent);
	for (i = 0; i < node->numrecs; i++) {
		rec = get_rec(node, i);
		pr_indent(indent);
		printf("%ld. ", i);
		rec_dump(rec);
	}
	overflow = node->overflow;
	buf_put(&buf);
	if (overflow) {
		node_dump(t, overflow, indent+1);
	}
}

static void pr_gmx_large_int(FILE *fp,int indent,const char *title,gmx_large_int_t i)
{
  char buf[STEPSTRSIZE];

  pr_indent(fp,indent);
  fprintf(fp,"%-20s = %s\n",title,gmx_step_str(i,buf));
}