自学教程：C++ util_snprintf函数代码示例

/** * /param fence  if non-null, returns pointer to a fence which can be waited on */voidllvmpipe_flush( struct pipe_context *pipe,                struct pipe_fence_handle **fence,                const char *reason){   struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);   draw_flush(llvmpipe->draw);   /* ask the setup module to flush */   lp_setup_flush(llvmpipe->setup, fence, reason);   /* Enable to dump BMPs of the color/depth buffers each frame */   if (0) {      static unsigned frame_no = 1;      char filename[256];      unsigned i;      for (i = 0; i < llvmpipe->framebuffer.nr_cbufs; i++) {         util_snprintf(filename, sizeof(filename), "cbuf%u_%u", i, frame_no);         debug_dump_surface_bmp(&llvmpipe->pipe, filename, llvmpipe->framebuffer.cbufs[i]);      }      if (0) {         util_snprintf(filename, sizeof(filename), "zsbuf_%u", frame_no);         debug_dump_surface_bmp(&llvmpipe->pipe, filename, llvmpipe->framebuffer.zsbuf);      }      ++frame_no;   }}

/* Sets "Link" header, if content manager is on */NSAPI_PUBLIC void CM_set_link_header(Request *rq){  char link[CM_BUFF_LEN];  char *uri;  if ( !CM_get_status() )  /* if cm is off. don't do anything */	return;    uri = pblock_findkeyval(pb_key_uri, rq->reqpb);  /* e.g. Link: <http://www.glyphica.com/index.html?services>; rel="services" */  if (pervs_vars()->Vsecurity_active) {	if (pervs_vars()->Vport == 443)	  util_snprintf(link, CM_BUFF_LEN, "<https://%s%s?%s>; rel=/"%s/"", 					pervs_vars()->Vserver_hostname, uri, CM_SERVICES_NS,CM_SERVICES_NS  );	else	  util_snprintf(link, CM_BUFF_LEN, "<https://%s:%d%s?%s>; rel=/"%s/"", 					pervs_vars()->Vserver_hostname, pervs_vars()->Vport, uri, CM_SERVICES_NS,CM_SERVICES_NS );  } else {	if (pervs_vars()->Vport == 80)	  util_snprintf( link, CM_BUFF_LEN, "<http://%s%s?%s>; rel=/"%s/"", 					 pervs_vars()->Vserver_hostname, uri, CM_SERVICES_NS,CM_SERVICES_NS );	else	  util_snprintf( link, CM_BUFF_LEN, "<http://%s:%d%s?%s>; rel=/"%s/"", 					 pervs_vars()->Vserver_hostname,  pervs_vars()->Vport, uri, CM_SERVICES_NS,CM_SERVICES_NS );  }  pblock_nvinsert("Link", link, rq->srvhdrs);  }

struct util_dl_library *pipe_loader_find_module(struct pipe_loader_device *dev,                        const char *library_paths){   struct util_dl_library *lib;   const char *next;   char path[PATH_MAX];   int len, ret;   for (next = library_paths; *next; library_paths = next + 1) {      next = util_strchrnul(library_paths, ':');      len = next - library_paths;      if (len)         ret = util_snprintf(path, sizeof(path), "%.*s/%s%s%s",                             len, library_paths,                             MODULE_PREFIX, dev->driver_name, UTIL_DL_EXT);      else         ret = util_snprintf(path, sizeof(path), "%s%s%s",                             MODULE_PREFIX, dev->driver_name, UTIL_DL_EXT);      if (ret > 0 && ret < sizeof(path)) {         lib = util_dl_open(path);         if (lib) {            return lib;         }      }   }   return NULL;}

static struct vg_shader * setup_lookup_single(struct vg_context *ctx, void *user_data){   char buffer[1024];   VGImageChannel channel = (VGImageChannel)(user_data);   struct vg_shader *shader;   switch(channel) {   case VG_RED:      util_snprintf(buffer, 1023, lookup_single_asm, "xxxx");      break;   case VG_GREEN:      util_snprintf(buffer, 1023, lookup_single_asm, "yyyy");      break;   case VG_BLUE:      util_snprintf(buffer, 1023, lookup_single_asm, "zzzz");      break;   case VG_ALPHA:      util_snprintf(buffer, 1023, lookup_single_asm, "wwww");      break;   default:      debug_assert(!"Unknown color channel");   }   shader = shader_create_from_text(ctx->pipe, buffer, 200,                                    PIPE_SHADER_FRAGMENT);   return shader;}

/* returns "Link" header, if content manager is on. Null otherwise */NSAPI_PUBLIC int CM_get_link_header(char *uri, char *link, int size ){  if ( !CM_get_status() )  /* if cm is off. don't do anything */	return 0;    /* e.g. Link: <http://www.glyphica.com/index.html?services>; rel ="services" */  if (pervs_vars()->Vsecurity_active) {	if (pervs_vars()->Vport == 443)	  util_snprintf(link, size, "Link: <https://%s%s?%s>; rel=/"%s/"", 					pervs_vars()->Vserver_hostname, uri, CM_SERVICES_NS,CM_SERVICES_NS  );	else	  util_snprintf(link, size, "Link: <https://%s:%d%s?%s>; rel=/"%s/"", 					pervs_vars()->Vserver_hostname, 			  pervs_vars()->Vport, uri, CM_SERVICES_NS,CM_SERVICES_NS  );  } else {	if (pervs_vars()->Vport == 80)	  util_snprintf( link, size, "Link: <http://%s%s?%s>; rel=/"%s/"", 					 pervs_vars()->Vserver_hostname, uri, CM_SERVICES_NS,CM_SERVICES_NS  );	else	  util_snprintf( link, size, "Link: <http://%s:%d%s?%s>; rel=/"%s/"", 					 pervs_vars()->Vserver_hostname, 			   pervs_vars()->Vport, uri, CM_SERVICES_NS,CM_SERVICES_NS  );  }  return 1;}

static voidinit_logging(struct pipe_screen *screen){   static const char *log_prefix = "Mesa: ";   char host_log[1000];   /* Log Version to Host */   util_snprintf(host_log, sizeof(host_log) - strlen(log_prefix),                 "%s%s", log_prefix, svga_get_name(screen));   svga_host_log(host_log);   util_snprintf(host_log, sizeof(host_log) - strlen(log_prefix),                 "%s%s"#ifdef MESA_GIT_SHA1                 " (" MESA_GIT_SHA1 ")"#endif                 , log_prefix, PACKAGE_VERSION);   svga_host_log(host_log);   /* If the SVGA_EXTRA_LOGGING env var is set, log the process's command    * line (program name and arguments).    */   if (debug_get_bool_option("SVGA_EXTRA_LOGGING", FALSE)) {      char cmdline[1000];      if (os_get_command_line(cmdline, sizeof(cmdline))) {         util_snprintf(host_log, sizeof(host_log) - strlen(log_prefix),                       "%s%s", log_prefix, cmdline);         svga_host_log(host_log);      }   }}

voidsoftpipe_flush( struct pipe_context *pipe,                unsigned flags,                struct pipe_fence_handle **fence ){   struct softpipe_context *softpipe = softpipe_context(pipe);   uint i;   draw_flush(softpipe->draw);   if (flags & SP_FLUSH_TEXTURE_CACHE) {      unsigned sh;      for (sh = 0; sh < Elements(softpipe->tex_cache); sh++) {         for (i = 0; i < softpipe->num_sampler_views[sh]; i++) {            sp_flush_tex_tile_cache(softpipe->tex_cache[sh][i]);         }      }   }   /* If this is a swapbuffers, just flush color buffers.    *    * The zbuffer changes are not discarded, but held in the cache    * in the hope that a later clear will wipe them out.    */   for (i = 0; i < softpipe->framebuffer.nr_cbufs; i++)      if (softpipe->cbuf_cache[i])         sp_flush_tile_cache(softpipe->cbuf_cache[i]);   if (softpipe->zsbuf_cache)      sp_flush_tile_cache(softpipe->zsbuf_cache);   softpipe->dirty_render_cache = FALSE;   /* Enable to dump BMPs of the color/depth buffers each frame */#if 0   if (flags & PIPE_FLUSH_END_OF_FRAME) {      static unsigned frame_no = 1;      static char filename[256];      util_snprintf(filename, sizeof(filename), "cbuf_%u.bmp", frame_no);      debug_dump_surface_bmp(pipe, filename, softpipe->framebuffer.cbufs[0]);      util_snprintf(filename, sizeof(filename), "zsbuf_%u.bmp", frame_no);      debug_dump_surface_bmp(pipe, filename, softpipe->framebuffer.zsbuf);      ++frame_no;   }#endif   if (fence)      *fence = (void*)(intptr_t)1;}

voidStatsVirtualServerNode::setInterfaces(const VirtualServer* vs){    interfaces.clear();    interfaces.ensureCapacity(128);    int nIndex = 0;    int nItfCount = vs->getHttpListenerNameCount();    // Calculate the length requirement for assignment    const Configuration* configuration =        ConfigurationManager::getConfiguration();    for (nIndex = 0; configuration && (nIndex < nItfCount); nIndex++)    {        const ListenSocketConfig* lsc;        lsc = configuration->getLsc(*vs->getHttpListenerName(nIndex));        if (lsc)        {            char iface[70] = "";            util_snprintf(iface, sizeof(iface), "%s:%d",                          lsc->ip.getStringValue(), lsc->port.getInt32Value());            interfaces.append(iface);            const char* spaceSeparater = " ";            if (nIndex != nItfCount - 1)            {                interfaces.append(" ");            }        }    }    if (configuration) configuration->unref();}

ast_expression *fold_constgen_string(fold_t *fold, const char *str, bool translate) {    hash_table_t *table = (translate) ? fold->imm_string_untranslate : fold->imm_string_dotranslate;    ast_value    *out   = NULL;    size_t        hash  = util_hthash(table, str);    if ((out = (ast_value*)util_htgeth(table, str, hash)))        return (ast_expression*)out;    if (translate) {        char name[32];        util_snprintf(name, sizeof(name), "dotranslate_%lu", (unsigned long)(fold->parser->translated++));        out                    = ast_value_new(parser_ctx(fold->parser), name, TYPE_STRING);        out->expression.flags |= AST_FLAG_INCLUDE_DEF; /* def needs to be included for translatables */    } else        out                    = ast_value_new(fold_ctx(fold), "#IMMEDIATE", TYPE_STRING);    out->cvq              = CV_CONST;    out->hasvalue         = true;    out->isimm            = true;    out->constval.vstring = parser_strdup(str);    vec_push(fold->imm_string, out);    util_htseth(table, str, hash, out);    return (ast_expression*)out;}

char *_add_table_event(EVENT_HANDLER *handler){	HANDLE event;	char *err;	EVENT_HANDLER *tmp;	if(!(event = CreateEvent(NULL, FALSE, FALSE, handler->event_name))) {		err = (char *)MALLOC(ERR_MSG_LEN);        util_snprintf(err, ERR_MSG_LEN, "could not open create event %s (%s)",             handler->event_name, system_errmsg());		TERMINATE_HANDLER_THREAD();        return err;	}	if (!events) {		events = (HANDLE *)MALLOC(sizeof(HANDLE));	} else {		events = (HANDLE *)REALLOC(events, (sizeof(events) + sizeof(HANDLE)));	}	events[event_number -1] = event;	if (!handler_table) {		handler_table = handler;	} else {		/* Prevent duplicate handlers from being entered */		for (tmp = handler_table; tmp; tmp = tmp->next) {			if (!strcmp(tmp->event_name, handler->event_name)) {				return NULL;			}		}		handler->next = handler_table;		handler_table = handler;	}    return NULL;}

static const char *fd_screen_get_name(struct pipe_screen *pscreen){	static char buffer[128];	util_snprintf(buffer, sizeof(buffer), "FD%03d",			fd_screen(pscreen)->device_id);	return buffer;}

static const char *nouveau_screen_get_name(struct pipe_screen *pscreen){	struct nouveau_device *dev = nouveau_screen(pscreen)->device;	static char buffer[128];	util_snprintf(buffer, sizeof(buffer), "NV%02X", dev->chipset);	return buffer;}

static const char *brw_get_name(struct pipe_screen *screen){   static char buffer[128];   const char *chipset;   switch (brw_screen(screen)->chipset.pci_id) {   case PCI_CHIP_I965_G:      chipset = "I965_G";      break;   case PCI_CHIP_I965_Q:      chipset = "I965_Q";      break;   case PCI_CHIP_I965_G_1:      chipset = "I965_G_1";      break;   case PCI_CHIP_I946_GZ:      chipset = "I946_GZ";      break;   case PCI_CHIP_I965_GM:      chipset = "I965_GM";      break;   case PCI_CHIP_I965_GME:      chipset = "I965_GME";      break;   case PCI_CHIP_GM45_GM:      chipset = "GM45_GM";      break;   case PCI_CHIP_IGD_E_G:      chipset = "IGD_E_G";      break;   case PCI_CHIP_Q45_G:      chipset = "Q45_G";      break;   case PCI_CHIP_G45_G:      chipset = "G45_G";      break;   case PCI_CHIP_G41_G:      chipset = "G41_G";      break;   case PCI_CHIP_B43_G:      chipset = "B43_G";      break;   case PCI_CHIP_ILD_G:      chipset = "ILD_G";      break;   case PCI_CHIP_ILM_G:      chipset = "ILM_G";      break;   default:      chipset = "unknown";      break;   }   util_snprintf(buffer, sizeof(buffer), "i965 (chipset: %s)", chipset);   return buffer;}

static int qc_vtos(qc_program_t *prog) {    char buffer[512];    qcany_t *num;    qcany_t str;    CheckArgs(1);    num = GetArg(0);    util_snprintf(buffer, sizeof(buffer), "'%g %g %g'", num->vector[0], num->vector[1], num->vector[2]);    str.string = prog_tempstring(prog, buffer);    Return(str);    return 0;}

static const char *etna_screen_get_name(struct pipe_screen *pscreen){   struct etna_screen *priv = etna_screen(pscreen);   static char buffer[128];   util_snprintf(buffer, sizeof(buffer), "Vivante GC%x rev %04x", priv->model,                 priv->revision);   return buffer;}

static int qc_etos(qc_program_t *prog) {    char buffer[512];    qcany_t *num;    qcany_t str;    CheckArgs(1);    num = GetArg(0);    util_snprintf(buffer, sizeof(buffer), "%i", num->_int);    str.string = prog_tempstring(prog, buffer);    Return(str);    return 0;}

int NTStatsServer::buildConnectionName(const char* instanceName,                                       char* outputPath,                                       int sizeOutputPath){    if (instanceName == NULL)    {        instanceName = conf_get_true_globals()->Vserver_id;    }    return util_snprintf(outputPath, sizeOutputPath,                         "////.//pipe//iWSStats-%s",                         instanceName);}

static void svga_flush( struct pipe_context *pipe,                        struct pipe_fence_handle **fence,                        unsigned flags){   struct svga_context *svga = svga_context(pipe);   /* Emit buffered drawing commands, and any back copies.    */   svga_surfaces_flush( svga );   if (flags & PIPE_FLUSH_FENCE_FD)      svga->swc->hints |= SVGA_HINT_FLAG_EXPORT_FENCE_FD;   /* Flush command queue.    */   svga_context_flush(svga, fence);   SVGA_DBG(DEBUG_DMA|DEBUG_PERF, "%s fence_ptr %p/n",            __FUNCTION__, fence ? *fence : 0x0);   /* Enable to dump BMPs of the color/depth buffers each frame */   if (0) {      struct pipe_framebuffer_state *fb = &svga->curr.framebuffer;      static unsigned frame_no = 1;      char filename[256];      unsigned i;      for (i = 0; i < fb->nr_cbufs; i++) {         util_snprintf(filename, sizeof(filename), "cbuf%u_%04u.bmp", i, frame_no);         debug_dump_surface_bmp(&svga->pipe, filename, fb->cbufs[i]);      }      if (0 && fb->zsbuf) {         util_snprintf(filename, sizeof(filename), "zsbuf_%04u.bmp", frame_no);         debug_dump_surface_bmp(&svga->pipe, filename, fb->zsbuf);      }      ++frame_no;   }}

voidlp_format_intrinsic(char *name,                    size_t size,                    const char *name_root,                    LLVMTypeRef type){   unsigned length = 0;   unsigned width;   char c;   LLVMTypeKind kind = LLVMGetTypeKind(type);   if (kind == LLVMVectorTypeKind) {      length = LLVMGetVectorSize(type);      type = LLVMGetElementType(type);      kind = LLVMGetTypeKind(type);   }   switch (kind) {   case LLVMIntegerTypeKind:      c = 'i';      width = LLVMGetIntTypeWidth(type);      break;   case LLVMFloatTypeKind:      c = 'f';      width = 32;      break;   case LLVMDoubleTypeKind:      c = 'f';      width = 64;      break;   default:      unreachable("unexpected LLVMTypeKind");   }   if (length) {      util_snprintf(name, size, "%s.v%u%c%u", name_root, length, c, width);   } else {      util_snprintf(name, size, "%s.%c%u", name_root, c, width);   }}

/** * Dump an image to a .raw or .ppm file (depends on OS). * /param format  PIPE_FORMAT_x * /param cpp  bytes per pixel * /param width  width in pixels * /param height height in pixels * /param stride  row stride in bytes */void debug_dump_image(const char *prefix,                      unsigned format, unsigned cpp,                      unsigned width, unsigned height,                      unsigned stride,                      const void *data)     {   /* write a ppm file */   char filename[256];   FILE *f;   util_snprintf(filename, sizeof(filename), "%s.ppm", prefix);   f = fopen(filename, "w");   if (f) {      int i, x, y;      int r, g, b;      const uint8_t *ptr = (uint8_t *) data;      /* XXX this is a hack */      switch (format) {      case PIPE_FORMAT_B8G8R8A8_UNORM:         r = 2;         g = 1;         b = 0;         break;      default:         r = 0;         g = 1;         b = 1;      }      fprintf(f, "P6/n");      fprintf(f, "# ppm-file created by osdemo.c/n");      fprintf(f, "%i %i/n", width, height);      fprintf(f, "255/n");      fclose(f);      f = fopen(filename, "ab");  /* reopen in binary append mode */      for (y = 0; y < height; y++) {         for (x = 0; x < width; x++) {            i = y * stride + x * cpp;            fputc(ptr[i + r], f); /* write red */            fputc(ptr[i + g], f); /* write green */            fputc(ptr[i + b], f); /* write blue */         }      }      fclose(f);   }   else {      fprintf(stderr, "Can't open %s for writing/n", filename);   }}

/* * Linux perf profiler integration. * * See also: * - http://penberg.blogspot.co.uk/2009/06/jato-has-profiler.html * - https://github.com/penberg/jato/commit/73ad86847329d99d51b386f5aba692580d1f8fdc * - http://git.kernel.org/?p=linux/kernel/git/torvalds/linux.git;a=commitdiff;h=80d496be89ed7dede5abee5c057634e80a31c82d */extern "C" voidlp_profile(LLVMValueRef func, const void *code){#if defined(__linux__) && defined(PROFILE)   static boolean first_time = TRUE;   static FILE *perf_map_file = NULL;   static int perf_asm_fd = -1;   if (first_time) {      /*       * We rely on the disassembler for determining a function's size, but       * the disassembly is a leaky and slow operation, so avoid running       * this except when running inside linux perf, which can be inferred       * by the PERF_BUILDID_DIR environment variable.       */      if (getenv("PERF_BUILDID_DIR")) {         pid_t pid = getpid();         char filename[256];         util_snprintf(filename, sizeof filename, "/tmp/perf-%llu.map", (unsigned long long)pid);         perf_map_file = fopen(filename, "wt");         util_snprintf(filename, sizeof filename, "/tmp/perf-%llu.map.asm", (unsigned long long)pid);         mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;         perf_asm_fd = open(filename, O_WRONLY | O_CREAT, mode);      }      first_time = FALSE;   }   if (perf_map_file) {      const char *symbol = LLVMGetValueName(func);      unsigned long addr = (uintptr_t)code;      llvm::raw_fd_ostream Out(perf_asm_fd, false);      Out << symbol << ":/n";      unsigned long size = disassemble(code, Out);      fprintf(perf_map_file, "%lx %lx %s/n", addr, size, symbol);      fflush(perf_map_file);   }#else   (void)func;   (void)code;#endif}

static struct vg_shader * setup_convolution(struct vg_context *ctx, void *user_data){   char buffer[1024];   VGint num_consts = (VGint)(long)(user_data);   struct vg_shader *shader;   util_snprintf(buffer, 1023, convolution_asm, num_consts, num_consts / 2 + 1);   shader = shader_create_from_text(ctx->pipe, buffer, 200,                                    PIPE_SHADER_FRAGMENT);   return shader;}

char *_resume_handler(){	HANDLE resume_event;	char *err;	    resume_event = OpenEvent(EVENT_ALL_ACCESS, FALSE, resume);    if (resume_event == NULL) {		err = (char *)MALLOC(ERR_MSG_LEN);        util_snprintf(err, ERR_MSG_LEN, "could not open resume event  (%s)",             system_errmsg());        return err;    }	    if(!SetEvent(resume_event)) { 		err = (char *)MALLOC(ERR_MSG_LEN);       util_snprintf(err, ERR_MSG_LEN, "cannot set reset event (%s)",             system_errmsg());        return err;    }	return NULL;}

char *_create_rotation_thread(){	char *err;	    handler_thread = systhread_start(15, 65536, _wait_for_events,                                          NULL);	if (handler_thread == NULL) {			err = (char *)MALLOC(ERR_MSG_LEN);		util_snprintf(err, ERR_MSG_LEN, "Failed to start event handler thread %s",				system_errmsg());		return err;	}	return NULL;}

/** * Generate sin(a) */LLVMValueReflp_build_sin(struct lp_build_context *bld,              LLVMValueRef a){   const struct lp_type type = bld->type;   LLVMTypeRef vec_type = lp_build_vec_type(type);   char intrinsic[32];   /* TODO: optimize the constant case */   assert(type.floating);   util_snprintf(intrinsic, sizeof intrinsic, "llvm.sin.v%uf%u", type.length, type.width);   return lp_build_intrinsic_unary(bld->builder, intrinsic, vec_type, a);}

const char *debug_dump_enum(const struct debug_named_value *names,                 unsigned long value){   static char rest[64];      while(names->name) {      if(names->value == value)	 return names->name;      ++names;   }   util_snprintf(rest, sizeof(rest), "0x%08lx", value);   return rest;}

static EGLBooleandlopen_gl_lib_cb(const char *dir, size_t len, void *callback_data){   const char *name = (const char *) callback_data;   char path[1024];   int ret;   if (len) {      assert(len <= INT_MAX && "path is insanely long!");      ret = util_snprintf(path, sizeof(path), "%.*s/%s" UTIL_DL_EXT,            (int)len, dir, name);   }   else {      ret = util_snprintf(path, sizeof(path), "%s" UTIL_DL_EXT, name);   }   if (ret > 0 && ret < sizeof(path)) {      egl_st_gl_lib = util_dl_open(path);      if (egl_st_gl_lib)         _eglLog(_EGL_DEBUG, "loaded %s", path);   }   return !egl_st_gl_lib;}

static const GLubyte *st_get_string(struct gl_context * ctx, GLenum name){    struct st_context *st = st_context(ctx);    struct pipe_screen *screen = st->pipe->screen;    switch (name) {    case GL_VENDOR: {        const char *vendor = screen->get_vendor( screen );        util_snprintf(st->vendor, sizeof(st->vendor), "%s", vendor);        return (GLubyte *) st->vendor;    }    case GL_RENDERER:        util_snprintf(st->renderer, sizeof(st->renderer), "Gallium %s on %s",                      ST_VERSION_STRING,                      screen->get_name( screen ));        return (GLubyte *) st->renderer;    default:        return NULL;    }}