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

/** * External logger function * @param level log level * @param fmt as printf format string * @param ... as printf variable argument */void fnc_log(int level, const char *fmt, ...) {    va_list vl;    va_start(vl, fmt);    fnc_vlog(level, fmt, vl);    va_end(vl);}

/****  Generate a list of files within a specified directory****  @param dirname  Directory to read.**  @param fl       Filelist pointer.****  @return the number of entries added to FileList.*/int ReadDataDirectory(const char *dirname, std::vector<FileList> &fl){	struct stat st;	char buffer[PATH_MAX];	char *filename;	strcpy_s(buffer, sizeof(buffer), dirname);	int n = strlen(buffer);	if (!n || buffer[n - 1] != '/') {		buffer[n++] = '/';		buffer[n] = 0;	}	char *np = buffer + n;#ifndef USE_WIN32	DIR *dirp = opendir(dirname);	struct dirent *dp;	if (dirp) {		while ((dp = readdir(dirp)) != NULL) {			filename = dp->d_name;#else	strcat_s(buffer, sizeof(buffer), "*.*");	struct _finddata_t fileinfo;	long hFile = _findfirst(buffer, &fileinfo);	if (hFile != -1L) {		do {			filename = fileinfo.name;#endif			if (strcmp(filename, ".") == 0) {				continue;			}			if (strcmp(filename, "..") == 0) {				continue;			}			strcpy_s(np, sizeof(buffer) - (np - buffer), filename);			if (stat(buffer, &st) == 0) {				int isdir = S_ISDIR(st.st_mode);				if (isdir || S_ISREG(st.st_mode)) {					FileList nfl;					if (isdir) {						nfl.name = np;					} else {						nfl.name = np;						nfl.type = 1;					}					// sorted instertion					fl.insert(std::lower_bound(fl.begin(), fl.end(), nfl), nfl);				}			}#ifndef USE_WIN32		}		closedir(dirp);#else		} while (_findnext(hFile, &fileinfo) == 0);		_findclose(hFile);#endif	}	return fl.size();}void FileWriter::printf(const char *format, ...){	// FIXME: hardcoded size	char buf[1024];	va_list ap;	va_start(ap, format);	buf[sizeof(buf) - 1] = '/0';	vsnprintf(buf, sizeof(buf) - 1, format, ap);	va_end(ap);	write(buf, strlen(buf));}

void __ast_string_field_ptr_build_va(struct ast_string_field_mgr *mgr,	struct ast_string_field_pool **pool_head, ast_string_field *ptr,	const char *format, va_list ap){	size_t needed;	size_t available;	size_t space = (*pool_head)->size - (*pool_head)->used;	int res;	ssize_t grow;	char *target;	va_list ap2;	/* if the field already has space allocated, try to reuse it;	   otherwise, try to use the empty space at the end of the current	   pool	*/	if (*ptr != __ast_string_field_empty) {		target = (char *) *ptr;		available = AST_STRING_FIELD_ALLOCATION(*ptr);		if (*ptr == mgr->last_alloc) {			available += space;		}	} else {		/* pool->used is always a multiple of ast_alignof(ast_string_field_allocation)		 * so we don't need to re-align anything here.		 */		target = (*pool_head)->base + (*pool_head)->used + ast_alignof(ast_string_field_allocation);		if (space > ast_alignof(ast_string_field_allocation)) {			available = space - ast_alignof(ast_string_field_allocation);		} else {			available = 0;		}	}	va_copy(ap2, ap);	res = vsnprintf(target, available, format, ap2);	va_end(ap2);	if (res < 0) {		/* Are we out of memory? */		return;	}	if (res == 0) {		__ast_string_field_release_active(*pool_head, *ptr);		*ptr = __ast_string_field_empty;		return;	}	needed = (size_t)res + 1; /* NUL byte */	if (needed > available) {		/* the allocation could not be satisfied using the field's current allocation		   (if it has one), or the space available in the pool (if it does not). allocate		   space for it, adding a new string pool if necessary.		*/		if (!(target = (char *) __ast_string_field_alloc_space(mgr, pool_head, needed))) {			return;		}		vsprintf(target, format, ap);		va_end(ap); /* XXX va_end without va_start? */		__ast_string_field_release_active(*pool_head, *ptr);		*ptr = target;	} else if (*ptr != target) {		/* the allocation was satisfied using available space in the pool, but not		   using the space already allocated to the field		*/		__ast_string_field_release_active(*pool_head, *ptr);		mgr->last_alloc = *ptr = target;	        ast_assert(needed < (ast_string_field_allocation)-1);		AST_STRING_FIELD_ALLOCATION(target) = (ast_string_field_allocation)needed;		(*pool_head)->used += ast_make_room_for(needed, ast_string_field_allocation);		(*pool_head)->active += needed;	} else if ((grow = (needed - AST_STRING_FIELD_ALLOCATION(*ptr))) > 0) {		/* the allocation was satisfied by using available space in the pool *and*		   the field was the last allocated field from the pool, so it grew		*/		AST_STRING_FIELD_ALLOCATION(*ptr) += grow;		(*pool_head)->used += ast_align_for(grow, ast_string_field_allocation);		(*pool_head)->active += grow;	}}

//.........这里部分代码省略.........        case MAIL_SERVER_PRE_ACCEPT:            multi_server_pre_accept = va_arg(ap, MAIL_SERVER_ACCEPT_FN);            break;        case MAIL_SERVER_PRE_DISCONN:            multi_server_pre_disconn = va_arg(ap, MAIL_SERVER_DISCONN_FN);            break;        case MAIL_SERVER_IN_FLOW_DELAY:            multi_server_in_flow_delay = 1;            break;        case MAIL_SERVER_SOLITARY:            if (stream == 0 && !alone)                msg_fatal("service %s requires a process limit of 1",                          service_name);            break;        case MAIL_SERVER_UNLIMITED:            if (stream == 0 && !zerolimit)                msg_fatal("service %s requires a process limit of 0",                          service_name);            break;        case MAIL_SERVER_PRIVILEGED:            if (user_name)                msg_fatal("service %s requires privileged operation",                          service_name);            break;        case MAIL_SERVER_BOUNCE_INIT:            dsn_filter_title = va_arg(ap, const char *);            dsn_filter_maps = va_arg(ap, const char **);            bounce_client_init(dsn_filter_title, *dsn_filter_maps);            break;        default:            msg_panic("%s: unknown argument type: %d", myname, key);        }    }    va_end(ap);    if (root_dir)        root_dir = var_queue_dir;    if (user_name)        user_name = var_mail_owner;    /*     * Can options be required?     */    if (stream == 0) {        if (transport == 0)            msg_fatal("no transport type specified");        if (strcasecmp(transport, MASTER_XPORT_NAME_INET) == 0)            multi_server_accept = multi_server_accept_inet;        else if (strcasecmp(transport, MASTER_XPORT_NAME_UNIX) == 0)            multi_server_accept = multi_server_accept_local;#ifdef MASTER_XPORT_NAME_PASS        else if (strcasecmp(transport, MASTER_XPORT_NAME_PASS) == 0)            multi_server_accept = multi_server_accept_pass;#endif        else            msg_fatal("unsupported transport type: %s", transport);    }    /*     * Retrieve process generation from environment.     */    if ((generation = getenv(MASTER_GEN_NAME)) != 0) {        if (!alldig(generation))            msg_fatal("bad generation: %s", generation);        OCTAL_TO_UNSIGNED(multi_server_generation, generation);        if (msg_verbose)

intACE_Process_Options::setenv (const ACE_TCHAR *variable_name,                             const ACE_TCHAR *format, ...){  // To address the potential buffer overflow,  // we now allocate the buffer on heap with a variable size.  size_t const buflen = ACE_OS::strlen (variable_name) + ACE_OS::strlen (format) + 2;  ACE_TCHAR *newformat = 0;  ACE_NEW_RETURN (newformat, ACE_TCHAR[buflen], -1);  ACE_Auto_Basic_Array_Ptr<ACE_TCHAR> safe_newformat (newformat);  // Add in the variable name.  ACE_OS::sprintf (safe_newformat.get (),                   ACE_TEXT ("%s=%s"),                   variable_name,                   format);  // Start varargs.  va_list argp;  va_start (argp, format);  // Add the rest of the varargs.  size_t tmp_buflen = DEFAULT_COMMAND_LINE_BUF_LEN > buflen                      ? static_cast<size_t> (DEFAULT_COMMAND_LINE_BUF_LEN) : buflen;  int retval = 0;  ACE_TCHAR *stack_buf = 0;  ACE_NEW_RETURN (stack_buf, ACE_TCHAR[tmp_buflen], -1);  ACE_Auto_Basic_Array_Ptr<ACE_TCHAR> safe_stack_buf (stack_buf);  do    {      retval = ACE_OS::vsnprintf (safe_stack_buf.get (), tmp_buflen, safe_newformat.get (), argp);      if (retval > ACE_Utils::truncate_cast<int> (tmp_buflen))        {          tmp_buflen *= 2;          ACE_NEW_RETURN (stack_buf, ACE_TCHAR[tmp_buflen], -1);          safe_stack_buf.reset (stack_buf);        }      else        break;    }  while (1);  if (retval == -1)    {      // In case that vsnprintf is not supported,      // e.g., LynxOS and VxWorks 5, we have to      // fall back to vsprintf.      if (errno == ENOTSUP)        {          // ALERT: Since we have to use vsprintf here, there is still a chance that          // the stack_buf overflows, i.e., the length of the resulting string          // can still possibly go beyond the allocated stack_buf.          retval = ACE_OS::vsprintf (safe_stack_buf.get (), safe_newformat.get (), argp);          if (retval == -1)            // vsprintf is failed.            return -1;        }      else        // vsnprintf is failed.        return -1;    }  // End varargs.  va_end (argp);  // Append the string to our environment buffer.  if (this->setenv_i (safe_stack_buf.get (),                      ACE_OS::strlen (safe_stack_buf.get ())) == -1)    return -1;#if defined (ACE_WIN32)  if (inherit_environment_)    this->inherit_environment ();#endif /* ACE_WIN32 */  return 0;}

void I_Error (char *error, ...){    va_list argptr;    atexit_listentry_t *entry;    boolean exit_gui_popup;    if (already_quitting)    {        fprintf(stderr, "Warning: recursive call to I_Error detected./n");        exit(-1);    }    else    {        already_quitting = true;    }        // Message first.    va_start(argptr, error);    //fprintf(stderr, "/nError: ");    vfprintf(stderr, error, argptr);    fprintf(stderr, "/n/n");    va_end(argptr);    fflush(stderr);    // Shutdown. Here might be other errors.    entry = exit_funcs;    while (entry != NULL)    {        if (entry->run_on_error)        {            entry->func();        }        entry = entry->next;    }    exit_gui_popup = !M_ParmExists("-nogui");#ifdef _WIN32    // On Windows, pop up a dialog box with the error message.    if (exit_gui_popup)    {        char msgbuf[512];        wchar_t wmsgbuf[512];        va_start(argptr, error);        memset(msgbuf, 0, sizeof(msgbuf));        M_vsnprintf(msgbuf, sizeof(msgbuf), error, argptr);        va_end(argptr);        MultiByteToWideChar(CP_ACP, 0,                            msgbuf, strlen(msgbuf) + 1,                            wmsgbuf, sizeof(wmsgbuf));        MessageBoxW(NULL, wmsgbuf, L"", MB_OK);    }#endif#ifdef __MACOSX__    if (exit_gui_popup && !I_ConsoleStdout())    {        CFStringRef message;        char msgbuf[512];	int i;        va_start(argptr, error);        memset(msgbuf, 0, sizeof(msgbuf));        M_vsnprintf(msgbuf, sizeof(msgbuf), error, argptr);        va_end(argptr);	// The CoreFoundation message box wraps text lines, so replace	// newline characters with spaces so that multiline messages	// are continuous.	for (i = 0; msgbuf[i] != '/0'; ++i)        {            if (msgbuf[i] == '/n')            {                msgbuf[i] = ' ';            }        }        message = CFStringCreateWithCString(NULL, msgbuf,                                            kCFStringEncodingUTF8);        CFUserNotificationDisplayNotice(0,                                        kCFUserNotificationCautionAlertLevel,                                        NULL,                                        NULL,                                        NULL,                                        CFSTR(PACKAGE_STRING),                                        message,                                        NULL);    }#endif    // abort();//.........这里部分代码省略.........

static voidtest0(const char *type, ...){	char buf[512];	CONV_RESULT cr;	int rc;	TDS_INT result_type;	int done_flags;	va_list ap;	struct {		const char *value;		const char *result;	} data[10];	int num_data = 0, i_row;	sprintf(buf, "CREATE TABLE #tmp(a %s)", type);	exec_query(buf);        va_start(ap, type);	for (;;) {		const char * value = va_arg(ap, const char *);		const char * result;		if (!value)			break;		result = va_arg(ap, const char *);		if (!result)			result = value;		data[num_data].value = value;		data[num_data].result = result;		sprintf(buf, "INSERT INTO #tmp VALUES(CONVERT(%s,'%s'))", type, value);		exec_query(buf);		++num_data;	}        va_end(ap);	assert(num_data > 0);	/* execute it */	rc = tds_submit_query(tds, "SELECT * FROM #tmp");	if (rc != TDS_SUCCESS) {		fprintf(stderr, "tds_submit_query() failed/n");		exit(1);	}	if (tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_RESULTS) != TDS_SUCCESS) {		fprintf(stderr, "tds_process_tokens() failed/n");		exit(1);	}	if (result_type != TDS_ROWFMT_RESULT) {		fprintf(stderr, "expected row fmt() failed/n");		exit(1);	}	if (tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_RESULTS) != TDS_SUCCESS) {		fprintf(stderr, "tds_process_tokens() failed/n");		exit(1);	}	if (result_type != TDS_ROW_RESULT) {		fprintf(stderr, "expected row result() failed/n");		exit(1);	}	i_row = 0;	while ((rc = tds_process_tokens(tds, &result_type, NULL, TDS_STOPAT_ROWFMT|TDS_RETURN_DONE|TDS_RETURN_ROW|TDS_RETURN_COMPUTE)) == TDS_SUCCESS && (result_type == TDS_ROW_RESULT || result_type == TDS_COMPUTE_RESULT)) {		TDSCOLUMN *curcol = tds->current_results->columns[0];		TDS_CHAR *src = (TDS_CHAR *) curcol->column_data;		int conv_type = tds_get_conversion_type(curcol->column_type, curcol->column_size);		assert(i_row < num_data);		if (is_blob_col(curcol)) {			TDSBLOB *blob = (TDSBLOB *) src;			src = blob->textvalue;		}		if (tds_convert(test_context, conv_type, src, curcol->column_cur_size, SYBVARCHAR, &cr) < 0) {			fprintf(stderr, "Error converting/n");			g_result = 1;		} else {			if (strcmp(data[i_row].result, cr.c) != 0) {				fprintf(stderr, "Failed! Is /n%s/nShould be/n%s/n", cr.c, data[i_row].result);				g_result = 1;			}			free(cr.c);		}		++i_row;	}	if (rc != TDS_NO_MORE_RESULTS && rc != TDS_SUCCESS) {		fprintf(stderr, "tds_process_tokens() unexpected return/n");		exit(1);	}	while ((rc = tds_process_tokens(tds, &result_type, &done_flags, TDS_TOKEN_RESULTS)) == TDS_SUCCESS) {		switch (result_type) {		case TDS_NO_MORE_RESULTS://.........这里部分代码省略.........

void class_addmethod(t_class *c, t_method fn, t_symbol *sel,    t_atomtype arg1, ...){    va_list ap;    t_methodentry *m;    t_atomtype argtype = arg1;    int nargs;        va_start(ap, arg1);        /* "signal" method specifies that we take audio signals but        that we don't want automatic float to signal conversion.  This        is obsolete; you should now use the CLASS_MAINSIGNALIN macro. */    if (sel == &s_signal)    {        if (c->c_floatsignalin)            post("warning: signal method overrides class_mainsignalin");        c->c_floatsignalin = -1;    }        /* check for special cases.  "Pointer" is missing here so that        pd_objectmaker's pointer method can be typechecked differently.  */    if (sel == &s_bang)    {        if (argtype) goto phooey;        class_addbang(c, fn);    }    else if (sel == &s_float)    {        if (argtype != A_FLOAT || va_arg(ap, t_atomtype)) goto phooey;        class_doaddfloat(c, fn);    }    else if (sel == &s_symbol)    {        if (argtype != A_SYMBOL || va_arg(ap, t_atomtype)) goto phooey;        class_addsymbol(c, fn);    }    else if (sel == &s_blob) /* MP 20070106 blob type */    {        post("class_addmethod: %p", fn);        if (argtype != A_BLOB || va_arg(ap, t_atomtype)) goto phooey;        class_addblob(c, fn);    }    else if (sel == &s_list)    {        if (argtype != A_GIMME) goto phooey;        class_addlist(c, fn);    }    else if (sel == &s_anything)    {        if (argtype != A_GIMME) goto phooey;        class_addanything(c, fn);    }    else    {        /* Pd-extended doesn't use the aliasing automagic        int i;        for (i = 0; i < c->c_nmethod; i++)            if (c->c_methods[i].me_name == sel)        {            char nbuf[80];            snprintf(nbuf, 80, "%s_aliased", sel->s_name);            c->c_methods[i].me_name = gensym(nbuf);            if (c == pd_objectmaker)                post("warning: class '%s' overwritten; old one renamed '%s'",                    sel->s_name, nbuf);            else post("warning: old method '%s' for class '%s' renamed '%s'",                sel->s_name, c->c_name->s_name, nbuf);        }        */        c->c_methods = t_resizebytes(c->c_methods,            c->c_nmethod * sizeof(*c->c_methods),            (c->c_nmethod + 1) * sizeof(*c->c_methods));        m = c->c_methods +  c->c_nmethod;        c->c_nmethod++;        m->me_name = sel;        m->me_fun = (t_gotfn)fn;        nargs = 0;        while (argtype != A_NULL && nargs < MAXPDARG)        {            m->me_arg[nargs++] = argtype;            argtype = va_arg(ap, t_atomtype);        }        if (argtype != A_NULL)            error("%s_%s: only 5 arguments are typecheckable; use A_GIMME",                c->c_name->s_name, sel->s_name);        va_end(ap);        m->me_arg[nargs] = A_NULL;    }    return;phooey:    bug("class_addmethod: %s_%s: bad argument types/n",        c->c_name->s_name, sel->s_name);}

void fmt_fmt(int put(int c, void *), void *cl, const char *fmt, ...){	va_list ap;	va_start(ap, fmt);	fmt_vfmt(put, cl, fmt, ap);	va_end(ap);}

void CLogFile::WriteMessage(const char* string, ...) {    va_list args;    va_start(args, string);    Write("#00FF00",string,args);    va_end(args);}

t_class *class_new(t_symbol *s, t_newmethod newmethod, t_method freemethod,    size_t size, int flags, t_atomtype type1, ...){    va_list ap;    t_atomtype vec[MAXPDARG+1], *vp = vec;    int count = 0;    t_class *c;    int typeflag = flags & CLASS_TYPEMASK;    if (!typeflag) typeflag = CLASS_PATCHABLE;    *vp = type1;    va_start(ap, type1);    while (*vp)    {        if (count == MAXPDARG)        {            error("class %s: sorry: only %d args typechecked; use A_GIMME",                s->s_name, MAXPDARG);            break;        }        vp++;        count++;        *vp = va_arg(ap, t_atomtype);    }    va_end(ap);    if (pd_objectmaker && newmethod)    {            /* add a "new" method by the name specified by the object */        class_addmethod(pd_objectmaker, (t_method)newmethod, s,            vec[0], vec[1], vec[2], vec[3], vec[4], vec[5]);        if (class_loadsym)        {                /* if we're loading an extern it might have been invoked by a                longer file name; in this case, make this an admissible name                too. */            char *loadstring = class_loadsym->s_name,                l1 = strlen(s->s_name), l2 = strlen(loadstring);            if (l2 > l1 && !strcmp(s->s_name, loadstring + (l2 - l1)))                class_addmethod(pd_objectmaker, (t_method)newmethod,                    class_loadsym,                    vec[0], vec[1], vec[2], vec[3], vec[4], vec[5]);        }    }    c = (t_class *)t_getbytes(sizeof(*c));    c->c_name = c->c_helpname = s;    c->c_size = size;    c->c_methods = t_getbytes(0);    c->c_nmethod = 0;    c->c_freemethod = (t_method)freemethod;    c->c_bangmethod = pd_defaultbang;    c->c_pointermethod = pd_defaultpointer;    c->c_floatmethod = pd_defaultfloat;    c->c_symbolmethod = pd_defaultsymbol;    c->c_blobmethod = pd_defaultblob; /* MP 20061226 blob type */    c->c_listmethod = pd_defaultlist;    c->c_anymethod = pd_defaultanything;    c->c_wb = (typeflag == CLASS_PATCHABLE ? &text_widgetbehavior : 0);    c->c_pwb = 0;    c->c_firstin = ((flags & CLASS_NOINLET) == 0);    c->c_patchable = (typeflag == CLASS_PATCHABLE);    c->c_gobj = (typeflag >= CLASS_GOBJ);    c->c_drawcommand = 0;    c->c_floatsignalin = 0;    c->c_externdir = class_extern_dir;    c->c_savefn = (typeflag == CLASS_PATCHABLE ? text_save : class_nosavefn);#if 0     post("class: %s", c->c_name->s_name);#endif    classtable_register(c);//    post("class: %s", c->c_name->s_name);    return (c);}

//.........这里部分代码省略.........	    *k = pic_int(v);	    *e = true;	    break;	  default:	    pic_error(pic, "pic_get_args: expected float or int");	  }	  i++;	}      }      break;    case 'i':      {	int *k;	k = va_arg(ap, int *);	if (i < argc) {	  pic_value v;	  v = GET_OPERAND(pic, i);	  switch (pic_type(v)) {	  case PIC_TT_FLOAT:	    *k = (int)pic_float(v);	    break;	  case PIC_TT_INT:	    *k = pic_int(v);	    break;	  default:	    pic_error(pic, "pic_get_args: expected int");	  }	  i++;	}      }      break;    case 's':      {	pic_value str;	char **cstr;	size_t *len;	cstr = va_arg(ap, char **);	len = va_arg(ap, size_t *);	if (i < argc) {	  str = GET_OPERAND(pic,i);	  if (! pic_str_p(str)) {	    pic_error(pic, "pic_get_args: expected string");	  }	  *cstr = pic_str_ptr(str)->str;	  *len = pic_str_ptr(str)->len;	  i++;	}      }      break;    case 'v':      {	struct pic_vector **vec;	pic_value v;	vec = va_arg(ap, struct pic_vector **);	if (i < argc) {	  v = GET_OPERAND(pic,i);	  if (pic_vec_p(v)) {	    *vec = pic_vec_ptr(v);	  }	  else {	    pic_error(pic, "pic_get_args: expected vector");	  }	  i++;	}      }      break;    case 'b':      {	struct pic_blob **b;	pic_value v;	b = va_arg(ap, struct pic_blob **);	if (i < argc) {	  v = GET_OPERAND(pic,i);	  if (pic_blob_p(v)) {	    *b = pic_blob_ptr(v);	  }	  else {	    pic_error(pic, "pic_get_args: expected bytevector");	  }	  i++;	}      }      break;    default:      {	pic_error(pic, "pic_get_args: invalid argument specifier given");      }    }  }  if (argc > i) {    pic_error(pic, "wrong number of arguments");  }  va_end(ap);  return i;}

void WOLog(int level, const char *format, ...){   FILE *log;   va_list ap;   int do_it;#if defined(TIMESTAMP_LOG_MESSAGES)   struct tm *t;   time_t now;   char timestamp[64];#endif   if (level < baselevel)      return;   if (! initialized )	   return;   do_it = shouldLog();   if ( do_it ) {      /*       * plenty of people have complained that we need to timestamp       * the log entries.  the problem is that mktime & friends aren't       * reentrant.       */#if defined(TIMESTAMP_LOG_MESSAGES)      WA_lock(logMutex);      time(&now);      t = localtime(&now);      strftime(timestamp, sizeof(timestamp), "%d-%b-%Y %T - ", t);      WA_unlock(logMutex);#endif      log = fopen(logPath, "a+");      if (log != NULL) {#if defined(TIMESTAMP_LOG_MESSAGES)         fprintf(log, timestamp);#endif         fprintf(log,"%s: ", WOLogLevel[level]);         va_start(ap, format);         vfprintf(log, format, ap);         va_end(ap);         fprintf(log,"/n");         fclose(log);      }else{// TODO - figure out how to report this for other web servers#if defined(APACHE)         ap_log_error(APLOG_MARK, APLOG_ERR, 0, _webobjects_server, "Failed to append to log file '%s'.  This can occur when the file is not writable by the child httpd process.  A workaround is to change the ownership of the file to match the child httpd process.", logPath);#endif      }   }   /*    *	if the error is serious, include it into the server's log    */#if	defined(Netscape) || defined(APACHE) || defined(IIS)   if (level == WO_ERR) {      String *str;      str = str_create(NULL, 128);      va_start(ap,format);      str_vappendf(str, format, ap);      va_end(ap);#if defined(Netscape)      log_error(0,"WebObjects",NULL,NULL,str->text);#elif defined(APACHE)      ap_log_error(APLOG_MARK, APLOG_ERR, 0, _webobjects_server, "%s", str->text);#elif defined(IIS)      /*       *	again, we're stymied because we don't have a ptr to the       *	server struct       * /       {          LPDWORD len = strlen(logstr);          ServerSupportFunction(p->ConnID, HSE_APPEND_LOG_PARAMETER,                                str->text, &len, (LPDWORD)NULL);       }       */#endif      str_free(str);   }#endif}

static voidlogprint(uint32_t flags, char *message, ...){	va_list args;	char buf[1024];	int do_always = ((flags & (SC_IF_VERBOSE | SC_IF_ISATTY)) == 0);	int do_ifverb = (flags & SC_IF_VERBOSE) && verbose;	int do_ifisatty = (flags & SC_IF_ISATTY) && interactive;	int code;	static int logprint_raised = 0;	if (do_always || do_ifverb || do_ifisatty) {		va_start(args, message);		/*LINTED: E_SEC_PRINTF_VAR_FMT*/		(void) vsnprintf(buf, sizeof (buf), message, args);		(void) fprintf(stderr, "%s: %s/n", progname, buf);		if (!interactive) {			switch (flags & (SC_SL_NONE | SC_SL_ERR | SC_SL_WARN)) {			case SC_SL_ERR:				/*LINTED: E_SEC_PRINTF_VAR_FMT*/				syslog(LOG_ERR, buf);				break;			case SC_SL_WARN:				/*LINTED: E_SEC_PRINTF_VAR_FMT*/				syslog(LOG_WARNING, buf);				break;			default:				break;			}		}		va_end(args);	}	switch (flags & _SC_ALLEXIT) {	case 0:		return;	case SC_EXIT_OK:		code = 0;		break;	case SC_EXIT_PEND:		/*		 * Raise an ireport saying why we are exiting.  Do not		 * raise if run as savecore -m.  If something in the		 * raise_event codepath calls logprint avoid recursion.		 */		if (!mflag && logprint_raised++ == 0)			raise_event(SC_EVENT_SAVECORE_FAILURE, buf);		code = 2;		break;	case SC_EXIT_FM:		code = 3;		break;	case SC_EXIT_ERR:	default:		if (!mflag && logprint_raised++ == 0)			raise_event(SC_EVENT_SAVECORE_FAILURE, buf);		code = 1;		break;	}	exit(code);}

int hb_vsnprintf( char * buffer, size_t bufsize, const char * format, va_list ap ){   va_list args;   size_t size;   char c;#ifndef __NO_ARGPOS__   const char * fmt_start = format;   v_param argbuf[ _ARGBUF_SIZE ];   v_paramlst params;   params.size = _ARGBUF_SIZE;   params.maxarg = 0;   params.arglst = argbuf;#endif#ifndef __NO_ARGPOS__   do   {      params.repeat = HB_FALSE;      if( params.maxarg > 0 )      {         va_copy( args, ap );         va_arg_fill( &params, args );         va_end( args );      }      format = fmt_start;#endif      va_copy( args, ap );      size = 0;      do      {         c = *format++;         if( c == '%' )         {            const char * pattern = format;            c = *format++;            if( c != 0 && c != '%' )            {               /* decode pattern */               v_param argval;               int param = 0, flags = 0, width = -1, precision = -1, length,                   value, stop = 0;               /* parameter position */               if( c >= '0' && c <= '9' )               {                  c = get_decimal( c, &format, &value );                  if( c == '$' )                     param = value;                  else                     format = pattern;                  c = *format++;               }               /* flags */               while( ! stop )               {                  switch( c )                  {                     case '#':                        flags |= _F_ALTERNATE;                        c = *format++;                        break;                     case '0':                        flags |= _F_ZEROPADED;                        c = *format++;                        break;                     case '-':                        flags |= _F_LEFTADJUSTED;                        c = *format++;                        break;                     case ' ':                        flags |= _F_SPACE;                        c = *format++;                        break;                     case '+':                        flags |= _F_SIGN;                        c = *format++;                        break;#ifdef _SUSV2_COMPAT_                     case '/'':  /* group with locale thousands' grouping characters */                        c = *format++;                        break;#endif                     default:                        stop = 1;                        break;                  }               }               /* field width */               if( c == '*' )               {                  c = *format++;                  if( c >= '0' && c <= '9' )                  {//.........这里部分代码省略.........

void fmt_print(const char *fmt, ...){	va_list ap;	va_start(ap, fmt);	fmt_vfmt(outc, stdout, fmt, ap);	va_end(ap);}

//.........这里部分代码省略.........        memcpy(modulebuf, module, modlen);        modulebuf[modlen] = '/0';        module = modulebuf;    }    /* C locale to get error messages in English in the logs */    locale_t c = newlocale (LC_MESSAGES_MASK, "C", (locale_t)0);    locale_t locale = uselocale (c);#ifndef __GLIBC__    /* Expand %m to strerror(errno) - only once */    char buf[strlen(format) + 2001], *ptr;    strcpy (buf, format);    ptr = (char*)buf;    format = (const char*) buf;    for( ;; )    {        ptr = strchr( ptr, '%' );        if( ptr == NULL )            break;        if( ptr[1] == 'm' )        {            char errbuf[2001];            size_t errlen;#ifndef _WIN32            strerror_r( errno, errbuf, 1001 );#else            int sockerr = WSAGetLastError( );            if( sockerr )            {                strncpy( errbuf, net_strerror( sockerr ), 1001 );                WSASetLastError( sockerr );            }            if ((sockerr == 0)             || (strcmp ("Unknown network stack error", errbuf) == 0))                strncpy( errbuf, strerror( errno ), 1001 );#endif            errbuf[1000] = 0;            /* Escape '%' from the error string */            for( char *percent = strchr( errbuf, '%' );                 percent != NULL;                 percent = strchr( percent + 2, '%' ) )            {                memmove( percent + 1, percent, strlen( percent ) + 1 );            }            errlen = strlen( errbuf );            memmove( ptr + errlen, ptr + 2, strlen( ptr + 2 ) + 1 );            memcpy( ptr, errbuf, errlen );            break; /* Only once, so we don't overflow */        }        /* Looks for conversion specifier... */        do            ptr++;        while( *ptr && ( strchr( "diouxXeEfFgGaAcspn%", *ptr ) == NULL ) );        if( *ptr )            ptr++; /* ...and skip it */    }#endif    /* Fill message information fields */    vlc_log_t msg;    msg.i_object_id = (uintptr_t)obj;    msg.psz_object_type = (obj != NULL) ? obj->psz_object_type : "generic";    msg.psz_module = module;    msg.psz_header = NULL;    for (vlc_object_t *o = obj; o != NULL; o = o->p_parent)        if (o->psz_header != NULL)        {            msg.psz_header = o->psz_header;            break;        }    /* Pass message to the callback */    libvlc_priv_t *priv = obj ? libvlc_priv (obj->p_libvlc) : NULL;#ifdef _WIN32    va_list ap;    va_copy (ap, args);    Win32DebugOutputMsg (priv ? &priv->log.verbose : NULL, type, &msg, format, ap);    va_end (ap);#endif    if (priv) {        vlc_rwlock_rdlock (&priv->log.lock);        priv->log.cb (priv->log.opaque, type, &msg, format, args);        vlc_rwlock_unlock (&priv->log.lock);    }    uselocale (locale);    freelocale (c);}

void fmt_fprint(FILE *stream, const char *fmt, ...){	va_list ap;	va_start(ap, fmt);	fmt_vfmt(outc, stdout, fmt, ap);	va_end(ap);}

static int TargetCall(WsXmlDocH doc, PyObject* instance,                  const char* opname, int nargs, ...){    va_list vargs;     PyObject *pyargs = NULL;     PyObject *pyfunc = NULL;     PyObject *result = NULL;     WsmanStatus status;    wsman_status_init(&status);    pyargs = PyTuple_New(nargs);     pyfunc = PyObject_GetAttrString(instance, opname);     if (pyfunc == NULL)    {        PyErr_Print();         PyErr_Clear();         char* str = fmtstr("Python module does not contain /"%s/"", opname);         debug("%s", str); 	status.fault_code = WSA_ENDPOINT_UNAVAILABLE;	status.fault_detail_code = 0;        free(str);         goto cleanup;     }    if (! PyCallable_Check(pyfunc))    {        char* str = fmtstr("Python module attribute /"%s/" is not callable",                 opname);         debug("%s", str); 	status.fault_code = WSA_ENDPOINT_UNAVAILABLE;	status.fault_detail_code = 0;        free(str);         goto cleanup;     }        va_start(vargs, nargs);     int i;     for (i = 0; i < nargs; ++i)    {        PyObject* arg = va_arg(vargs, PyObject*);         if (arg == NULL)        {            arg = Py_None;             Py_IncRef(arg);         }        PyTuple_SET_ITEM(pyargs, i, arg);     }    va_end(vargs);     result = PyObject_CallObject(pyfunc, pyargs);    if (PyErr_Occurred())    {        status.fault_code = WSMAN_INTERNAL_ERROR;	status.fault_detail_code = 0;        PyErr_Clear();         goto cleanup;     }    if (! PyTuple_Check(result) ||             (PyTuple_Size(result) != 2 && PyTuple_Size(result) != 1))    {        TARGET_THREAD_BEGIN_ALLOW;        status.fault_msg = fmtstr("Python function /"%s/" didn't return a two-tuple", opname); 	status.fault_code = WSMAN_INTERNAL_ERROR;	status.fault_detail_code = 0;        TARGET_THREAD_END_ALLOW;         goto cleanup;     }    PyObject* code = PyTuple_GetItem(result, 0);    PyObject* detail = Py_None;     if (PyTuple_Size(result) == 2)    {        detail = PyTuple_GetItem(result, 1);     }    if (! PyInt_Check(code) || (! PyInt_Check(detail) && detail != Py_None))    {        TARGET_THREAD_BEGIN_ALLOW;        status.fault_msg = fmtstr("Python function /"%s/" didn't return a {<int>, <int>) two-tuple", opname); 	status.fault_code = WSMAN_INTERNAL_ERROR;	status.fault_detail_code = 0;        TARGET_THREAD_END_ALLOW;         goto cleanup;     }    status.fault_code = PyInt_AsLong(code);     if (detail == Py_None)    {	status.fault_code = WSMAN_INTERNAL_ERROR;	status.fault_detail_code = 0;    }    else    {        status.fault_detail_code = PyInt_AsLong(detail);    }cleanup:    if (status.fault_code != WSMAN_RC_OK)      wsman_generate_fault( doc, status.fault_code, status.fault_detail_code, status.fault_msg );    Py_DecRef(pyargs);    Py_DecRef(pyfunc);    Py_DecRef(result);//.........这里部分代码省略.........

void *g_html_special(struct g_part *p, int c, ...){	va_list l;	unsigned char *t;	struct form_control *fc;	struct frameset_param *fsp;	struct frame_param *fp;	struct image_description *im;	struct g_object_tag *tag;	struct refresh_param *rp;	struct hr_param *hr;	va_start(l, c);	switch (c) {		case SP_TAG:			t = va_arg(l, unsigned char *);			va_end(l);			/*html_tag(p->data, t, X(p->cx), Y(p->cy));*/			tag = mem_calloc(sizeof(struct g_object_tag) + strlen(t) + 1);			tag->mouse_event = g_dummy_mouse;			tag->draw = g_dummy_draw;			tag->destruct = g_tag_destruct;			strcpy(tag->name, t);			flush_pending_text_to_line(p);			add_object_to_line(p, &p->line, (struct g_object *)tag);			break;		case SP_CONTROL:			fc = va_arg(l, struct form_control *);			va_end(l);			g_html_form_control(p, fc);			break;		case SP_TABLE:			va_end(l);			return convert_table;		case SP_USED:			va_end(l);			return (void *)(my_intptr_t)!!p->data;		case SP_FRAMESET:			fsp = va_arg(l, struct frameset_param *);			va_end(l);			return create_frameset(p->data, fsp);		case SP_FRAME:			fp = va_arg(l, struct frame_param *);			va_end(l);			create_frame(fp);			break;		case SP_SCRIPT:			t = va_arg(l, unsigned char *);			va_end(l);			if (p->data) process_script(p->data, t);			break;		case SP_IMAGE:			im = va_arg(l, struct image_description *);			va_end(l);			do_image(p, im);			break;		case SP_NOWRAP:			va_end(l);			break;		case SP_REFRESH:			rp = va_arg(l, struct refresh_param *);			va_end(l);			html_process_refresh(p->data, rp->url, rp->time);			break;		case SP_SET_BASE:			t = va_arg(l, unsigned char *);			va_end(l);			if (p->data) set_base(p->data, t);			break;		case SP_HR:			hr = va_arg(l, struct hr_param *);			va_end(l);			g_hr(p, hr);			break;		default:			va_end(l);			internal("html_special: unknown code %d", c);	}	return NULL;}

/** * gedit_utils_get_ui_objects: * @filename: the path to the gtk builder file * @root_objects: a NULL terminated list of root objects to load or NULL to *                load all objects * @error_widget: a pointer were a #GtkLabel * @object_name: the name of the first object * @...: a pointer were the first object is returned, followed by more *       name / object pairs and terminated by NULL. * * This function gets the requested objects from a GtkBuilder ui file. In case * of error it returns FALSE and sets error_widget to a GtkLabel containing * the error message to display. * * Returns FALSE if an error occurs, TRUE on success. */gbooleangedit_utils_get_ui_objects (const gchar  *filename,			    gchar       **root_objects,			    GtkWidget   **error_widget,			    const gchar  *object_name,			    ...){	GtkBuilder *builder;	va_list args;	const gchar *name;	GError *error = NULL;	gchar *filename_markup;	gboolean ret = TRUE;	g_return_val_if_fail (filename != NULL, FALSE);	g_return_val_if_fail (error_widget != NULL, FALSE);	g_return_val_if_fail (object_name != NULL, FALSE);	filename_markup = g_markup_printf_escaped ("<i>%s</i>", filename);	*error_widget = NULL;	builder = gtk_builder_new ();		if (root_objects != NULL)	{		gtk_builder_add_objects_from_file (builder, 						   filename, 						   root_objects, 						   &error);	}	else	{		gtk_builder_add_from_file (builder,					   filename,					   &error);	}	if (error != NULL)	{		*error_widget = handle_builder_error (_("Unable to open ui file %s. Error: %s"),						      filename_markup,						      error->message);		g_error_free (error);		g_free (filename_markup);		g_object_unref (builder);		return FALSE;	}	va_start (args, object_name);	for (name = object_name; name; name = va_arg (args, const gchar *) )	{		GObject **gobj;		gobj = va_arg (args, GObject **);		*gobj = gtk_builder_get_object (builder, name);		if (!*gobj)		{			*error_widget = handle_builder_error (_("Unable to find the object '%s' inside file %s."), 							      name, 							      filename_markup),			ret = FALSE;			break;		}		/* we return a new ref for the root objects,		 * the others are already reffed by their parent root object */		if (root_objects != NULL)		{			gint i;			for (i = 0; root_objects[i] != NULL; ++i)			{				if ((strcmp (name, root_objects[i]) == 0))				{					g_object_ref (*gobj);				}			}		}	}	va_end (args);//.........这里部分代码省略.........

void TxtLogger::logSync(unsigned insid, unsigned short sync,                        unsigned turn,                         timespec time1,                         timespec time2, timespec sched_time,                         bool after, ...) {  assert(sync >= syncfunc::first_sync && sync < syncfunc::num_syncs    && "trying to log unknown synchronization operation!");//  if(!syncfunc::isSync(sync))//  {    if (sync == syncfunc::tern_thread_begin      || sync == syncfunc::tern_thread_end)    //  for tests, i need to know the thread_mapping    {      va_list args;      va_start(args, after);      ouf << syncfunc::getName(sync)          << " 0x" << hex << insid << dec          << ' ' << turn          << " " << dec << time1.tv_sec << ":"          << setfill('0') << setw(9) << time1.tv_nsec          << " " << dec << time2.tv_sec << ":"          << setfill('0') << setw(9) << time2.tv_nsec          << " " << dec << sched_time.tv_sec << ":"          << setfill('0') << setw(9) << sched_time.tv_nsec          << ' ' << tid          << hex << " 0x" << va_arg(args, uint64_t) << dec;      va_end(args);      ouf << "/n";      ouf.flush();      return;    }//    return;//  }  // YJF: why ignore prog_begin/end and thread_begin/end?  const char *suffix = "";  if(NumRecordsForSync(sync) == 2)    suffix = (after?"_second":"_first");  ouf << syncfunc::getName(sync) << suffix      << " 0x" << hex << setfill('0') << setw(8) << insid << dec      << ' ' << turn      << " " << dec << time1.tv_sec << ":"      << setfill('0') << setw(9) << time1.tv_nsec      << " " << dec << time2.tv_sec << ":"      << setfill('0') << setw(9) << time2.tv_nsec      << " " << dec << sched_time.tv_sec << ":"      << setfill('0') << setw(9) << sched_time.tv_nsec      << ' ' << tid;  va_list args;  va_start(args, after);  switch(sync) {    // log nothing, mostly for sched point.   case syncfunc::accept4:  case syncfunc::recv:  case syncfunc::recvfrom:  case syncfunc::recvmsg:  case syncfunc::select:  case syncfunc::poll:  case syncfunc::bind:  case syncfunc::listen:  case syncfunc::getsockopt:  case syncfunc::setsockopt:  case syncfunc::pipe:  case syncfunc::fcntl:  case syncfunc::shutdown:  case syncfunc::gethostbyname:  case syncfunc::gethostbyname_r:  case syncfunc::getaddrinfo:  case syncfunc::freeaddrinfo:  case syncfunc::gethostbyaddr:  case syncfunc::inet_ntoa:  case syncfunc::strtok:  case syncfunc::epoll_wait:  case syncfunc::epoll_create:  case syncfunc::epoll_ctl:  case syncfunc::sigwait:  case syncfunc::fgets:  case syncfunc::kill:  case syncfunc::fork:  case syncfunc::execv:  case syncfunc::sched_yield:  case syncfunc::wait:  case syncfunc::waitpid:  case syncfunc::tern_idle:  case syncfunc::tern_non_det_start:  case syncfunc::tern_non_det_end:    break;    // log one sync var (common case)  case syncfunc::pthread_mutex_init:  case syncfunc::pthread_mutex_destroy:  case syncfunc::pthread_mutex_lock:  case syncfunc::pthread_mutex_unlock:  case syncfunc::pthread_barrier_wait:  case syncfunc::pthread_barrier_destroy:  case syncfunc::pthread_cond_signal:  case syncfunc::pthread_cond_broadcast:  case syncfunc::sem_wait:  case syncfunc::sem_init://.........这里部分代码省略.........

//.........这里部分代码省略.........   1) "American National Standard for Programming Languages---C."      Section 5.4.2.1, "Translation Limits," p. 13.      Published by American National Standards Institute,      11 West 42nd St., New York, NY 10035. Copyright 1990.      -Author_and_Institution    N.J. Bachman   (JPL)  -Version    -CSPICE Version 1.0.1, 11-NOV-2006 (EDW)      Added "None." text to Particulars section, required for      API doc script (cspicehtml.pl) integrity checks.   -CSPICE Version 1.0.0, 29-MAR-1999 (NJB)-Index_Entries    minimum of integer values  -&*/{ /* Begin mini_c */   /*   Local variables   */      SpiceInt                next;   SpiceInt                retval;      SpiceInt                i;   /*   ap is the argument pointer.  Its type va_list is declared in the   header stdarg.h.   */   va_list                 ap;            /*   If there are no values to compare, return zero.     */    if ( n < 1 )   {      return ( 0 );   }      /*   Initialize the argument pointer with the last named argument, namely   n.   */      va_start ( ap, n );         /*   Initialize the minimum with the first value.   */      retval = va_arg ( ap, int );         /*   Now compute a running minimum of the values, if there are more.      By the way, we capture the argument in the variable next rather than   make the va_arg call as a MinVal argument, because the MinVal macro   would make the va_arg call twice.   */       for ( i = 1;  i < n;  i++ )   {      next   =  va_arg ( ap,     int  );      retval =  MinVal ( retval, next );   }         /*   Terminate the argument fetching process.   */      va_end ( ap );         /*   Return the value we've found.   */      return ( retval );      } /* End mini_c */

//.........这里部分代码省略.........	 * Reorder the strings into the message string based on argument	 * order.	 *	 * !!!	 * We ignore arguments that are out of order, i.e. if we don't find	 * an argument, we continue.  Assume (almost certainly incorrectly)	 * that whoever created the string knew what they were doing.	 *	 * !!!	 * Brute force "sort", but since we don't expect more than one or two	 * arguments in a string, the setup cost of a fast sort will be more	 * expensive than the loop.	 */	for (cnt1 = 1; cnt1 <= soff; ++cnt1)		for (cnt2 = 0; cnt2 < soff; ++cnt2)			if (cnt1 == str[cnt2].arg) {				memmove(s_rbp, str[cnt2].str, str[cnt2].prefix);				memmove(s_rbp + str[cnt2].prefix,				    str[cnt2].str + str[cnt2].prefix +				    str[cnt2].skip, str[cnt2].suffix);				s_rbp += str[cnt2].prefix + str[cnt2].suffix;				*s_rbp++ =				    gp == NULL ? DEFAULT_NOPRINT : gp->noprint;				break;			}	*s_rbp = '/0';	fmt = rbp;format:#endif	/* Format the arguments into the string. */        va_start(ap, fmt);	len = vsnprintf(mp, REM, fmt, ap);	va_end(ap);	if (len >= nlen)		goto retry;#ifndef NL_ARGMAX	if (soff == 0)		goto nofmt;	/*	 * Go through the resulting string, and, for each separator character	 * separated string, enter its new starting position and length in the	 * array.	 */	for (p = t = mp, cnt1 = 1,	    ch = gp == NULL ? DEFAULT_NOPRINT : gp->noprint; *p != '/0'; ++p)		if (*p == ch) {			for (cnt2 = 0; cnt2 < soff; ++cnt2)				if (str[cnt2].arg == cnt1)					break;			str[cnt2].str = t;			str[cnt2].prefix = p - t;			t = p + 1;			++cnt1;		}	/*	 * Reorder the strings once again, putting them back into the	 * message buffer.	 *	 * !!!	 * Note, the length of the message gets decremented once for	 * each substring, when we discard the separator character.	 */

void StringAppendF(std::string* dst, const char* format, ...) {    va_list ap;    va_start(ap, format);    StringAppendV(dst, format, ap);    va_end(ap);}

//.........这里部分代码省略.........          dec = (OpusDecoder*)ptr;          ret = opus_decoder_ctl(dec, request, value);       }       break;       case OPUS_GET_FINAL_RANGE_REQUEST:       {          int s;          opus_uint32 *value = va_arg(ap, opus_uint32*);          opus_uint32 tmp;          if (!value)          {             goto bad_arg;          }          *value = 0;          for (s=0;s<st->layout.nb_streams;s++)          {             OpusDecoder *dec;             dec = (OpusDecoder*)ptr;             if (s < st->layout.nb_coupled_streams)                ptr += align(coupled_size);             else                ptr += align(mono_size);             ret = opus_decoder_ctl(dec, request, &tmp);             if (ret != OPUS_OK) break;             *value ^= tmp;          }       }       break;       case OPUS_RESET_STATE:       {          int s;          for (s=0;s<st->layout.nb_streams;s++)          {             OpusDecoder *dec;             dec = (OpusDecoder*)ptr;             if (s < st->layout.nb_coupled_streams)                ptr += align(coupled_size);             else                ptr += align(mono_size);             ret = opus_decoder_ctl(dec, OPUS_RESET_STATE);             if (ret != OPUS_OK)                break;          }       }       break;       case OPUS_MULTISTREAM_GET_DECODER_STATE_REQUEST:       {          int s;          opus_int32 stream_id;          OpusDecoder **value;          stream_id = va_arg(ap, opus_int32);          if (stream_id<0 || stream_id >= st->layout.nb_streams)             ret = OPUS_BAD_ARG;          value = va_arg(ap, OpusDecoder**);          if (!value)          {             goto bad_arg;          }          for (s=0;s<stream_id;s++)          {             if (s < st->layout.nb_coupled_streams)                ptr += align(coupled_size);             else                ptr += align(mono_size);          }          *value = (OpusDecoder*)ptr;       }       break;       case OPUS_SET_GAIN_REQUEST:       {          int s;          /* This works for int32 params */          opus_int32 value = va_arg(ap, opus_int32);          for (s=0;s<st->layout.nb_streams;s++)          {             OpusDecoder *dec;             dec = (OpusDecoder*)ptr;             if (s < st->layout.nb_coupled_streams)                ptr += align(coupled_size);             else                ptr += align(mono_size);             ret = opus_decoder_ctl(dec, request, value);             if (ret != OPUS_OK)                break;          }       }       break;       default:          ret = OPUS_UNIMPLEMENTED;       break;   }   va_end(ap);   return ret;bad_arg:   va_end(ap);   return OPUS_BAD_ARG;}

/* Write string, similar to nputs, but with embedded formatting (#[]). */voidscreen_write_cnputs(struct screen_write_ctx *ctx,    ssize_t maxlen, struct grid_cell *gc, int utf8flag, const char *fmt, ...){	struct grid_cell	 lgc;	struct utf8_data	 utf8data;	va_list			 ap;	char			*msg;	u_char 			*ptr, *last;	size_t			 left, size = 0;	va_start(ap, fmt);	xvasprintf(&msg, fmt, ap);	va_end(ap);	memcpy(&lgc, gc, sizeof lgc);	ptr = msg;	while (*ptr != '/0') {		if (ptr[0] == '#' && ptr[1] == '[') {			ptr += 2;			last = ptr + strcspn(ptr, "]");			if (*last == '/0') {				/* No ]. Not much point in doing anything. */				break;			}			*last = '/0';			style_parse(gc, &lgc, ptr);			ptr = last + 1;			continue;		}		if (utf8flag && *ptr > 0x7f && utf8_open(&utf8data, *ptr)) {			ptr++;			left = strlen(ptr);			if (left < utf8data.size - 1)				break;			while (utf8_append(&utf8data, *ptr))				ptr++;			ptr++;			if (maxlen > 0 &&			    size + utf8data.width > (size_t) maxlen) {				while (size < (size_t) maxlen) {					screen_write_putc(ctx, gc, ' ');					size++;				}				break;			}			size += utf8data.width;			grid_cell_set(&lgc, &utf8data);			screen_write_cell(ctx, &lgc);		} else {			if (maxlen > 0 && size + 1 > (size_t) maxlen)				break;			size++;			screen_write_putc(ctx, &lgc, *ptr);			ptr++;		}	}	free(msg);}

void ble_send_message(uint8 msgid,...)            {    uint32 i;    uint32 u32;    uint16 u16;    uint8  u8;    struct ble_cmd_packet packet;    uint8 *b=(uint8 *)&packet.payload;                uint8 *hw;    uint8 *data_ptr=0;    uint16 data_len=0;    va_list va;    va_start(va,msgid);        i=apis[msgid].params;    packet.header=apis[msgid].hdr;    while(i)    {            switch(i&0xF)        {                    case 7:/*int32*/            case 6:/*uint32*/                u32=va_arg(va,uint32);                *b++=u32&0xff;u32>>=8;                *b++=u32&0xff;u32>>=8;                *b++=u32&0xff;u32>>=8;                *b++=u32&0xff;                break;            case 5:/*int16*/            case 4:/*uint16*/                u16=va_arg(va,unsigned);                *b++=u16&0xff;u16>>=8;                *b++=u16&0xff;                break;            case 3:/*int8*/            case 2:/*uint8*/                u8=va_arg(va,int);                *b++=u8&0xff;            break;                             case 9:/*string*/            case 8:/*uint8 array*/                data_len=va_arg(va,int);                *b++=data_len;                                        u16=data_len+packet.header.lolen;                packet.header.lolen=u16&0xff;                packet.header.type_hilen|=u16>>8;                                 data_ptr=va_arg(va,uint8*);            break;            case 10:/*hwaddr*/                hw=va_arg(va,uint8*);                *b++=*hw++;                *b++=*hw++;                *b++=*hw++;                *b++=*hw++;                *b++=*hw++;                *b++=*hw++;            break;            case 11:/*uint16 array*/                data_len=va_arg(va,int);                *b++=data_len&0xff;                        *b++=data_len>>8;                                        u16=data_len+packet.header.lolen;                packet.header.lolen=u16&0xff;                packet.header.type_hilen|=u16>>8;                                 data_ptr=va_arg(va,uint8*);            break;        }        i=i>>4;    }    va_end(va);        if(bglib_output)bglib_output(sizeof(struct ble_header)+apis[msgid].hdr.lolen,(uint8*)&packet,data_len,(uint8*)data_ptr);}

int parse_env_file(                const char *fname,                const char *separator, ...) {        int r = 0;        char *contents = NULL, *p;        assert(fname);        assert(separator);        if ((r = read_full_file(fname, &contents, NULL)) < 0)                return r;        p = contents;        for (;;) {                const char *key = NULL;                p += strspn(p, separator);                p += strspn(p, WHITESPACE);                if (!*p)                        break;                if (!strchr(COMMENTS, *p)) {                        va_list ap;                        char **value;                        va_start(ap, separator);                        while ((key = va_arg(ap, char *))) {                                size_t n;                                char *v;                                value = va_arg(ap, char **);                                n = strlen(key);                                if (!strneq(p, key, n) ||                                    p[n] != '=')                                        continue;                                p += n + 1;                                n = strcspn(p, separator);                                if (n >= 2 &&                                    strchr(QUOTES, p[0]) &&                                    p[n-1] == p[0])                                        v = strndup(p+1, n-2);                                else                                        v = strndup(p, n);                                if (!v) {                                        r = -ENOMEM;                                        va_end(ap);                                        goto fail;                                }                                if (v[0] == '/0') {                                        /* return empty value strings as NULL */                                        free(v);                                        v = NULL;                                }                                free(*value);                                *value = v;                                p += n;                                r ++;                                break;                        }                        va_end(ap);                }                if (!key)                        p += strcspn(p, separator);        }