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

/** * Handle a "-d<dir>=<path>" option. * * Sets any of angband's special directories to <path>. * * The "<path>" can be any legal path for the given system, and should * not end in any special path separator (i.e. "/tmp" or "~/.ang-info"). */static void change_path(const char *info){	char *info_copy = NULL;	char *path = NULL;	char *dir = NULL;	unsigned int i = 0;	char dirpath[512];	if (!info || !info[0])		quit_fmt("Try '-d<dir>=<path>'.", info);	info_copy = string_make(info);	path = strtok(info_copy, "=");	dir = strtok(NULL, "=");	for (i = 0; i < N_ELEMENTS(change_path_values); i++) {		if (my_stricmp(path, change_path_values[i].name) == 0) {#ifdef SETGID			if (!change_path_values[i].setgid_ok)				quit_fmt("Can't redefine path to %s dir on multiuser setup",						 path);#endif			string_free(*change_path_values[i].path);			*change_path_values[i].path = string_make(dir);			/* the directory may not exist and may need to be created. */			path_build(dirpath, sizeof(dirpath), dir, "");			if (!dir_create(dirpath)) quit_fmt("Cannot create '%s'", dirpath);			return;		}	}	quit_fmt("Unrecognised -d paramater %s", path);}

static errr parse_specs(struct parser_hook *h, char *fmt) {	char *name ;	char *stype = NULL;	int type;	struct parser_spec *s;	assert(h);	assert(fmt);	name = strtok(fmt, " ");	if (!name)		return -EINVAL;	h->dir = string_make(name);	h->fhead = NULL;	h->ftail = NULL;	while (name) {		/* Lack of a type is legal; that means we're at the end of the line. */		stype = strtok(NULL, " ");		if (!stype)			break;		/* Lack of a name, on the other hand... */		name = strtok(NULL, " ");		if (!name) {			clean_specs(h);			return -EINVAL;		}		/* Grab a type, check to see if we have a mandatory type		 * following an optional type. */		type = parse_type(stype);		if (type == PARSE_T_NONE) {			clean_specs(h);			return -EINVAL;		}		if (!(type & PARSE_T_OPT) && h->ftail &&			(h->ftail->type & PARSE_T_OPT)) {			clean_specs(h);			return -EINVAL;		}		if (h->ftail && ((h->ftail->type & ~PARSE_T_OPT) == PARSE_T_STR)) {			clean_specs(h);			return -EINVAL;		}		/* Save this spec. */		s = mem_alloc(sizeof *s);		s->type = type;		s->name = string_make(name);		s->next = NULL;		if (h->fhead)			h->ftail->next = s;		else			h->fhead = s;		h->ftail = s;	}	return 0;}

lvalue files_read(lvalue v_) {  char *s = (char *)v_;  char *buffer;  lvalue *ptr;  long size;    FILE *fh = fopen(s, "rb");    if (fh != NULL) {    fseek(fh, 0L, SEEK_END);    size = ftell(fh);    rewind(fh);        buffer = malloc(size + sizeof(lvalue) + 1);    ptr = (lvalue*)buffer;    *ptr = (lvalue) size;    buffer = (char *) (ptr+1);        long rsize = fread(buffer, 1, size, fh);        fclose(fh);    fh = NULL;        if (rsize == size) {      *(buffer + size) = 0;      return (lvalue) buffer;    }  }    return string_make((lvalue) "");}

/* * Initialize sound */static bool init_sound(void){   /* Initialize once */   if (!can_use_sound)   {      int i;      char wav[128];      char buf[1024];      /* Prepare the sounds */      for (i = 1; i < SOUND_MAX; i++)      {	 /* Extract name of sound file */	 sprintf(wav, "%s.wav", angband_sound_name[i]);	 /* Access the sound */	 path_build(buf, sizeof(buf), ANGBAND_DIR_XTRA_SOUND, wav);	 /* Save the sound filename, if it exists */	 if (check_file(buf)) sound_file[i] = string_make(buf);      }      /* Sound available */      can_use_sound = TRUE;   }   /* Result */   return (can_use_sound);}

static enum parser_error parse_r_s(struct parser *p) {	struct monster_race *r = parser_priv(p);	char *flags;	char *s;	int pct;	int ret = PARSE_ERROR_NONE;	if (!r)		return PARSE_ERROR_MISSING_RECORD_HEADER;	flags = string_make(parser_getstr(p, "spells"));	s = strtok(flags, " |");	while (s) {		if (1 == sscanf(s, "1_IN_%d", &pct)) {			if (pct < 1 || pct > 100) {				ret = PARSE_ERROR_INVALID_SPELL_FREQ;				break;			}			r->freq_spell = 100 / pct;			r->freq_innate = r->freq_spell;		} else {			if (grab_flag(r->spell_flags, RSF_SIZE, r_info_spell_flags, s)) {				ret = PARSE_ERROR_INVALID_FLAG;				break;			}		}		s = strtok(NULL, " |");	}	/* Add the "base monster" flags to the monster */	if (r->base)		rsf_union(r->spell_flags, r->base->spell_flags);	mem_free(flags);	return ret;}

/* * Open file 'fname', in mode 'mode', with filetype 'ftype'. * Returns file handle or NULL. */ang_file *file_open(const char *fname, file_mode mode, file_type ftype){	ang_file *f = ZNEW(ang_file);	char buf[1024];	(void)ftype;	/* Get the system-specific path */	path_parse(buf, sizeof(buf), fname);	switch (mode)	{		case MODE_WRITE:  f->fh = fopen(buf, "wb"); break;		case MODE_READ:   f->fh = fopen(buf, "rb"); break;		case MODE_APPEND: f->fh = fopen(buf, "a+"); break;		default:          f->fh = fopen(buf, "__");	}	if (f->fh == NULL)	{		FREE(f);		return NULL;	}	f->fname = string_make(buf);	f->mode = mode;	if (mode != MODE_READ && file_open_hook)		file_open_hook(buf, ftype);	return f;}

errr parser_reg(struct parser *p, const char *fmt,                enum parser_error (*func)(struct parser *p)) {	errr r;	char *cfmt;	struct parser_hook *h;	assert(p);	assert(fmt);	assert(func);	h = mem_alloc(sizeof *h);	cfmt = string_make(fmt);	h->next = p->hooks;	h->func = func;	r = parse_specs(h, cfmt);	if (r)	{		mem_free(h);		mem_free(cfmt);		return r;	}	p->hooks = h;	mem_free(cfmt);	return 0;}

static voidsetup_argv(struct Parrot_Interp *interpreter, int argc, char ** argv){    INTVAL i;    PMC *userargv;    if (Interp_flags_TEST(interpreter, PARROT_DEBUG_FLAG)) {        PIO_eprintf(interpreter,                "*** Parrot VM: Setting up ARGV array in P5.  Current argc: %d ***/n",                argc);    }    userargv = pmc_new_noinit(interpreter, enum_class_SArray);    /* immediately anchor pmc to root set */    interpreter->pmc_reg.registers[5] = userargv;    VTABLE_set_pmc_keyed_int(interpreter, interpreter->iglobals,            (INTVAL)IGLOBALS_ARGV_LIST, userargv);    VTABLE_init(interpreter, userargv);    VTABLE_set_integer_native(interpreter, userargv, argc);    for (i = 0; i < argc; i++) {        /* Run through argv, adding everything to @ARGS. */        STRING *arg = string_make(interpreter, argv[i], strlen(argv[i]),                                  0, PObj_external_FLAG, 0);        if (Interp_flags_TEST(interpreter, PARROT_DEBUG_FLAG)) {            PIO_eprintf(interpreter, "/t%vd: %s/n", i, argv[i]);        }        VTABLE_push_string(interpreter, userargv, arg);    }}

/* * Handle a "-d<what>=<path>" option * * The "<what>" can be any string starting with the same letter as the * name of a subdirectory of the "lib" folder (i.e. "i" or "info"). * * The "<path>" can be any legal path for the given system, and should * not end in any special path separator (i.e. "/tmp" or "~/.ang-info"). */static void change_path(const char *info){	if (!info || !info[0])		quit_fmt("Try '-d<path>'.", info);	string_free(ANGBAND_DIR_USER);	ANGBAND_DIR_USER = string_make(info);}

static enum parser_error parse_vault_type(struct parser *p) {	struct vault *v = parser_priv(p);	if (!v)		return PARSE_ERROR_MISSING_RECORD_HEADER;	v->typ = string_make(parser_getstr(p, "type"));	return PARSE_ERROR_NONE;}

/* * Handle a "-d<what>=<path>" option * * The "<what>" can be any string starting with the same letter as the * name of a subdirectory of the "lib" folder (i.e. "i" or "info"). * * The "<path>" can be any legal path for the given system, and should * not end in any special path separator (i.e. "/tmp" or "~/.ang-info"). */static void change_path(cptr info){	if (!info || !info[0])		quit_fmt("Try '-d<path>'.", info);	string_free(reposband_DIR_USER);	reposband_DIR_USER = string_make(info);}

static enum parser_error parse_rb_n(struct parser *p) {	struct monster_base *h = parser_priv(p);	struct monster_base *rb = mem_zalloc(sizeof *rb);	rb->next = h;	rb->name = string_make(parser_getstr(p, "name"));	parser_setpriv(p, rb);	return PARSE_ERROR_NONE;}

static enum parser_error parse_prefs_gf(struct parser *p){	bool types[GF_MAX] = { 0 };	const char *direction;	int motion;	char *s, *t;	size_t i;	struct prefs_data *d = parser_priv(p);	assert(d != NULL);	if (d->bypass)		return PARSE_ERROR_NONE;	/* Parse the type, which is a | seperated list of GF_ constants */	s = string_make(parser_getsym(p, "type"));	t = strtok(s, "| ");	while (t) {		if (streq(t, "*")) {			memset(types, TRUE, sizeof types);		} else {			int idx = gf_name_to_idx(t);			if (idx == -1)				return PARSE_ERROR_INVALID_VALUE;			types[idx] = TRUE;		}		t = strtok(NULL, "| ");	}	string_free(s);	direction = parser_getsym(p, "direction");	if (streq(direction, "static"))		motion = BOLT_NO_MOTION;	else if (streq(direction, "0"))		motion = BOLT_0;	else if (streq(direction, "45"))		motion = BOLT_45;	else if (streq(direction, "90"))		motion = BOLT_90;	else if (streq(direction, "135"))		motion = BOLT_135;	else		return PARSE_ERROR_INVALID_VALUE;	for (i = 0; i < GF_MAX; i++) {		if (!types[i])			continue;		gf_to_attr[i][motion] = (byte) parser_getuint(p, "attr");		gf_to_char[i][motion] = (wchar_t) parser_getuint(p, "char");	}	return PARSE_ERROR_NONE;}

/** * Parsing functions for vault.txt */static enum parser_error parse_vault_name(struct parser *p) {	struct vault *h = parser_priv(p);	struct vault *v = mem_zalloc(sizeof *v);	v->name = string_make(parser_getstr(p, "name"));	v->next = h;	parser_setpriv(p, v);	return PARSE_ERROR_NONE;}

/** * Parsing functions for room_template.txt */static enum parser_error parse_room_name(struct parser *p) {	struct room_template *h = parser_priv(p);	struct room_template *t = mem_zalloc(sizeof *t);	t->name = string_make(parser_getstr(p, "name"));	t->next = h;	parser_setpriv(p, t);	return PARSE_ERROR_NONE;}

static enum parser_error parse_summon_name(struct parser *p) {	struct summon *h = parser_priv(p);	struct summon *s = mem_zalloc(sizeof *s);	s->next = h;	parser_setpriv(p, s);	s->name = string_make(parser_getstr(p, "name"));	return PARSE_ERROR_NONE;}

/* Parsing functions for monster.txt */static enum parser_error parse_r_n(struct parser *p) {	struct monster_race *h = parser_priv(p);	struct monster_race *r = mem_zalloc(sizeof *r);	r->next = h;	r->ridx = parser_getuint(p, "index");	r->name = string_make(parser_getstr(p, "name"));	parser_setpriv(p, r);	return PARSE_ERROR_NONE;}

voidParrot_initialize_header_pool_names(struct Parrot_Interp *interpreter){    interpreter->arena_base->string_header_pool->name            = string_make(interpreter, "String Pool", strlen("String Pool"),            0, PObj_constant_FLAG, 0);    interpreter->arena_base->pmc_pool->name            = string_make(interpreter, "PMC Pool", strlen("PMC Pool"),            0, PObj_constant_FLAG, 0);    /* Set up names for each header pool, * now that we have a constant string     *     * * pool available to us */    interpreter->arena_base->constant_string_header_pool->name            =            string_make(interpreter, "Constant String Pool",            strlen("Constant String Pool"), 0, PObj_constant_FLAG, 0);    interpreter->arena_base->buffer_header_pool->name =            string_make(interpreter, "Generic Header Pool",            strlen("Generic Header Pool"), 0, PObj_constant_FLAG, 0);}

/** * Parsing functions for quest.txt */static enum parser_error parse_quest_name(struct parser *p) {	const char *name = parser_getstr(p, "name");	struct quest *h = parser_priv(p);	struct quest *q = mem_zalloc(sizeof(*q));	q->next = h;	parser_setpriv(p, q);	q->name = string_make(name);	return PARSE_ERROR_NONE;}

/** * Small hack to allow both spellings of armer */char *de_armour(const char *name){	char newname[40];	char *armour;	my_strcpy(newname, name, sizeof(newname));	armour = strstr(newname, "armour");	if (armour)		my_strcpy(armour + 4, "r", 2);	return string_make(newname);}

/* * Open file 'fname', in mode 'mode', with filetype 'ftype'. * Returns file handle or NULL. */ang_file *file_open(const char *fname, file_mode mode, file_type ftype){	ang_file *f = ZNEW(ang_file);	char buf[1024];	(void)ftype;	/* Get the system-specific path */	path_parse(buf, sizeof(buf), fname);	switch (mode) {		case MODE_WRITE: { 			if (ftype == FTYPE_SAVE) {				/* open only if the file does not exist */				int fd;				fd = open(buf, O_CREAT | O_EXCL | O_WRONLY | O_BINARY, S_IRUSR | S_IWUSR);				if (fd < 0) {					/* there was some error */					f->fh = NULL;				} else {					f->fh = fdopen(fd, "wb");				}			} else {				f->fh = fopen(buf, "wb");			}			break;		}		case MODE_READ:			f->fh = fopen(buf, "rb");			break;		case MODE_APPEND:			f->fh = fopen(buf, "a+");			break;		default:			assert(0);	}	if (f->fh == NULL)	{		FREE(f);		return NULL;	}	f->fname = string_make(buf);	f->mode = mode;	if (mode != MODE_READ && file_open_hook)		file_open_hook(buf, ftype);	return f;}

static void module_reset_dir_aux(cptr *dir, cptr new_path){	char buf[1024];	/* Build the new path */	strnfmt(buf, sizeof (buf), "%s%s%s", dir, PATH_SEP, new_path);	string_free(*dir);	*dir = string_make(buf);	/* Make it if needed */	if (!private_check_user_directory(*dir))		quit(format("Unable to create module dir %s/n", *dir));}

static enum parser_error parse_store(struct parser *p) {	struct store *h = parser_priv(p);	struct store *s;	unsigned int idx = parser_getuint(p, "index") - 1;	if (idx >= MAX_STORES)		return PARSE_ERROR_OUT_OF_BOUNDS;	s = store_new(parser_getuint(p, "index") - 1);	s->name = string_make(parser_getstr(p, "name"));	s->next = h;	parser_setpriv(p, s);	return PARSE_ERROR_NONE;}

/* * Open file 'fname', in mode 'mode', with filetype 'ftype'. * Returns file handle or NULL. */ang_file *file_open(const char *fname, file_mode mode, file_type ftype){	ang_file *f = ZNEW(ang_file);	char buf[1024];	(void)ftype;	/* Get the system-specific path */	path_parse(buf, sizeof(buf), fname);	switch (mode)	{		case MODE_WRITE:  f->fh = fopen(buf, "wb"); break;		case MODE_READ:   f->fh = fopen(buf, "rb"); break;		case MODE_APPEND: f->fh = fopen(buf, "a+"); break;		default:          f->fh = fopen(buf, "__");	}	if (f->fh == NULL)	{		FREE(f);		return NULL;	}	f->fname = string_make(buf);	f->mode = mode;#ifdef MACH_O_CARBON	extern void fsetfileinfo(cptr path, u32b fcreator, u32b ftype);	/* OS X uses its own kind of filetypes */	if (mode != MODE_READ)	{		u32b mac_type = 'TEXT';		if (ftype == FTYPE_RAW) mac_type = 'DATA';		else if (ftype == FTYPE_SAVE) mac_type = 'SAVE';		fsetfileinfo(buf, 'A271', mac_type);	}#endif /* MACH_O_CARBON */#if defined(RISCOS) && 0	/* do something for RISC OS here? */	if (mode != MODE_READ)		File_SetType(n, ftype);#endif	return f;}

/** * Copy all the standard quests to the player quest history */void player_quests_reset(struct player *p){	size_t i;	if (p->quests)		player_quests_free(p);	p->quests = mem_zalloc(z_info->quest_max * sizeof(struct quest));	for (i = 0; i < z_info->quest_max; i++) {		p->quests[i].name = string_make(quests[i].name);		p->quests[i].level = quests[i].level;		p->quests[i].race = quests[i].race;		p->quests[i].max_num = quests[i].max_num;	}}

static enum parser_error parse_owner(struct parser *p) {	struct store *s = parser_priv(p);	unsigned int maxcost = parser_getuint(p, "purse");	char *name = string_make(parser_getstr(p, "name"));	struct owner *o;	if (!s)		return PARSE_ERROR_MISSING_RECORD_HEADER;	o = mem_zalloc(sizeof *o);	o->oidx = (s->owners ? s->owners->oidx + 1 : 0);	o->next = s->owners;	o->name = name;	o->max_cost = maxcost;	s->owners = o;	return PARSE_ERROR_NONE;}

/** * Parsing functions for dungeon_profile.txt */static enum parser_error parse_profile_name(struct parser *p) {    struct cave_profile *h = parser_priv(p);    struct cave_profile *c = mem_zalloc(sizeof *c);	size_t i;	c->name = string_make(parser_getstr(p, "name"));	for (i = 0; i < N_ELEMENTS(cave_builders); i++)		if (streq(c->name, cave_builders[i].name))			break;	if (i == N_ELEMENTS(cave_builders))		return PARSE_ERROR_NO_BUILDER_FOUND;	c->builder = cave_builders[i].builder;	c->next = h;	parser_setpriv(p, c);	return PARSE_ERROR_NONE;}

int button_add_end(const char *label, keycode_t keypress,                   int bottom, int right){	button_mouse* button = button_stack;	if (!button) {		return -1;	}	if (bottom) button->bottom = bottom;	if (!right && label) {		right = strlen(label);		right = button->left + right;	}	if (right) button->right = right;	if (keypress) button->key = keypress;	if (label) {		if (button->label) {			(void)string_free(button->label);		}		button->label = (char*)string_make(label);	}	if (button_call_fn) {		button->fn = button_call_fn;	}	if (button_add_2d_hook) {		int res = (*button_add_2d_hook) (button->top, button->left,			button->bottom, button->right, button->label, button->key);		if (res) { // if res != 0			if (res == 1) {				/* pop the button off of the stack */				button_stack = button->next;				/* free the button */				if (button->label)					string_free(button->label);				FREE(button);			}			return res;		}	}	/* Redraw */	p_ptr->redraw |= (PR_BUTTONS);	return 0;}

static enum parser_error parse_r_plural(struct parser *p){	struct monster_race *r = parser_priv(p);	if (r == NULL)		return PARSE_ERROR_MISSING_RECORD_HEADER;	if (parser_hasval(p, "plural")) {		const char *plural = parser_getstr(p, "plural");		if (strlen(plural) > 0)			r->plural = string_make(plural);		else			r->plural = NULL;	}	return PARSE_ERROR_NONE;}