C++ buffer_puts函数代码示例

int main (int argc, char const *const *argv)
{
  stralloc sa = STRALLOC_ZERO ;
  for (;;)
  {
    struct tm tm ;
    uint64 tt ;
    time_t t ;
    char *p ;
    int r ;
    char fmt[UINT64_FMT] ;
    sa.len = 0 ;
    r = skagetln(buffer_0, &sa, '\n') ;
    if (r < 0) strerr_diefu1sys(111, "read from stdin") ;
    if (!r) break ;
    sa.s[sa.len-1] = 0 ;
    if (!strptime(sa.s, "+%Y-%m-%d", &tm)) continue ;
    tm.tm_sec = 59 ;
    tm.tm_min = 59 ;
    tm.tm_hour = 23 ;
    t = mktime(&tm) ;
    if (t < 0) strerr_diefu1sys(111, "mktime") ;
    tt = t + 10 ;
    add_leapsecs(&tt) ;
    if (!genalloc_append(uint64, &table, &tt))
      strerr_diefu1sys(111, "genalloc_append") ;
    fmt[uint64_fmt(fmt, tt)] = 0 ;
    buffer_puts(buffer_1, "  TAI_MAGIC + ") ;
    buffer_puts(buffer_1, fmt) ;
    buffer_puts(buffer_1, ",\n") ;
  }
  buffer_unput(buffer_1, 2) ;
  buffer_putsflush(buffer_1, "\n") ;
  return 0 ;
}

static enum ud_tree_walk_stat
x_tag_list (struct udoc *ud, struct udr_ctx *render_ctx)
{
  const struct ud_node *n = render_ctx->uc_tree_ctx->utc_state->utc_node;
  struct udr_ctx rtmp = *render_ctx;

  if (x_tag_generic (ud, render_ctx, "ul", 0, TAG_NEWLINE) == UD_TREE_FAIL)
    return UD_TREE_FAIL;

  /* for each item in list, render list */
  for (;;) {
    if (n->un_type == UDOC_TYPE_LIST) {
      buffer_puts (&render_ctx->uc_out->uoc_buffer, "<li>");
      rtmp.uc_tree_ctx = 0;
      rtmp.uc_flag_finish_file = 0;
      if (!ud_render_node (ud, &rtmp, &n->un_data.un_list)) return UD_TREE_FAIL;
      buffer_puts (&render_ctx->uc_out->uoc_buffer, "</li>\n");
    }
    if (n->un_next) n = n->un_next; else break;
  }

  if (x_tag_end_generic (ud, render_ctx, "ul", 0, TAG_NEWLINE) == UD_TREE_FAIL)
    return UD_TREE_FAIL;

  return UD_TREE_STOP_LIST;
}

/* ----------------------------------------------------------------------- */
void vartab_dump(struct vartab *vartab) {
  unsigned int i;
  struct var *var;

/*          buffer_puts(fd_out->w, "44: ");
          buffer_putulong(fd_out->w, (long)(vartab->table[44]));
          buffer_putnlflush(fd_out->w);
          buffer_puts(fd_out->w, "46: ");
          buffer_putulong(fd_out->w, (long)(vartab->table[46]));
          buffer_putnlflush(fd_out->w);*/
  
  buffer_puts(fd_out->w, "address  name                     value                   nlen offs vlen lev buck lexhash          rndhash\n");
  buffer_puts(fd_out->w, "-------------------------------------------------------------------------------------------------------------------\n");
  
  if(vartab) {
    for(; vartab; vartab = vartab->parent) {
      buffer_puts(fd_out->w, "level: ");
      buffer_putulong(fd_out->w, vartab->level);
      buffer_puts(fd_out->w, "\n===================================================================================================================");
      buffer_putnlflush(fd_out->w);
        
      for(i = 0; i < (unsigned int)VARTAB_BUCKETS; i++) {
        for(var = vartab->table[i]; var; var = var->bnext) {
          var_dump(var);
        }
      }
    }
  } else {
    for(var = var_list; var; var = var->gnext)
      var_dump(var);
  }
}

static enum ud_tree_walk_stat
rt_tag_link_ext (struct udoc *ud, struct udr_ctx *rc)
{
    char cnum[FMT_ULONG];
    const struct ud_node *node = rc->uc_tree_ctx->utc_state->utc_node;
    struct ud_ref *ref;
    struct buffer *buf = &rc->uc_out->uoc_buffer;
    unsigned long index;
    unsigned long max;

    /* urls are numbered, so a linear search is necessary to work out the url id */
    /* XXX: this is not ideal... */
    max = ud_oht_size (&ud->ud_link_exts);
    for (index = 0; index < max; ++index) {
        ud_assert (ud_oht_get_index (&ud->ud_link_exts, index, (void *) &ref));
        if (node == ref->ur_node) {
            buffer_puts (buf, "\\from[url_");
            buffer_put (buf, cnum, fmt_ulong (cnum, index));
            buffer_puts (buf, "]");
            return 1;
        }
    }

    return 1;
}

int
sln(const char* path) {
  stralloc s, d;
  char* to;
  ssize_t i;
  stralloc_init(&s);
  stralloc_copys(&s, path);

  stralloc_init(&d);
  stralloc_copy(&d, &s);

  while(reduce(&d)) {

    buffer_puts(buffer_2, "'");
    buffer_putsa(buffer_2, &d);
    buffer_puts(buffer_2, "' -> '");
    buffer_putsa(buffer_2, &s);
    buffer_puts(buffer_2, "'\n");
    buffer_flush(buffer_2);

    stralloc_nul(&s);
    stralloc_nul(&d);

    if(mklink_sa(&s, &d) == -1) {
      errmsg_warnsys("symlink failed", NULL);
      exit(2);
    }
    stralloc_copy(&s, &d);
  }

  return 0;
}

void snap_dump(char *filename, stralloc *sa)
{
  dAVLCursor c;
  dAVLNode *node;
  char strip[IP6_FMT];
  char strnum[FMT_ULONG];
  int fd;

  fd = open_trunc("filename");  
  if(fd == -1)
    strerr_warn1(ARGV0 "warning: unable to open for tcp.tmp for writing", &strerr_sys);
  
  buffer_init(&wb, write, fd, wbspace, sizeof wbspace);

  node = dAVLFirst(&c, t);
  while(node)
    {
      buffer_put(&wb, strnum, fmt_ulong(strnum, node->key));
      buffer_puts(&wb, ",");
      buffer_put(&wb, strip, ip4_fmt(strip, node->ip4));
      buffer_puts(&wb, ",");
      buffer_put(&wb, strip, ip6_fmt(strip, node->ip6));
      buffer_puts(&wb, ",LOC\n");
      
      node = dAVLNext(&c);
    }
 
  buffer_flush(&wb);
  close(fd);
}

int main(int argc,char **argv)
{
    int i;

    dns_random_init(seed);

    if (*argv) ++argv;

    while (*argv) {
        if (!stralloc_copys(&fqdn,*argv))
            strerr_die2x(111,FATAL,"out of memory");
        if (dns_ip4(&out,&fqdn) == -1)
            strerr_die4sys(111,FATAL,"unable to find IP address for ",*argv,": ");

        for (i = 0; i + 4 <= out.len; i += 4) {
            buffer_put(buffer_1,str,ip4_fmt(str,out.s + i));
            buffer_puts(buffer_1," ");
        }
        buffer_puts(buffer_1,"\n");

        ++argv;
    }

    buffer_flush(buffer_1);
    _exit(0);
}

static enum ud_tree_walk_stat
rt_tag_list (struct udoc *ud, struct udr_ctx *rc)
{
    struct udr_ctx rtmp = *rc;
    const struct ud_node *n = rc->uc_tree_ctx->utc_state->utc_node;
    struct buffer *buf = &rc->uc_out->uoc_buffer;

    buffer_puts (buf, "\\startitemize\n");

    /* for each item in list, render list */
    for (;;) {
        if (n->un_type == UDOC_TYPE_LIST) {
            buffer_puts (buf, "\\item ");

            rtmp.uc_tree_ctx = 0;
            rtmp.uc_flag_finish_file = 0;
            if (!ud_render_node (ud, &rtmp, &n->un_data.un_list)) return UD_TREE_FAIL;

            buffer_puts (buf, "\n");
        }
        if (n->un_next) n = n->un_next;
        else break;
    }

    buffer_puts (buf, "\\stopitemize\n");
    return UD_TREE_STOP_LIST;
}

static void carp(const char* routine) {
  buffer_flush(buffer_1);
  buffer_puts(buffer_2,"httpbench: ");
  buffer_puts(buffer_2,routine);
  buffer_puts(buffer_2,": ");
  buffer_puterror(buffer_2);
  buffer_putnlflush(buffer_2);
}

/* source msg
 * ----------------------------------------------------------------------- */
void source_msg(void) {
  if(fdtable[STDSRC_FILENO]->name) {
    buffer_puts(fd_err->w, fdtable[STDSRC_FILENO]->name);
    buffer_puts(fd_err->w, ":");
    buffer_putulong(fd_err->w, source->line);
    buffer_puts(fd_err->w, ": ");
  }
}

static enum ud_tree_walk_stat
rt_tag_end_para_verbatim (struct udoc *ud, struct udr_ctx *rc)
{
    struct buffer *buf = &rc->uc_out->uoc_buffer;
    buffer_puts (buf, "\n");
    rt_literal_end (rc);
    buffer_puts (buf, "\n");
    return UD_TREE_OK;
}

static void
x_html_xml (struct buffer *out, const char *encoding)
{
  if (!encoding) encoding = "utf-8";

  buffer_puts (out, "<?xml version=\"1.0\" encoding=\"");
  buffer_puts (out, encoding);
  buffer_puts (out, "\"?>\n");
}

/* output message prefix ("argv[0]: ")
 * ----------------------------------------------------------------------- */
void sh_msg(char *s) {
  buffer_puts(fd_err->w, sh_name);
  buffer_puts(fd_err->w, ": ");
  
  if(source->mode & SOURCE_IACTIVE)
    source_msg();

  if(s)
    buffer_puts(fd_err->w, s);
}

static void showstatus(const char status[19], int r)
{
  const char *x;
  struct tai when;
  struct tai now;

  pid = (unsigned char) status[15];
  pid <<= 8; pid += (unsigned char) status[14];
  pid <<= 8; pid += (unsigned char) status[13];
  pid <<= 8; pid += (unsigned char) status[12];

  paused = status[16];
  want = status[17];
  statusflag = status[18];

  tai_unpack(status,&when);
  tai_now(&now);
  if (tai_less(&now,&when)) when = now;
  tai_sub(&when,&now,&when);

  if (pid) {
    buffer_puts(&b,"up (pid ");
    buffer_put(&b,strnum,fmt_ulong(strnum,pid));
    buffer_puts(&b,") ");
  }
  else
    buffer_puts(&b,"down ");

  buffer_put(&b,strnum,fmt_ulong(strnum,tai_approx(&when)));
  buffer_puts(&b," seconds");

  if (pid && !normallyup)
    buffer_puts(&b,", normally down");
  if (!pid && normallyup)
    buffer_puts(&b,", normally up");
  if (pid && paused)
    buffer_puts(&b,", paused");
  if (!pid && (want == 'u'))
    buffer_puts(&b,", want up");
  if (pid && (want == 'd'))
    buffer_puts(&b,", want down");
  if (r > 18) {
    switch (statusflag) {
    case svstatus_stopped: x = ", stopped"; break;
    case svstatus_starting: x = ", starting"; break;
    case svstatus_started: x = ", started"; break;
    case svstatus_running: x = ", running"; break;
    case svstatus_stopping: x = ", stopping"; break;
    case svstatus_failed: x=", failed"; break;
    default: x = ", status unknown";
    }
    if (x)
      buffer_puts(&b,x);
  }
}

int write_fifodir(char *dirname, stralloc *sa, void (*oaw_func)(char *, stralloc *))
{
  DIR *dir = NULL;
  stralloc name = {0};
  struct dirent *x = NULL;
  static struct stat st;

  /* read directory */
  dir = opendir(dirname);
  if(dir == NULL)
    {
      strerr_warn3("can't opendir() ", dirname, ": ", &strerr_sys);
      return -1;
    }

  while (x = readdir(dir))
    {
      if(x == NULL)
	{
	  strerr_warn3("can't readdir() ", dirname, ": ", &strerr_sys);
	  if(name.a) 
	    stralloc_free(&name);
	  return -1;
	}

      /* Ignore everything starting with a . */
      if(x->d_name[0] != '.')
	{ 
	  stralloc_copys(&name, dirname);
	  stralloc_cats(&name, "/");
	  stralloc_cats(&name, x->d_name);
	  stralloc_0(&name);

	  if(stat(name.s, &st) == -1)
	    {
	      strerr_warn2("can't stat ", name.s, &strerr_sys);
	    }

	  if(S_ISFIFO(st.st_mode))
	    {
	      oaw_func(name.s, sa);
	    }
	  else
	    {
	      buffer_puts(buffer_2, "ddnsd: warning: ");
	      buffer_puts(buffer_2, name.s);
	      buffer_puts(buffer_2, " is no fifo, ignoring\n");
	      buffer_flush(buffer_2);
	    }
	}
    }
  closedir(dir);  

  return 0;
}