C++ Snprintf函数代码示例

 void OptionsList::PrintUserOptions(std::string& list) const
 {
   list.erase();
   char buffer[256];
   Snprintf(buffer, 255, "%40s   %-20s %s\n", "Name", "Value", "used");
   list += buffer;
   for (std::map< std::string, OptionValue >::const_iterator p = options_.begin();
        p != options_.end();
        p++ ) {
     if (!p->second.DontPrint()) {
       const char yes[] = "yes";
       const char no[] = "no";
       const char* used;
       if (p->second.Counter()>0) {
         used = yes;
       }
       else {
         used = no;
       }
       Snprintf(buffer, 255, "%40s = %-20s %4s\n", p->first.c_str(),
                p->second.Value().c_str(), used);
       list += buffer;
     }
   }
 }

/*
 * Math library extensions to AG_Label(3).
 */
static void
PrintReal(AG_Label *lbl, char *s, size_t len, int fPos)
{
	M_Real r = AG_LABEL_ARG(lbl,M_Real);
#if defined(QUAD_PRECISION)
	Snprintf(s, len, "%llf", r);
#else
	Snprintf(s, len, "%f", r);
#endif
}

static char *make_nonce(const struct timeval *tv)
{
    char *buf = NULL;
    size_t size = 0, offset = 0;
    MD5_CTX md5;
    unsigned char hashbuf[MD5_DIGEST_LENGTH];
    char hash_hex[MD5_DIGEST_LENGTH * 2 + 1];
    char time_buf[32];

    /* Crash if someone forgot to call http_digest_init_secret. */
    if (!secret_initialized)
        bye("Server secret not initialized for Digest authentication. Call http_digest_init_secret.");

    Snprintf(time_buf, sizeof(time_buf), "%lu.%06lu",
        (long unsigned) tv->tv_sec, (long unsigned) tv->tv_usec);

    MD5_Init(&md5);
    MD5_Update(&md5, secret, sizeof(secret));
    MD5_Update(&md5, ":", 1);
    MD5_Update(&md5, time_buf, strlen(time_buf));
    MD5_Final(hashbuf, &md5);
    enhex(hash_hex, hashbuf, sizeof(hashbuf));

    strbuf_sprintf(&buf, &size, &offset, "%s-%s", time_buf, hash_hex);

    return buf;
}

 void CompoundVector::PrintImpl(const Journalist& jnlst,
                                EJournalLevel level,
                                EJournalCategory category,
                                const std::string& name,
                                Index indent,
                                const std::string& prefix) const
 {
   DBG_START_METH("CompoundVector::PrintImpl", dbg_verbosity);
   jnlst.Printf(level, category, "\n");
   jnlst.PrintfIndented(level, category, indent,
                        "%sCompoundVector \"%s\" with %d components:\n",
                        prefix.c_str(), name.c_str(), NComps());
   for (Index i=0; i<NComps(); i++) {
     jnlst.Printf(level, category, "\n");
     jnlst.PrintfIndented(level, category, indent,
                          "%sComponent %d:\n", prefix.c_str(), i+1);
     if (ConstComp(i)) {
       DBG_ASSERT(name.size()<200);
       char buffer[256];
       Snprintf(buffer, 255, "%s[%2d]", name.c_str(), i);
       std::string term_name = buffer;
       ConstComp(i)->Print(&jnlst, level, category, term_name,
                           indent+1, prefix);
     }
     else {
       jnlst.PrintfIndented(level, category, indent,
                            "%sComponent %d is not yet set!\n",
                            prefix.c_str(), i+1);
     }
   }
 }

  void MultiVectorMatrix::PrintImpl(const Journalist& jnlst,
                                    EJournalLevel level,
                                    EJournalCategory category,
                                    const std::string& name,
                                    Index indent,
                                    const std::string& prefix) const
  {
    jnlst.Printf(level, category, "\n");
    jnlst.PrintfIndented(level, category, indent,
                         "%sMultiVectorMatrix \"%s\" with %d columns:\n",
                         prefix.c_str(), name.c_str(), NCols());

    for (Index i=0; i<NCols(); i++) {
      if (ConstVec(i)) {
        DBG_ASSERT(name.size()<200);
        char buffer[256];
        Snprintf(buffer, 255, "%s[%2d]", name.c_str(), i);
        std::string term_name = buffer;
        ConstVec(i)->Print(&jnlst, level, category, term_name,
                           indent+1, prefix);
      }
      else {
        jnlst.PrintfIndented(level, category, indent,
                             "%sVector in column %d is not yet set!\n",
                             prefix.c_str(), i);
      }
    }
  }

/* Internal helper for resolve and resolve_numeric. addl_flags is ored into
   hints.ai_flags, so you can add AI_NUMERICHOST. */
static int resolve_internal(const char *hostname, unsigned short port,
    struct sockaddr_storage *ss, size_t *sslen, int af, int addl_flags)
{
    struct addrinfo hints;
    struct addrinfo *result;
    char portbuf[16];
    int rc;

    ncat_assert(hostname != NULL);
    ncat_assert(ss != NULL);
    ncat_assert(sslen != NULL);

    memset(&hints, 0, sizeof(hints));
    hints.ai_family = af;
    hints.ai_socktype = SOCK_DGRAM;
    hints.ai_flags |= addl_flags;

    /* Make the port number a string to give to getaddrinfo. */
    rc = Snprintf(portbuf, sizeof(portbuf), "%hu", port);
    ncat_assert(rc >= 0 && (size_t) rc < sizeof(portbuf));

    rc = getaddrinfo(hostname, portbuf, &hints, &result);
    if (rc != 0)
        return rc;
    if (result == NULL)
        return EAI_NONAME;
    ncat_assert(result->ai_addrlen > 0 && result->ai_addrlen <= (int) sizeof(struct sockaddr_storage));
    *sslen = result->ai_addrlen;
    memcpy(ss, result->ai_addr, *sslen);
    freeaddrinfo(result);

    return 0;
}

static void
SelectUnicodeRange(AG_Event *event)
{
	char text[4][128];
	AG_Treetbl *tt = AG_PTR(1);
	AG_TlistItem *it = AG_PTR(2);
	struct unicode_range *range = it->p1;
	const struct unicode_range *next_range = NULL;
	Uint32 i, end;
	char *c;

	for (i = 0; i < unicodeRangeCount; i++) {
		if ((&unicodeRanges[i] == range) &&
		    (i+1 < unicodeRangeCount)) {
			next_range = &unicodeRanges[i+1];
			break;
		}
	}
	end = (next_range != NULL) ? next_range->start-1 : 0xffff;

	AG_TreetblClearRows(tt);
	
	for (i = range->start; i < end; i++) {
		if (i == 10)
			continue;
        
		/* prep column 0 */
		unitext[0] = i;
		AG_ExportUnicode(AG_UNICODE_TO_UTF8, utf8text, unitext,
		    sizeof(unitext));
		Snprintf(text[0], sizeof(text[0]), "%s", utf8text);
        
		/* prep column 1 */
		utf8seq[0] = '\0';
		for (c = &utf8text[0]; *c != '\0'; c++) {
			char s[4];
            
			Snprintf(s, sizeof(s), "%x", (unsigned char)*c);
			Strlcat(utf8seq, s, sizeof(utf8seq));
		}
		Snprintf(text[1], sizeof(text[1]), "%s", utf8seq);
        
		AG_TreetblAddRow(tt, NULL, i, "%s,%s", text[0], text[1]);
	}
}

/* Format a number using the unit most suited to its magnitude. */
int
AG_UnitFormat(double n, const AG_Unit ugroup[], char *buf, size_t len)
{
	const AG_Unit *ubest;

	ubest = AG_BestUnit(ugroup, n);
	return (Snprintf(buf, len, "%.2f%s", AG_Base2Unit(n, ubest),
	    ubest->abbr[0] != '\0' ? ubest->abbr : ubest->key));
}

/* n is the size of src. dest must have at least n * 2 + 1 allocated bytes. */
static char *enhex(char *dest, const unsigned char *src, size_t n)
{
    unsigned int i;

    for (i = 0; i < n; i++)
        Snprintf(dest + i * 2, 3, "%02x", src[i]);

    return dest;
}

char *nsock_pcap_set_filter(pcap_t *pt, const char *device, const char *bpf) {
  struct bpf_program fcode;
  static char errorbuf[128];

  /* log_write(LOG_STDOUT, "Packet capture filter (device %s): %s\n", device, buf); */

  if (pcap_compile(pt, &fcode, (char*)bpf, 1, 0) < 0) {
    Snprintf(errorbuf, sizeof(errorbuf), "Error compiling our pcap filter: %s\n", pcap_geterr(pt));
    return errorbuf;
  }

  if (pcap_setfilter(pt, &fcode) < 0 ) {
    Snprintf(errorbuf, sizeof(errorbuf),"Failed to set the pcap filter: %s\n", pcap_geterr(pt));
    return errorbuf;
  }

  pcap_freecode(&fcode);
  return NULL;
}

static int chat_announce_disconnect(int fd)
{
    char buf[128];
    int n;

    n = Snprintf(buf, sizeof(buf),
        "<announce> <user%d> is disconnected.\n", fd);
    if (n >= sizeof(buf) || n < 0)
        return -1;

    return ncat_broadcast(&master_broadcastfds, &broadcast_fdlist, buf, n);
}

void init_iuctl() {
    int fd = open(QUEUE_PATH, O_WRONLY | O_CREAT | O_TRUNC, UMASK);
    if(fd < 0) {
        perror(QUEUE_PATH);
    }
    self_pid = getpid();
    assert(self_pid > 0);
    char self_pid_str[24];
    int bytes = Snprintf(self_pid_str, sizeof(self_pid_str), "%lu", self_pid);
    Write(fd, self_pid_str, bytes);
    Close(fd);
    init_iuctl(true);
}

/*
 * This is stupid. But it's just a bit of fun.
 *
 * The file descriptor of the sender is prepended to the
 * message sent to clients, so you can distinguish
 * each other with a degree of sanity. This gives a
 * similar effect to an IRC session. But stupider.
 */
static char *chat_filter(char *buf, size_t size, int fd, int *nwritten)
{
    char *result = NULL;
    size_t n = 0;
    const char *p;
    int i;

    n = 32;
    result = (char *) safe_malloc(n);
    i = Snprintf(result, n, "<user%d> ", fd);

    /* Escape control characters. */
    for (p = buf; p - buf < size; p++) {
        char repl[32];
        int repl_len;

        if (isprint((int) (unsigned char) *p) || *p == '\r' || *p == '\n' || *p == '\t') {
            repl[0] = *p;
            repl_len = 1;
        } else {
            repl_len = Snprintf(repl, sizeof(repl), "\\%03o", (unsigned char) *p);
        }

        if (i + repl_len > n) {
            n = (i + repl_len) * 2;
            result = (char *) safe_realloc(result, n + 1);
        }
        memcpy(result + i, repl, repl_len);
        i += repl_len;
    }
    /* Trim to length. (Also does initial allocation when str is empty.) */
    result = (char *) safe_realloc(result, i + 1);
    result[i] = '\0';

    *nwritten = i;

    return result;
}

const char *gai_strerror(int errcode) {
  static char customerr[64];
  switch (errcode) {
  case EAI_FAMILY:
    return "ai_family not supported";
  case EAI_NODATA:
    return "no address associated with hostname";
  case EAI_NONAME:
    return "hostname nor servname provided, or not known";
  default:
    Snprintf(customerr, sizeof(customerr), "unknown error (%d)", errcode);
    return "unknown error.";
  }
  return NULL; /* unreached */
}

int setenv_portable(const char *name, const char *value)
{
    char *var;
    int ret;
    size_t len;
    len = strlen(name) + strlen(value) + 2; /* 1 for '\0', 1 for =. */
    var = (char *) safe_malloc(len);
    Snprintf(var, len, "%s=%s", name, value);
    /* _putenv was chosen over SetEnvironmentVariable because variables set
       with the latter seem to be invisible to getenv() calls and Lua uses
       these in the 'os' module. */
    ret = _putenv(var) == 0;
    free(var);
    return ret;
}