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

char* rrdgetenv(long argc, const char **args) {	char buf[128];	const char* envvar;	if (argc != 1) {		return stralloc("[ERROR: getenv failed because it did not "						"get 1 argument only]");	};	envvar = getenv(args[0]);	if (envvar) {		return stralloc(envvar);	} else {                snprintf(buf, sizeof(buf), "[ERROR:_getenv_'%s'_failed", args[0]);                return stralloc(buf);	}}

/* rrd interface to the variable function putvar() */char*rrdsetvarconst(long argc, const char **args){	if (argc >= 2)	{		const char* result = putvar(args[0], args[1], 1 /* const */);		if (result) {			/* setvar does not return the value set */			return stralloc("");		}		return stralloc("[ERROR: putvar failed]");	}	return stralloc("[ERROR: putvar failed because not enough arguments "					"were defined]");}

/* Put a variable into the variable store. If a variable by that   name exists, it's value is overwritten with the new value unless it was   marked as 'const' (initialized by RRD::SETCONSTVAR).   Returns a copy the newly allocated value on success, NULL on error. */static const char*putvar(const char* name, const char* value, int is_const){	int i;	for (i=0; i < (int)varheap_size && varheap[i].name; i++) {		if (0 == strcmp(name, varheap[i].name)) {			/* overwrite existing entry */			if (varheap[i].is_const) {#ifdef			DEBUG_VARS				printf("<!-- setver(%s, %s): not assigning: "						"const variable -->/n", name, value);#				endif				return varheap[i].value;			}#ifdef		DEBUG_VARS			printf("<!-- setvar(%s, %s): overwriting old value (%s) -->/n",					name, value, varheap[i].value);#endif			/* make it possible to promote a variable to readonly */			varheap[i].is_const = is_const;			free((char*)varheap[i].value);			varheap[i].value = stralloc(value);			return varheap[i].value;		}	}	/* no existing variable found by that name, add it */	if (i == (int)varheap_size) {		/* ran out of heap: resize heap to double size */		size_t new_size = varheap_size * 2;		varheap = (vardata*)(realloc(varheap, sizeof(vardata) * new_size));		if (!varheap) {			fprintf(stderr, "ERROR: Unable to realloc variable heap/n");			return NULL;		}		/* initialize newly allocated memory */;		memset(&varheap[varheap_size], 0, sizeof(vardata) * varheap_size);		varheap_size = new_size;	}	varheap[i].is_const = is_const;	varheap[i].name  = stralloc(name);	varheap[i].value = stralloc(value);#ifdef		DEBUG_VARS	printf("<!-- setvar(%s, %s): adding new variable -->/n", name, value);#endif	return varheap[i].value;}

char *xstralloccat(char *base,char *add,int line,char *file){	if(diagmisc && !diagallocx)	{		prterr("DIAG xstralloccat String Allocated at line [%d] program [%s].",line,file);		}	if(base!=NULL)	{		if(diagallocx && diagmisc)		{					base=(char *)xRrealloc(base,RDAstrlen(base)+RDAstrlen(add)+1,line,file);		} else {			base=(char *)Rrealloc(base,RDAstrlen(base)+RDAstrlen(add)+1);		}		if(base!=NULL) strcat(base,add);	} else {		if(diagallocx && diagmisc)		{					base=xstralloc(add,line,file);		} else {			base=stralloc(add);		}	}	return(base);}

Wt::Auth::User RDAUserDatabase::findWithAuthToken (const std::string &hash)  const{	char *ud=NULL,delflag=FALSE;  /*   * David: find a user associated with a token with given hash value, taking   * into account that it should not be expired   */	if(SEC_TOKEN_FILENO==(-1))	{    		return;	}	ZERNRD(SEC_TOKEN_FILENO);	FINDFLDSETSTRING(SEC_TOKEN_FILENO,"TOKEN",hash.c_str());	if(!EQLNRD(SEC_TOKEN_FILENO,1))	{		FINDFLDGETCHAR(SEC_TOKEN_FILENO,"DELETEFLAG",&delflag);		if(!delflag)		{			FINDFLDGETSTRING(SEC_TOKEN_FILENO,"USER IDENTIFICATION",&ud);			USERLOGIN=stralloc(ud);			const std::string u(ud);/*			std::cerr << "User Identification [" << ud << "]" << std::endl;*/  			return Wt::Auth::User(u, *this);		} else {    			return Wt::Auth::User();		}	} else {    		return Wt::Auth::User();	}}

ipp_attribute_t *			ippAddResolutions(ipp_t      *ipp,	        	  ipp_tag_t  group,			  const char *name,			  int        num_values,		  ipp_res_t  units,			  const int  *xres,			  const int  *yres)	{  int			i;		  ipp_attribute_t	*attr;		  ipp_value_t		*value;		  if (!ipp || !name || num_values < 1)    return (NULL);  if ((attr = _ippAddAttr(ipp, num_values)) == NULL)    return (NULL);  attr->name      = stralloc(name);  attr->group_tag = group;  attr->value_tag = IPP_TAG_RESOLUTION;  if (xres != NULL && yres != NULL)    for (i = 0, value = attr->values;	 i < num_values;	 i ++, value ++)    {      value->resolution.xres  = xres[i];      value->resolution.yres  = yres[i];      value->resolution.units = units;    }  return (attr);}

ipp_attribute_t *			ippAddRanges(ipp_t      *ipp,		             ipp_tag_t  group,			     const char *name,			     int        num_values,		     const int  *lower,			     const int  *upper)		{  int			i;		  ipp_attribute_t	*attr;		  ipp_value_t		*value;		  if (!ipp || !name || num_values < 1)    return (NULL);  if ((attr = _ippAddAttr(ipp, num_values)) == NULL)    return (NULL);  attr->name      = stralloc(name);  attr->group_tag = group;  attr->value_tag = IPP_TAG_RANGE;  if (lower != NULL && upper != NULL)    for (i = 0, value = attr->values;	 i < num_values;	 i ++, value ++)    {      value->range.lower = lower[i];      value->range.upper = upper[i];    }  return (attr);}

char     *rrdgetinternal(    long argc,    const char **args){    if (argc == 1) {        if (strcasecmp(args[0], "VERSION") == 0) {            return stralloc(PACKAGE_VERSION);        } else if (strcasecmp(args[0], "COMPILETIME") == 0) {            return stralloc(__DATE__ " " __TIME__);        } else {            return stralloc("[ERROR: internal unknown argument]");        }    } else {        return stralloc("[ERROR: internal expected 1 argument]");    }}

char     *rrdgoodfor(    long argc,    const char **args){    if (argc == 1) {        goodfor = atol(args[0]);    } else {        return stralloc("[ERROR: goodfor expected 1 argument]");    }    if (goodfor == 0) {        return stralloc("[ERROR: goodfor value must not be 0]");    }    return stralloc("");}

static void DEF_MANAGE_SCANS(){	RDAdefault *def=NULL;	char *defdir=NULL;	char *temp1=NULL;	def=RDAdefaultNEW("ARCHIVE","MANAGE SCANS");	if(def!=NULL)	{		def->input_focus=stralloc("ADD SCAN DIRECTORIES");		defdir=Rmalloc(RDAstrlen(CURRENTDIRECTORY)+RDAstrlen(module)+12);#ifndef WIN32		sprintf(defdir,"%s/rda/%s.DEF",CURRENTDIRECTORY,module);#endif#ifdef WIN32		sprintf(defdir,"%s//rda//%s.DEF",CURRENTDIRECTORY,module);#endif		if(writedefaultbin(defdir,def))		{			if(temp1!=NULL) Rfree(temp1);			temp1=Rmalloc(12+7+100+1);			sprintf(temp1,"SCREEN DEFAULT WRITE ERROR: Module [ARCHIVE] Screen [MANAGE SCANS], Can Not Save Screen Defaults!");			prterr(temp1);			if(errorlist!=NULL)			{				addERRlist(&errorlist,temp1);			}			if(temp1!=NULL) Rfree(temp1);		}		if(defdir!=NULL) Rfree(defdir);		if(def!=NULL) FreeRDAdefault(def);	}}

static int cfg_do_set(CONFIG *table,char *item,char *value,int copy,    void *context){    CONFIG *walk;    for (walk = table; walk->type != cft_end; walk++) {	if (walk->name && !strcasecmp(walk->name,item)) {	    if (value && walk->type != cft_strg)		cfg_error("'%s' doesn't have a value",walk->name);	    if (!value && walk->type == cft_strg)		cfg_error("Value expected for '%s'",walk->name);	    if (walk->data) {		if (walk->context == context)		    cfg_error("Duplicate entry '%s'",walk->name);		else {		    warn("Ignoring entry '%s'",walk->name);		    if (!copy) free(value);		    return 1;		}	    }	    if (walk->type == cft_flag) walk->data = &flag_set;	    else if (walk->type == cft_strg)		    walk->data = copy ? stralloc(value) : value; 	    walk->context = context;	    if (walk->action) ((void (*)(void)) walk->action)();	    break;	}	if (walk->type == cft_link) walk = ((CONFIG *) walk->action)-1;    }    if (walk->type != cft_end) return 1;    cfg_return(item,value);    return 0;}

int main(int argc,char **argv)#endif{	if(InitializeSubsystems(argc,argv,module,"ITRON IMPORT FILE")) 	{		RDAAPPMAINLOOP();		return;	}	if((utbcus=APPOPNNRD(module,"UTBCUS",TRUE,FALSE))==(-1)) return;	if((utbsvc=APPOPNNRD(module,"UTBSVC",TRUE,TRUE))==(-1)) return;	if((utbmtr=APPOPNNRD(module,"UTBMTR",TRUE,FALSE))==(-1)) return;	if((utbrte=APPOPNNRD(module,"UTBRTE",TRUE,TRUE))==(-1)) return;	MAINrsrc=RDArsrcNEW(module,"ITRON IMPORT FILE");	addDFincvir(MAINrsrc,module,"UTBCUS",NULL,utbcus);	addDFincvir(MAINrsrc,module,"UTBSVC",NULL,utbsvc);	addDFincvir(MAINrsrc,module,"UTBMTR",NULL,utbmtr);	addDFincvir(MAINrsrc,module,"UTBRTE",NULL,utbrte);	ITRON_FILENAME=stralloc("UPLOAD.DAT");	addstdrsrc(MAINrsrc,"FILENAME",VARIABLETEXT,0,ITRON_FILENAME,TRUE);	DefaultScreens(MAINrsrc);	addbtnrsrc(MAINrsrc,"DEFAULTS",TRUE,SaveDefaults,NULL);	addrfcbrsrc(MAINrsrc,"SELECT",TRUE,ReadItron,NULL);	addrfexrsrc(MAINrsrc,"QUIT",TRUE,quitfunc,NULL);	addrfcbrsrc(MAINrsrc,"HELP",TRUE,screenhelp,NULL);	addrfcbrsrc(MAINrsrc,"PRINT RESOURCES",TRUE,printrsrcs,NULL);	computeallSCRNvirtuals(MAINrsrc);	APPmakescrn(MAINrsrc,TRUE,quitfunc,NULL,TRUE);	RDAAPPMAINLOOP();}

intcd_dir(    char *	path_on_disk,    char *	default_dir,    int		verbose){    char *dir = NULL;    char *s;    int nb_found;    int result;    size_t i;    DIR_ITEM *ditem;    if ((s = validate_regexp(path_on_disk)) != NULL) {	result = set_directory(default_dir, verbose);	return result;    }    nb_found = 0;    for (ditem=get_dir_list(); ditem!=NULL && nb_found <= 1; 			       ditem=get_next_dir_item(ditem))    {	if (match(path_on_disk, ditem->path))	{	    i = strlen(ditem->path);	    if((i > 0 && ditem->path[i-1] == '/')               || (i > 1 && ditem->path[i-2] == '/' && ditem->path[i-1] == '.'))            {   /* It is a directory */		char *dir1, *dir2;		nb_found++;		dir = newstralloc(dir,ditem->path);		if(dir[strlen(dir)-1] == '/')		    dir[strlen(dir)-1] = '/0'; /* remove last / */		/* remove everything before the last / */		dir1 = strrchr(dir,'/');		if (dir1) {		    dir1++;		    dir2 = stralloc(dir1);		    amfree(dir);		    dir = dir2;		}	    }	}    }    if(nb_found==0) {	result = set_directory(default_dir, verbose);    }    else if(nb_found==1) {	result = set_directory(dir, verbose);    }    else {	g_printf(_("Too many directories matching '%s'/n"), default_dir);	result = 0;    }    amfree(dir);    return result;}

void setCFI_IDENT(Connection *Conn,int cid[2],int sv){	CStr(env,1024);	IGNRETZ pipe(cid);	sprintf(env,"CFI_IDENT=%d",cid[1]);	putenv(stralloc(env));}

ipp_attribute_t	*			ippAddOctetString(ipp_t      *ipp,	                  ipp_tag_t  group,	                  const char *name,	                  const void *data,			  int        datalen)	{  ipp_attribute_t	*attr;		  if (ipp == NULL || name == NULL)    return (NULL);  if ((attr = _ippAddAttr(ipp, 1)) == NULL)    return (NULL);  attr->name                     = stralloc(name);  attr->group_tag                = group;  attr->value_tag                = IPP_TAG_STRING;  attr->values[0].unknown.length = datalen;  if (data)  {    if ((attr->values[0].unknown.data = malloc(datalen)) == NULL)    {      ippDeleteAttribute(ipp, attr);      return (NULL);    }    memcpy(attr->values[0].unknown.data, data, datalen);  }  return (attr);}

ipp_attribute_t *			ippAddBooleans(ipp_t      *ipp,		               ipp_tag_t  group,		       const char *name,		       int        num_values,		       const char *values)	{  int			i;		  ipp_attribute_t	*attr;		  ipp_value_t		*value;		  if (!ipp || !name || num_values < 1)    return (NULL);  if ((attr = _ippAddAttr(ipp, num_values)) == NULL)    return (NULL);  attr->name      = stralloc(name);  attr->group_tag = group;  attr->value_tag = IPP_TAG_BOOLEAN;  if (values != NULL)    for (i = 0, value = attr->values;	 i < num_values;	 i ++, value ++)      value->boolean = values[i];  return (attr);}

char     *drawgraph(    long argc,    const char **args){    int       i, xsize, ysize;    double    ymin, ymax;    for (i = 0; i < argc; i++)        if (strcmp(args[i], "--imginfo") == 0 || strcmp(args[i], "-g") == 0)            break;    if (i == argc) {        args[argc++] = "--imginfo";        args[argc++] = "<IMG SRC=/"./%s/" WIDTH=/"%lu/" HEIGHT=/"%lu/">";    }    calfree();    if (rrd_graph        (argc + 1, (char **) args - 1, &calcpr, &xsize, &ysize, NULL, &ymin,         &ymax) != -1) {        return stralloc(calcpr[0]);    } else {        if (rrd_test_error()) {            const size_t len = strlen(rrd_get_error()) + DS_NAM_SIZE;            char *err = malloc(len);            snprintf(err, len, "[ERROR: %s]", rrd_get_error());            rrd_clear_error();            return err;        }    }    return NULL;}

ipp_attribute_t *			ippAddResolution(ipp_t      *ipp,	        	 ipp_tag_t  group,			 const char *name,			 ipp_res_t  units,			 int        xres,			 int        yres)	{  ipp_attribute_t	*attr;		  if (!ipp || !name)    return (NULL);  if ((attr = _ippAddAttr(ipp, 1)) == NULL)    return (NULL);  attr->name                       = stralloc(name);  attr->group_tag                  = group;  attr->value_tag                  = IPP_TAG_RESOLUTION;  attr->values[0].resolution.xres  = xres;  attr->values[0].resolution.yres  = yres;  attr->values[0].resolution.units = units;  return (attr);}

char           *inputline(){	/* and removes comment, newline, beginning and trailing blanks */	/* used to get the TITLE line */#if __TURBOC__ || SYSV || VMS#define index strchr#endif	char            *cp;	int             i;	buf[0] = '/0';	cp = Gets(buf);	i = strlen(buf);	if (i)		buf[i - 1] = '/0';	if ((cp = index(buf, '!')) != (char *) 0) {		*cp-- = '/0';	}	while (cp >= buf && isspace(*cp)) {		*cp-- = '/0';	}	/*EMPTY*/	for (cp = buf; *cp != '/0' && isspace(*cp); cp++){		;	}	return stralloc(cp, (char *) 0);}

ipp_attribute_t *			ippAddCollections(    ipp_t       *ipp,			    ipp_tag_t   group,			    const char  *name,			    int         num_values,		    const ipp_t **values)		{  int			i;		  ipp_attribute_t	*attr;		  ipp_value_t		*value;		  if (!ipp || !name || num_values < 1)    return (NULL);  if ((attr = _ippAddAttr(ipp, num_values)) == NULL)    return (NULL);  attr->name      = stralloc(name);  attr->group_tag = group;  attr->value_tag = IPP_TAG_BEGIN_COLLECTION;  if (values != NULL)  {    for (i = 0, value = attr->values;	 i < num_values;	 i ++, value ++)    {      value->collection = (ipp_t *)values[i];      value->collection->use ++;    }  }  return (attr);}

/* In running mode (not startup mode), get a command from driver and   deal with it. */static gboolean process_driver_command(taper_state_t * state) {    struct cmdargs *cmdargs;    char * q;    /* This will return QUIT if driver has died. */    cmdargs = getcmd();    switch (cmdargs->cmd) {    case PORT_WRITE:        /*         * PORT-WRITE         *   handle         *   hostname         *   features         *   diskname         *   level         *   datestamp         *   splitsize         *   split_diskbuffer         */        process_port_write(state, cmdargs);        break;            case FILE_WRITE:        /*         * FILE-WRITE         *   handle         *   filename         *   hostname         *   features         *   diskname         *   level         *   datestamp         *   splitsize         */        process_file_write(state, cmdargs);        break;            case QUIT:	free_cmdargs(cmdargs);	if (state->device && state->device->volume_label) {	    log_add(L_INFO, "tape %s kb %lld fm %d [OK]/n",		    state->device->volume_label,		    (long long)((state->total_bytes+(off_t)1023) / (off_t)1024),		    state->device->file);	}        return send_quitting(state);    default:        if (cmdargs->argc >= 1) {            q = quote_string(cmdargs->argv[0]);        } else {            q = stralloc("(no input?)");        }        putresult(BAD_COMMAND, "%s/n", q);        amfree(q);        break;    }    free_cmdargs(cmdargs);    return TRUE;}

char* rrdsetenv(long argc, const char **args) {	if (argc >= 2) {		char *xyz = malloc((strlen(args[0]) + strlen(args[1]) + 2));		if (xyz == NULL) {			return stralloc("[ERROR: allocating setenv buffer]");		};		sprintf(xyz, "%s=%s", args[0], args[1]);		if(putenv(xyz) == -1) {			free(xyz);			return stralloc("[ERROR: failed to do putenv]");		}; 	        return stralloc("");	}	return stralloc("[ERROR: setenv failed because not enough "		  			"arguments were defined]");}

ipp_attribute_t *			ippAddIntegers(ipp_t      *ipp,		               ipp_tag_t  group,		       ipp_tag_t  type,			       const char *name,		       int        num_values,		       const int  *values)	{  int			i;		  ipp_attribute_t	*attr;		  ipp_value_t		*value;		  if (!ipp || !name || num_values < 1)    return (NULL);  if ((attr = _ippAddAttr(ipp, num_values)) == NULL)    return (NULL);  attr->name      = stralloc(name);  attr->group_tag = group;  attr->value_tag = type;  if (values != NULL)    for (i = 0, value = attr->values;	 i < num_values;	 i ++, value ++)      value->integer = values[i];  return (attr);}

dle_t *amxml_parse_node_FILE(    FILE *file,    char **errmsg){    amgxml_t             amgxml = {NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL};    GMarkupParser        parser = {&amstart_element, &amend_element, &amtext,				   NULL, NULL};    GMarkupParseFlags    flags = 0;    GMarkupParseContext *context;    GError		*gerror = NULL;    char                *line;    (void)errmsg;    context = g_markup_parse_context_new(&parser, flags, &amgxml, NULL);    while ((line = agets(file)) != NULL && !gerror) {	g_markup_parse_context_parse(context, line, strlen(line), &gerror);	amfree(line);    }    if (!gerror)	g_markup_parse_context_end_parse(context, &gerror);    g_markup_parse_context_free(context);    if (gerror) {	if (errmsg)	    *errmsg = stralloc(gerror->message);	g_error_free(gerror);    }    return amgxml.dles;}

const char *paramAbsPath(PCStr(param)){	int plen;	int pi;	CStr(px,1024);	const char **apath;	if( strncmp(param,"DGROOT=",plen=7) == 0 ){		pi = PX_DGROOT;		apath = &DELEGATE_DGROOT;	}else{		return 0;	}	if( isFullpath(param+plen) ){		return 0;	}	if( absPARAMS[pi] ){		return absPARAMS[pi];	}	if( !isFullpath(*apath) ){		return 0;	}	strcpy(px,param);	Xstrcpy(DVStr(px,plen),*apath);	absPARAMS[pi] = stralloc(px);	return absPARAMS[pi];}

dle_t *amxml_parse_node_CHAR(    char *txt,    char **errmsg){    amgxml_t             amgxml = {NULL, NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL};    GMarkupParser        parser = {&amstart_element, &amend_element, &amtext,				   NULL, NULL};    GMarkupParseFlags    flags = 0;    GMarkupParseContext *context;    GError		*gerror = NULL;    (void)errmsg;    context = g_markup_parse_context_new(&parser, flags, &amgxml, NULL);    g_markup_parse_context_parse(context, txt, strlen(txt), &gerror);    if (!gerror)	g_markup_parse_context_end_parse(context, &gerror);    g_markup_parse_context_free(context);    if (gerror) {	if (errmsg)	    *errmsg = stralloc(gerror->message);	g_error_free(gerror);    }    return amgxml.dles;	}

char* cgigetq(long argc, const char **args){  if (argc>= 1){    char *buf = rrdstrip(rrdcgiGetValue(rrdcgiArg,args[0]));    char *buf2;    char *c,*d;    int  qc=0;    if (buf==NULL) return NULL;    for(c=buf;*c != '/0';c++)      if (*c == '"') qc++;    if ((buf2 = malloc((strlen(buf) + 4 * qc + 4))) == NULL) {	perror("Malloc Buffer");	exit(1);    };    c=buf;    d=buf2;    *(d++) = '"';    while(*c != '/0'){	if (*c == '"') {	    *(d++) = '"';	    *(d++) = '/'';	    *(d++) = '"';	    *(d++) = '/'';	} 	*(d++) = *(c++);    }    *(d++) = '"';    *(d) = '/0';    free(buf);    return buf2;  }  return stralloc("[ERROR: not enough argument for RRD::CV::QUOTE]");}

/* Quote str for shell interpretation, being conservative. * Any non-alphanumeric charcacters other than '.' and '/' * trigger surrounding single quotes, and single quotes and * backslashes within those single quotes are escaped. */static char *quote_dumpspec_string(char *str){    char *rv;    char *p, *q;    int len = 0;    int need_single_quotes = 0;    if (!str[0])	return stralloc("''"); /* special-case the empty string */    for (p = str; *p; p++) {        if (!isalnum((int)*p) && *p != '.' && *p != '/') need_single_quotes=1;        if (*p == '/'' || *p == '//') len++; /* extra byte for '/' */        len++;    }    if (need_single_quotes) len += 2;    q = rv = malloc(len+1);    if (need_single_quotes) *(q++) = '/'';    for (p = str; *p; p++) {        if (*p == '/'' || *p == '//') *(q++) = '//';        *(q++) = *p;    }    if (need_single_quotes) *(q++) = '/'';    *(q++) = '/0';    return rv;}

printf_arglist_function1(void log_add, logtype_t, typ, char *, format){    va_list argp;    char *leader = NULL;    char *xlated_fmt = gettext(format);    char linebuf[STR_SIZE];    size_t n;    static gboolean in_log_add = 0;    /* avoid recursion */    if (in_log_add)	return;    /* format error message */    if((int)typ <= (int)L_BOGUS || (int)typ > (int)L_MARKER) typ = L_BOGUS;    if(multiline > 0) {	leader = stralloc("  ");		/* continuation line */    } else {	leader = vstralloc(logtype_str[(int)typ], " ", get_pname(), " ", NULL);    }    arglist_start(argp, format);    /* use sizeof(linebuf)-2 to save space for a trailing newline */    g_vsnprintf(linebuf, SIZEOF(linebuf)-2, xlated_fmt, argp);						/* -1 to allow for '/n' */    arglist_end(argp);    /* avoid recursive call from error() */    in_log_add = 1;    /* append message to the log file */    if(multiline == -1) open_log();    if (full_write(logfd, leader, strlen(leader)) < strlen(leader)) {	error(_("log file write error: %s"), strerror(errno));	/*NOTREACHED*/    }    amfree(leader);    /* add a newline if necessary */    n = strlen(linebuf);    if(n == 0 || linebuf[n-1] != '/n') linebuf[n++] = '/n';    linebuf[n] = '/0';    if (full_write(logfd, linebuf, n) < n) {	error(_("log file write error: %s"), strerror(errno));	/*NOTREACHED*/    }    if(multiline != -1) multiline++;    else close_log();    in_log_add = 0;}