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

static size_t obj_desc_pval(const object_type *o_ptr, char *buf, size_t max,	size_t end, bool spoil){	bitflag f[OF_SIZE], f2[OF_SIZE];	int i;	bool any = FALSE;	object_flags(o_ptr, f);	create_mask(f2, FALSE, OFT_PVAL, OFT_STAT, OFT_MAX);	if (!of_is_inter(f, f2)) return end;	strnfcat(buf, max, &end, " <");	for (i = 0; i < o_ptr->num_pvals; i++) {		if (spoil || object_this_pval_is_visible(o_ptr, i)) {			if (any)				strnfcat(buf, max, &end, ", ");			strnfcat(buf, max, &end, "%+d", o_ptr->pval[i]);			any = TRUE;		}	}	strnfcat(buf, max, &end, ">");	return end;}

static size_t obj_desc_inscrip(const object_type *o_ptr, char *buf, size_t max, size_t end){	const char *u[4] = { 0, 0, 0, 0 };	int n = 0;	int feel = object_pseudo(o_ptr);	bitflag flags_known[OF_SIZE];	object_flags_known(o_ptr, flags_known);	/* Get inscription */	if (o_ptr->note)		u[n++] = quark_str(o_ptr->note);	/* Use special inscription, if any */	if (!object_is_known(o_ptr) && feel)	{		/* cannot tell excellent vs strange vs splendid until wield */		if (!object_was_worn(o_ptr) && ego_item_p(o_ptr))			u[n++] = "ego";		else			u[n++] = inscrip_text[feel];	}	else if ((o_ptr->ident & IDENT_EMPTY) && !object_is_known(o_ptr))		u[n++] = "empty";	else if (!object_is_known(o_ptr) && object_was_worn(o_ptr))	{		if (wield_slot(o_ptr) == INVEN_WIELD || wield_slot(o_ptr) == INVEN_BOW)			u[n++] = "wielded";		else u[n++] = "worn";	}	else if (!object_is_known(o_ptr) && object_was_fired(o_ptr))		u[n++] = "fired";	else if (!object_flavor_is_aware(o_ptr) && object_flavor_was_tried(o_ptr))		u[n++] = "tried";	/* Note curses */	if (flags_test(flags_known, OF_SIZE, OF_CURSE_MASK, FLAG_END))		u[n++] = "cursed";	/* Note squelch */	if (squelch_item_ok(o_ptr))		u[n++] = "squelch";	if (n)	{		int i;		for (i = 0; i < n; i++)		{			if (i == 0)				strnfcat(buf, max, &end, " {");			strnfcat(buf, max, &end, "%s", u[i]);			if (i < n-1)				strnfcat(buf, max, &end, ", ");		}		strnfcat(buf, max, &end, "}");	}	return end;}

static void path_process(char *buf, size_t len, size_t *cur_len, const char *path){#if defined(SET_UID) || defined(USE_PRIVATE_PATHS)	/* Home directory on Unixes */	if (path[0] == '~')	{		const char *s;		const char *username = path + 1;		struct passwd *pw;		char user[128];		/* Look for non-user portion of the file */		s = strstr(username, PATH_SEP);		if (s)		{			int i;			/* Keep username a decent length */			if (s >= username + sizeof(user)) return;			for (i = 0; username < s; ++i) user[i] = *username++;			user[i] = '/0';			username = user;		}#ifndef MACH_O_CARBON		/* Look up a user (or "current" user) */		pw = username[0] ? getpwnam(username) : getpwuid(getuid());#else /* MACH_O_CARBON */		/* On Macs getlogin() can incorrectly return root, so get the username via system frameworks */		CFStringRef cfusername = CSCopyUserName(TRUE);		CFIndex cfbufferlength = CFStringGetMaximumSizeForEncoding(CFStringGetLength(cfusername), kCFStringEncodingUTF8) + 1;		char *macusername = mem_alloc(cfbufferlength);		CFStringGetCString(cfusername, macusername, cfbufferlength, kCFStringEncodingUTF8);		CFRelease(cfusername);		/* Look up the user */		pw = getpwnam(macusername);		mem_free(macusername);#endif /* !MACH_O_CARBON */		if (!pw) return;		/* Copy across */		strnfcat(buf, len, cur_len, "%s%s", pw->pw_dir, PATH_SEP);		if (s) strnfcat(buf, len, cur_len, "%s", s);	}	else#endif	{		strnfcat(buf, len, cur_len, "%s", path);	}}

/** * Describe charges or charging status for re-usable items with magic effects */static size_t obj_desc_charges(const struct object *obj, char *buf, size_t max,							   size_t end, int mode){	bool aware = object_flavor_is_aware(obj) || (mode & ODESC_STORE);	/* Wands and Staffs have charges */	if (aware && tval_can_have_charges(obj))		strnfcat(buf, max, &end, " (%d charge%s)", obj->pval,				 PLURAL(obj->pval));	/* Charging things */	else if (obj->timeout > 0)	{		if (tval_is_rod(obj) && obj->number > 1)		{			strnfcat(buf, max, &end, " (%d charging)", number_charging(obj));		}		/* Artifacts, single rods */		else if (!(tval_is_light(obj) && !obj->artifact))		{			strnfcat(buf, max, &end, " (charging)");		}	}	return end;}

/** * Add player-defined inscriptions or game-defined descriptions */static size_t obj_desc_inscrip(const struct object *obj, char *buf,							   size_t max, size_t end){	const char *u[4] = { 0, 0, 0, 0 };	int n = 0;	int feel = object_pseudo(obj);	bitflag flags_known[OF_SIZE], f2[OF_SIZE];	object_flags_known(obj, flags_known);	/* Get inscription */	if (obj->note)		u[n++] = quark_str(obj->note);	/* Use special inscription, if any */	if (!object_is_known(obj)) {		if (feel) {			/* cannot tell excellent vs strange vs splendid until wield */			if (!object_was_worn(obj) && obj->ego)				u[n++] = "ego";			else				u[n++] = inscrip_text[feel];		} 		else if (tval_can_have_charges(obj) && (obj->pval == 0))			u[n++] = "empty";		else if (object_was_worn(obj))			u[n++] = (tval_is_weapon(obj)) ? "wielded" : "worn";		else if (!object_flavor_is_aware(obj) &&				 object_flavor_was_tried(obj))			u[n++] = "tried";	}	/* Note curses */	create_mask(f2, FALSE, OFT_CURSE, OFT_MAX);	if (of_is_inter(flags_known, f2))		u[n++] = "cursed";	/* Note ignore */	if (ignore_item_ok(obj))		u[n++] = "ignore";	if (n)	{		int i;		for (i = 0; i < n; i++)		{			if (i == 0)				strnfcat(buf, max, &end, " {");			strnfcat(buf, max, &end, "%s", u[i]);			if (i < n-1)				strnfcat(buf, max, &end, ", ");		}		strnfcat(buf, max, &end, "}");	}	return end;}

/** * ------------------------------------------------------------------------ * The rolling bit of the roller. * ------------------------------------------------------------------------ */static enum birth_stage roller_command(bool first_call){	char prompt[80] = "";	size_t promptlen = 0;	struct keypress ch;	enum birth_stage next = BIRTH_ROLLER;	/* Used to keep track of whether we've rolled a character before or not. */	static bool prev_roll = FALSE;	/* Display the player - a bit cheaty, but never mind. */	display_player(0);	if (first_call)		prev_roll = FALSE;	/* Prepare a prompt (must squeeze everything in) */	strnfcat(prompt, sizeof (prompt), &promptlen, "['r' to reroll");	if (prev_roll) 		strnfcat(prompt, sizeof(prompt), &promptlen, ", 'p' for previous roll");	strnfcat(prompt, sizeof (prompt), &promptlen, " or 'Enter' to accept]");	/* Prompt for it */	prt(prompt, Term->hgt - 1, Term->wid / 2 - promptlen / 2);		/* Prompt and get a command */	ch = inkey();	/* Analyse the command */	if (ch.code == ESCAPE) {		/* Back out */		next = BIRTH_BACK;	} else if (ch.code == KC_ENTER) {		/* 'Enter' accepts the roll */		next = BIRTH_NAME_CHOICE;	} else if ((ch.code == ' ') || (ch.code == 'r')) {		/* Reroll this character */		cmdq_push(CMD_ROLL_STATS);		prev_roll = TRUE;	} else if (prev_roll && (ch.code == 'p')) {		/* Previous character */		cmdq_push(CMD_PREV_STATS);	} else if (ch.code == KTRL('X')) {		/* Quit */		quit(NULL);	} else if (ch.code == '?') {		/* Help XXX */		do_cmd_help();	} else {		/* Nothing handled directly here */		bell("Illegal roller command!");	}	return next;}

/* * Print an artifact activation message. * * In order to support randarts, with scrambled names, we re-write * the message to replace instances of {name} with the artifact name * and instances of {kind} with the type of object. * * This code deals with plural and singular forms of verbs correctly * when encountering {s}, though in fact both names and kinds are * always singular in the current code (gloves are "Set of" and boots * are "Pair of") */static void activation_message(object_type *o_ptr, const char *message){	char buf[1024] = "/0";	const char *next;	const char *s;	const char *tag;	const char *in_cursor;	size_t end = 0;	in_cursor = message;	next = strchr(in_cursor, '{');	while (next)	{		/* Copy the text leading up to this { */		strnfcat(buf, 1024, &end, "%.*s", next - in_cursor, in_cursor); 		s = next + 1;		while (*s && isalpha((unsigned char) *s)) s++;		if (*s == '}')		/* Valid tag */		{			tag = next + 1; /* Start the tag after the { */			in_cursor = s + 1;			switch(art_tag_lookup(tag))			{			case ART_TAG_NAME:				end += object_desc(buf, 1024, o_ptr, ODESC_PREFIX | ODESC_BASE); 				break;			case ART_TAG_KIND:				object_kind_name(&buf[end], 1024-end, o_ptr->kind, TRUE);				end += strlen(&buf[end]);				break;			case ART_TAG_VERB:				strnfcat(buf, 1024, &end, "s");				break;			case ART_TAG_VERB_IS:				if((end > 2) && (buf[end-2] == 's'))					strnfcat(buf, 1024, &end, "are");				else					strnfcat(buf, 1024, &end, "is");			default:				break;			}		}		else    /* An invalid tag, skip it */		{			in_cursor = next + 1;		}		next = strchr(in_cursor, '{');	}	strnfcat(buf, 1024, &end, in_cursor);	msg("%s", buf);}

static size_t obj_desc_combat(const object_type *o_ptr, char *buf, size_t max, 		size_t end, bool spoil){	bitflag flags[OF_SIZE];	bitflag flags_known[OF_SIZE];	object_flags(o_ptr, flags);	object_flags_known(o_ptr, flags_known);	if (of_has(flags, OF_SHOW_DICE)) {		/* Only display the real damage dice if the combat stats are known */		if (spoil || object_attack_plusses_are_visible(o_ptr))			strnfcat(buf, max, &end, " (%dd%d)", o_ptr->dd, o_ptr->ds);		else			strnfcat(buf, max, &end, " (%dd%d)", o_ptr->kind->dd, o_ptr->kind->ds);	}	if (of_has(flags, OF_SHOW_MULT)) {		/* Display shooting power as part of the multiplier */		if (of_has(flags, OF_MIGHT) &&		    (spoil || object_flag_is_known(o_ptr, OF_MIGHT)))			strnfcat(buf, max, &end, " (x%d)", (o_ptr->sval % 10) + o_ptr->pval[which_pval(o_ptr, OF_MIGHT)]);		else			strnfcat(buf, max, &end, " (x%d)", o_ptr->sval % 10);	}	/* Show weapon bonuses */	if (spoil || object_attack_plusses_are_visible(o_ptr)) {		if (wield_slot(o_ptr) == INVEN_WIELD || wield_slot(o_ptr) == INVEN_BOW				|| obj_is_ammo(o_ptr) || o_ptr->to_d || o_ptr->to_h) {			/* Make an exception for body armor with only a to-hit penalty */			if (o_ptr->to_h < 0 && o_ptr->to_d == 0 &&			    (o_ptr->tval == TV_SOFT_ARMOR ||			     o_ptr->tval == TV_HARD_ARMOR ||			     o_ptr->tval == TV_DRAG_ARMOR))				strnfcat(buf, max, &end, " (%+d)", o_ptr->to_h);			/* Otherwise, always use the full tuple */			else				strnfcat(buf, max, &end, " (%+d,%+d)", o_ptr->to_h, o_ptr->to_d);		}	}	/* Show armor bonuses */	if (spoil || object_defence_plusses_are_visible(o_ptr)) {		if (obj_desc_show_armor(o_ptr))			strnfcat(buf, max, &end, " [%d,%+d]", o_ptr->ac, o_ptr->to_a);		else if (o_ptr->to_a)			strnfcat(buf, max, &end, " [%+d]", o_ptr->to_a);	}	else if (obj_desc_show_armor(o_ptr))		strnfcat(buf, max, &end, " [%d]", object_was_sensed(o_ptr) ? o_ptr->ac : o_ptr->kind->ac);	return end;}

/** * Describe combat properties of an item - damage dice, to-hit, to-dam, armor * class, missile multipler */static size_t obj_desc_combat(const struct object *obj, char *buf, size_t max, 		size_t end, bool spoil){	bitflag flags_known[OF_SIZE];	object_flags_known(obj, flags_known);	if (kf_has(obj->kind->kind_flags, KF_SHOW_DICE)) {		/* Only display the real damage dice if the combat stats are known */		if (spoil || object_attack_plusses_are_visible(obj))			strnfcat(buf, max, &end, " (%dd%d)", obj->dd, obj->ds);		else			strnfcat(buf, max, &end, " (%dd%d)", obj->kind->dd,					 obj->kind->ds);	}	if (kf_has(obj->kind->kind_flags, KF_SHOW_MULT)) {		/* Display shooting power as part of the multiplier */		if ((obj->modifiers[OBJ_MOD_MIGHT] > 0) &&		    (spoil || object_this_mod_is_visible(obj, OBJ_MOD_MIGHT)))			strnfcat(buf, max, &end, " (x%d)",					 obj->pval + obj->modifiers[OBJ_MOD_MIGHT]);		else			strnfcat(buf, max, &end, " (x%d)", obj->pval);	}	/* Show weapon bonuses */	if (spoil || object_attack_plusses_are_visible(obj)) {		if (tval_is_weapon(obj) || obj->to_d || obj->to_h) {			/* Make an exception for body armor with only a to-hit penalty */			if (obj->to_h < 0 && obj->to_d == 0 &&				tval_is_body_armor(obj))				strnfcat(buf, max, &end, " (%+d)", obj->to_h);			/* Otherwise, always use the full tuple */			else				strnfcat(buf, max, &end, " (%+d,%+d)", obj->to_h,						 obj->to_d);		}	}	/* Show armor bonuses */	if (spoil || object_defence_plusses_are_visible(obj)) {		if (obj_desc_show_armor(obj))			strnfcat(buf, max, &end, " [%d,%+d]", obj->ac, obj->to_a);		else if (obj->to_a)			strnfcat(buf, max, &end, " [%+d]", obj->to_a);	}	else if (obj_desc_show_armor(obj))		strnfcat(buf, max, &end, " [%d]",				 object_was_sensed(obj) ? obj->ac : obj->kind->ac);	return end;}

/** * Add "unseen" to the end of unaware items in stores */static size_t obj_desc_aware(const struct object *obj, char *buf, size_t max,							 size_t end){	if (!object_flavor_is_aware(obj))		strnfcat(buf, max, &end, " {unseen}");	return end;}

/* Add "unseen" to the end of unaware items in stores */static size_t obj_desc_aware(const object_type *o_ptr, char *buf, size_t max,	size_t end){	if (!object_flavor_is_aware(o_ptr))		strnfcat(buf, max, &end, " {unseen}");	return end;}

static size_t obj_desc_light(const object_type *o_ptr, char *buf, size_t max, size_t end){	/* Fuelled light sources get number of remaining turns appended */	if (fuelable_lite_p(o_ptr))		strnfcat(buf, max, &end, " (%d turns)", o_ptr->timeout);	return end;}

static size_t obj_desc_pval(const object_type *o_ptr, char *buf, size_t max, size_t end){	u32b f1, f2, f3, fn;	object_flags(o_ptr, &f1, &f2, &f3, &fn);	if (!(f1 & TR1_PVAL_MASK)) return end;	strnfcat(buf, max, &end, " (%+d", o_ptr->pval);	if (!(f3 & TR3_HIDE_TYPE))	{		if (f1 & TR1_STEALTH)			strnfcat(buf, max, &end, " stealth");		else if (f1 & TR1_SEARCH)			strnfcat(buf, max, &end, " searching");		else if (f1 & TR1_INFRA)			strnfcat(buf, max, &end, " infravision");		else if (f1 & TR1_SPEED)			strnfcat(buf, max, &end, " speed");		else if (f1 & TR1_BLOWS)			strnfcat(buf, max, &end, " attack%s", PLURAL(o_ptr->pval));	}	strnfcat(buf, max, &end, ")");	return end;}

static size_t obj_desc_pval(const object_type *o_ptr, char *buf, size_t max, size_t end){	bitflag f[OF_SIZE];	object_flags(o_ptr, f);	if (!flags_test(f, OF_SIZE, OF_PVAL_MASK, FLAG_END)) return end;	strnfcat(buf, max, &end, " (%+d", o_ptr->pval);	if (!of_has(f, OF_HIDE_TYPE))	{		if (of_has(f, OF_STEALTH))			strnfcat(buf, max, &end, " stealth");		else if (of_has(f, OF_SEARCH))			strnfcat(buf, max, &end, " searching");		else if (of_has(f, OF_INFRA))			strnfcat(buf, max, &end, " infravision");		else if (of_has(f, OF_SPEED))			strnfcat(buf, max, &end, " speed");		else if (of_has(f, OF_BLOWS))			strnfcat(buf, max, &end, " attack%s", PLURAL(o_ptr->pval));	}	strnfcat(buf, max, &end, ")");	return end;}

static size_t obj_desc_light(const object_type * o_ptr, char *buf, size_t max,			     size_t end){    /* Fuelled light sources get number of remaining turns appended */    if ((o_ptr->tval == TV_LIGHT) && !artifact_p(o_ptr))	strnfcat(buf, max, &end, " (%d turns)", o_ptr->pval);    return end;}

/** * Describe remaining light for refuellable lights */static size_t obj_desc_light(const struct object *obj, char *buf, size_t max,							 size_t end){	/* Fuelled light sources get number of remaining turns appended */	if (tval_is_light(obj) && !of_has(obj->flags, OF_NO_FUEL))		strnfcat(buf, max, &end, " (%d turns)", obj->timeout);	return end;}

static size_t obj_desc_charges(const object_type * o_ptr, char *buf, size_t max,			       size_t end){    object_kind *k_ptr = &k_info[o_ptr->k_idx];    bool aware = object_aware_p(o_ptr);    /* Wands and Staffs have charges */    if (aware && (o_ptr->tval == TV_STAFF || o_ptr->tval == TV_WAND))	strnfcat(buf, max, &end, " (%d charge%s)", o_ptr->pval,		 PLURAL(o_ptr->pval));    /* Charging things */    else if (o_ptr->timeout > 0) {	if (o_ptr->tval == TV_ROD && o_ptr->number > 1) {	    int power;	    int time_base = randcalc(k_ptr->time, 0, MINIMISE);	    if (!time_base)		time_base = 1;	    /* 	     * Find out how many rods are charging, by dividing	     * current timeout by each rod's maximum timeout.	     * Ensure that any remainder is rounded up.  Display	     * very discharged stacks as merely fully discharged.	     */	    power = (o_ptr->timeout + (time_base - 1)) / time_base;	    if (power > o_ptr->number)		power = o_ptr->number;	    /* Display prettily */	    strnfcat(buf, max, &end, " (%d charging)", power);	}	/* Artifacts, single rods */	else if (!(o_ptr->tval == TV_LIGHT && !artifact_p(o_ptr))) {	    strnfcat(buf, max, &end, " (charging)");	}    }    return end;}

/** * Format object obj's name into 'buf'. */static size_t obj_desc_name(char *buf, size_t max, size_t end,		const struct object *obj, bool prefix, int mode, bool spoil, bool terse){	bool known = object_is_known(obj) || spoil;	bool aware = object_flavor_is_aware(obj) || (mode & ODESC_STORE) || spoil;	const char *basename = obj_desc_get_basename(obj, aware, terse, mode);	const char *modstr = obj_desc_get_modstr(obj->kind);	if (aware && !obj->kind->everseen && !spoil)		obj->kind->everseen = TRUE;	if (prefix)		end = obj_desc_name_prefix(buf, max, end, obj, known,				basename, modstr, terse);	/* Pluralize if (not forced singular) and	 * (not a known/visible artifact) and	 * (not one in stack or forced plural) */	end = obj_desc_name_format(buf, max, end, basename, modstr,			!(mode & ODESC_SINGULAR) &&			!(obj->artifact &&			  (object_name_is_visible(obj) || known)) &&			(obj->number != 1 || (mode & ODESC_PLURAL)));	/** Append extra names of various kinds **/	if ((object_name_is_visible(obj) || known) && obj->artifact)		strnfcat(buf, max, &end, " %s", obj->artifact->name);	else if (((spoil && obj->ego) || object_ego_is_visible(obj)) &&			 !(mode & ODESC_NOEGO))		strnfcat(buf, max, &end, " %s", obj->ego->name);	else if (aware && !obj->artifact &&			(obj->kind->flavor || obj->kind->tval == TV_SCROLL)) {		if (terse)			strnfcat(buf, max, &end, " '%s'", obj->kind->name);		else			strnfcat(buf, max, &end, " of %s", obj->kind->name);	}	return end;}

/** * Print a message when an object flag is identified by use. * * /param flag is the flag being noticed * /param name is the object name  */void flag_message(int flag, char *name){	struct obj_property *prop = lookup_obj_property(OBJ_PROPERTY_FLAG, flag);	char buf[1024] = "/0";	const char *next;	const char *s;	const char *tag;	const char *in_cursor;	size_t end = 0;	/* See if we have a message */	if (!prop->msg) return;	in_cursor = prop->msg;	next = strchr(in_cursor, '{');	while (next) {		/* Copy the text leading up to this { */		strnfcat(buf, 1024, &end, "%.*s", next - in_cursor, in_cursor); 		s = next + 1;		while (*s && isalpha((unsigned char) *s)) s++;		/* Valid tag */		if (*s == '}') {			/* Start the tag after the { */			tag = next + 1;			in_cursor = s + 1;			if (strncmp(tag, "name", 4) == 0) {				strnfcat(buf, 1024, &end, "%s", name); 			}		} else {			/* An invalid tag, skip it */			in_cursor = next + 1;		}		next = strchr(in_cursor, '{');	}	strnfcat(buf, 1024, &end, in_cursor);	msg("%s", buf);}

static size_t obj_desc_inscrip(const object_type * o_ptr, char *buf, size_t max,			       size_t end){    const char *u[4] = { 0, 0, 0, 0 };    int n = 0;    /* Get inscription */    if (o_ptr->note)	u[n++] = quark_str(o_ptr->note);    /* Use special inscription, if any */    if (o_ptr->feel) {	u[n++] = feel_text[o_ptr->feel];    } else if ((o_ptr->ident & IDENT_EMPTY) && !object_known_p(o_ptr))	u[n++] = "empty";    else if (!object_aware_p(o_ptr) && object_tried_p(o_ptr))	u[n++] = "tried";        /* Use the discount, if any. No annoying inscription for homemade     * branded items. */    if ((o_ptr->discount > 0) && (o_ptr->discount != 80)) 	u[n++] = format("%d%% off", o_ptr->discount);    /* Note squelch */    if (squelch_item_ok(o_ptr))	u[n++] = "squelch";    if (n) {	int i;	for (i = 0; i < n; i++) {	    if (i == 0)		strnfcat(buf, max, &end, " {");	    strnfcat(buf, max, &end, "%s", u[i]);	    if (i < n - 1)		strnfcat(buf, max, &end, ", ");	}	strnfcat(buf, max, &end, "}");    }    return end;}

static void path_process(char *buf, size_t len, size_t *cur_len, const char *path){#if defined(UNIX)	/* Home directory on Unixes */	if (path[0] == '~')	{		const char *s;		const char *username = path + 1;		struct passwd *pw;		char user[128];		/* Look for non-user portion of the file */		s = strstr(username, PATH_SEP);		if (s)		{			int i;			/* Keep username a decent length */			if (s >= username + sizeof(user)) return;			for (i = 0; username < s; ++i) user[i] = *username++;			user[i] = '/0';			username = user;		}		/* Look up a user (or "current" user) */		pw = username[0] ? getpwnam(username) : getpwuid(getuid());		if (!pw) return;		/* Copy across */		strnfcat(buf, len, cur_len, "%s%s", pw->pw_dir, PATH_SEP);		if (s) strnfcat(buf, len, cur_len, "%s", s);	}	else#endif /* defined(UNIX) */	strnfcat(buf, len, cur_len, "%s", path);}

static size_t obj_desc_light(const object_type *o_ptr, char *buf, size_t max, size_t end){	bitflag f[OF_SIZE];	object_flags(o_ptr, f);	/* Fuelled light sources get number of remaining turns appended */	if ((o_ptr->tval == TV_LIGHT) && !of_has(f, OF_NO_FUEL))		strnfcat(buf, max, &end, " (%d turns)", o_ptr->timeout);	return end;}

void get_table_name(char *out_string, bool quotes){	int testcounter = 2;		int len = 0;		/* Empty string */	out_string[0] = 0;	if (quotes)	{		strnfcat(out_string, 18, &len, "'");	}	if (one_in_(3))	{		while (testcounter--)			strnfcat(out_string, 18, &len, syllables[randint0(MAX_SYLLABLES)]);	}	else	{		char Syllable[80];		while (testcounter--)		{			(void)get_rnd_line("elvish.txt", 0, Syllable);			strnfcat(out_string, 18, &len, "%s", Syllable);		}	}	if (quotes)	{		out_string[1] = toupper(out_string[1]);		strnfcat(out_string, 18, &len, "'");	}	else	{		out_string[0] = toupper(out_string[0]);	}}

/** * Start to description, indicating number/uniqueness (a, the, no more, 7, etc) */static size_t obj_desc_name_prefix(char *buf, size_t max, size_t end,		const struct object *obj, bool known, const char *basename,		const char *modstr, bool terse){	if (obj->number == 0)		strnfcat(buf, max, &end, "no more ");	else if (obj->number > 1)		strnfcat(buf, max, &end, "%d ", obj->number);	else if ((object_name_is_visible(obj) || known) && obj->artifact)		strnfcat(buf, max, &end, "the ");	else if (*basename == '&')	{		bool an = FALSE;		const char *lookahead = basename + 1;		while (*lookahead == ' ') lookahead++;		if (*lookahead == '#')		{			if (modstr && is_a_vowel(*modstr))				an = TRUE;		}		else if (is_a_vowel(*lookahead))		{			an = TRUE;		}		if (!terse)		{			if (an)				strnfcat(buf, max, &end, "an ");			else				strnfcat(buf, max, &end, "a ");					}	}	return end;}

/** * Describe numerical modifiers to stats and other player qualities which * allow numerical bonuses - speed, stealth, etc */static size_t obj_desc_mods(const struct object *obj, char *buf, size_t max,	size_t end, bool spoil){	int i, j, num_mods = 0;	int mods[OBJ_MOD_MAX] = { 0 };	/* Run through possible modifiers and store distinct ones */	for (i = 0; i < OBJ_MOD_MAX; i++) {		/* Check for known non-zero mods */		if ((spoil || object_this_mod_is_visible(obj, i))			&& (obj->modifiers[i] != 0)) {			/* If no mods stored yet, store and move on */			if (!num_mods) {				mods[num_mods++] = obj->modifiers[i];				continue;			}			/* Run through the existing mods, quit on duplicates */			for (j = 0; j < num_mods; j++)				if (mods[j] == obj->modifiers[i]) break;			/* Add another mod if needed */			if (j == num_mods)				mods[num_mods++] = obj->modifiers[i];		}	}	if (!num_mods) return end;	/* Print the modifiers */	strnfcat(buf, max, &end, " <");	for (j = 0; j < num_mods; j++) {		if (j) strnfcat(buf, max, &end, ", ");		strnfcat(buf, max, &end, "%+d", mods[j]);	}	strnfcat(buf, max, &end, ">");	return end;}

/* * Function used to print a flag in coloured binary. */void binary_fmt(char *buf, uint max, cptr fmt, va_list *vp){	uint i;	u32b mask = 1;		int len = 0;	    u32b arg;		/* Unused parameter */	(void)fmt;		/* Pre-terminate buffer */	buf[0] = '/0';        /* Get the argument */	arg = va_arg(*vp, u32b);	/* Scan the flags */	for (i = 1; ((i <= 32) && (i < max)); i++)	{		/* Dump set bits */		if (arg & mask)		{			strnfcat(buf, max, &len, CLR_BLUE "*");		}		/* Dump unset bits */		else		{			strnfcat(buf, max, &len, CLR_WHITE "-");		}				mask *= 2;	}}

/** * Create a new path string by appending a 'leaf' to 'base'. * * On Unixes, we convert a tidle at the beginning of a basename to mean the * directory, complicating things a little, but better now than later. * * Remember to free the return value. */size_t path_build(char *buf, size_t len, const char *base, const char *leaf){	size_t cur_len = 0;	int starts_with_separator;	buf[0] = '/0';	if (!leaf || !leaf[0]) {		if (base && base[0])			path_process(buf, len, &cur_len, base);		return cur_len;	}	/*	 * If the leafname starts with the seperator,	 *   or with the tilde (on Unix),	 *   or there's no base path,	 * We use the leafname only.	 */	starts_with_separator = (!base || !base[0]) || prefix(leaf, PATH_SEP);#if defined(UNIX)	starts_with_separator = starts_with_separator || leaf[0] == '~';#endif	if (starts_with_separator) {		path_process(buf, len, &cur_len, leaf);		return cur_len;	}	/* There is both a relative leafname and a base path from which it is	 * relative */	path_process(buf, len, &cur_len, base);	strnfcat(buf, len, &cur_len, "%s", PATH_SEP);	path_process(buf, len, &cur_len, leaf);	return cur_len;}

/* * Create a new path string by appending a 'leaf' to 'base'. * * On Unixes, we convert a tidle at the beginning of a basename to mean the * directory, complicating things a little, but better now than later. * * Remember to free the return value. */size_t path_build(char *buf, size_t len, const char *base, const char *leaf){	size_t cur_len = 0;	buf[0] = '/0';	if (!leaf || !leaf[0])	{		if (base && base[0])			path_process(buf, len, &cur_len, base);		return cur_len;	}	/*	 * If the leafname starts with the seperator,	 *   or with the tilde (on Unix),	 *   or there's no base path,	 * We use the leafname only.	 */#if defined(SET_UID) || defined(USE_PRIVATE_PATHS)	if ((!base || !base[0]) || prefix(leaf, PATH_SEP) || leaf[0] == '~')#else	if ((!base || !base[0]) || prefix(leaf, PATH_SEP))#endif	{		path_process(buf, len, &cur_len, leaf);		return cur_len;	}	/* There is both a relative leafname and a base path from which it is relative */	path_process(buf, len, &cur_len, base);	strnfcat(buf, len, &cur_len, "%s", PATH_SEP);	path_process(buf, len, &cur_len, leaf);	return cur_len;}

static size_t obj_desc_inscrip(const object_type *o_ptr, char *buf, size_t max, size_t end){	const char *u[6] = { 0, 0, 0, 0, 0, 0};	int n = 0;	/* See if the object is "known" */	bool known = (object_known_p(o_ptr) ? TRUE : FALSE);	bool aware = (object_aware_p(o_ptr) ? TRUE : FALSE);	u32b f1, f2, f3, fn;	object_flags(o_ptr, &f1, &f2, &f3, &fn);	/* Get inscription, pdeudo-id, or store discount */	if (o_ptr->obj_note) u[n++] = quark_str(o_ptr->obj_note);	if (o_ptr->discount >= INSCRIP_NULL)	{		u[n++] = inscrip_text[o_ptr->discount - INSCRIP_NULL];	}	else if (cursed_p(o_ptr) && known)	{		u[n++] = "cursed";	}	else if ((o_ptr->ident & IDENT_EMPTY) && (!known))	{		u[n++] = "empty";	}	else if ((!aware) && object_tried_p(o_ptr))	{		u[n++] = "tried";	}	else if (o_ptr->discount > 0)	{		char buf[80];		my_strcpy(buf, format("%d%% off", o_ptr->discount), sizeof(buf));		u[n++] = buf;	}	/* Use the "unknown" inscription */	else if (!known && can_be_pseudo_ided(o_ptr) &&			(o_ptr->discount < INSCRIP_NULL))	{		u[n++] = "unknown";	}	if (n)	{		int i;		for (i = 0; i < n; i++)		{			if (i == 0)				strnfcat(buf, max, &end, " {");			strnfcat(buf, max, &end, "%s", u[i]);			if (i < n-1)				strnfcat(buf, max, &end, ", ");		}		strnfcat(buf, max, &end, "}");	}	return end;}

static size_t obj_desc_charges(const object_type *o_ptr, char *buf, size_t max, size_t end){	object_kind *k_ptr = &k_info[o_ptr->k_idx];	bool aware = object_flavor_is_aware(o_ptr) || (o_ptr->ident & IDENT_STORE);	/* See if the object is "known" */	bool known = (object_known_p(o_ptr) ? TRUE : FALSE);	/* Wands and Staffs have charges */	if (aware && known && (o_ptr->tval == TV_STAFF || o_ptr->tval == TV_WAND))		strnfcat(buf, max, &end, " (%d charge%s)", o_ptr->pval, PLURAL(o_ptr->pval));	/* Charging things */	else if (o_ptr->timeout > 0)	{		/* Hack -- Rods have a "charging" indicator */		if (known && (o_ptr->tval == TV_ROD))		{			/* Hack -- Dump " (# charging)" if relevant */			if (o_ptr->timeout >= 1)			{				/* Stacks of rods display an exact count of charging rods. */				if (o_ptr->number > 1)				{					int power;					/* Paranoia. */					if (k_ptr->pval == 0) k_ptr->pval = 1;					/* Find out how many rods are charging, by dividing				 	 * current timeout by each rod's maximum timeout.				 	 * Ensure that any remainder is rounded up.  Display				 	 * very discharged stacks as merely fully discharged.				 	 */					power = (o_ptr->timeout + (k_ptr->pval - 1)) / k_ptr->pval;					if (power > o_ptr->number) power = o_ptr->number;					/* Display prettily */					strnfcat(buf, max, &end, " (%d charging)", power);				}				/* Display prettily */				else strnfcat(buf, max, &end, " (charging)");			}		}		/* Indicate "charging" objects, but not rods or lites */		if (known && o_ptr->timeout && o_ptr->tval != TV_ROD			    && !fuelable_lite_p(o_ptr))		{			/* Hack -- Dump " (charging)" if relevant */			strnfcat(buf, max, &end, " (charging)");		}	}	return end;}