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

boolcct_check_str_eq(const char *file, int line, const char *expression,                 const char *expected, const char *actual, bool free1,                 bool free2){	bool result;	if (expected && actual && str_eq(actual, expected)) {		cct_check_passed(file, line, expression);		result = true;	} else {		char *exp_str = expected ? format("/"%s/"", expected) : x_strdup("(null)");		char *act_str = actual ? format("/"%s/"", actual) : x_strdup("(null)");		cct_check_failed(file, line, expression, exp_str, act_str);		free(exp_str);		free(act_str);		result = false;	}	if (free1) {		free((char *)expected);	}	if (free2) {		free((char *)actual);	}	return result;}

boolcct_check_args_eq(const char *file, int line, const char *expression,                  struct args *expected, struct args *actual,                  bool free1, bool free2){	bool result;	if (expected && actual && args_equal(actual, expected)) {		cct_check_passed(file, line, expression);		result = true;	} else {		char *exp_str = expected ? args_to_string(expected) : x_strdup("(null)");		char *act_str = actual ? args_to_string(actual) : x_strdup("(null)");		cct_check_failed(file, line, expression, exp_str, act_str);		free(exp_str);		free(act_str);		result = false;	}	if (free1) {		args_free(expected);	}	if (free2) {		args_free(actual);	}	return result;}

struct resource *fdstream_resource (const char * path, int fd, const char * content_type){	struct fdstream * st;	if ((st = calloc (1, sizeof(*st))) == NULL)		return NULL;	st->path = x_strdup (path);	if (st->path == NULL) {		free (st);		return NULL;	}	st->content_type = x_strdup (content_type);	if (st->content_type == NULL) {		free (st);		free ((char *)st->path);		return NULL;	}	st->stream = stream_open (fd);	if (st->stream == NULL) {		free (st);		free ((char *)st->path);		free ((char *)st->content_type);		return NULL;	}	return resource_new (fdstream_check, fdstream_head, fdstream_body, fdstream_delete, st);}

static voidconf_item_receiver(const char *descr, const char *origin, void *context){	(void)context;	received_conf_items[n_received_conf_items].descr = x_strdup(descr);	received_conf_items[n_received_conf_items].origin = x_strdup(origin);	++n_received_conf_items;}

static intverify_object(struct conf *conf, struct manifest *mf, struct object *obj,              struct hashtable *stated_files, struct hashtable *hashed_files){	for (uint32_t i = 0; i < obj->n_file_info_indexes; i++) {		struct file_info *fi = &mf->file_infos[obj->file_info_indexes[i]];		char *path = mf->files[fi->index];		struct file_stats *st = hashtable_search(stated_files, path);		if (!st) {			struct stat file_stat;			if (x_stat(path, &file_stat) != 0) {				return 0;			}			st = x_malloc(sizeof(*st));			st->size = file_stat.st_size;			st->mtime = file_stat.st_mtime;			st->ctime = file_stat.st_ctime;			hashtable_insert(stated_files, x_strdup(path), st);		}		if (fi->size != st->size) {			return 0;		}		if (conf->sloppiness & SLOPPY_FILE_STAT_MATCHES) {			if (fi->mtime == st->mtime && fi->ctime == st->ctime) {				cc_log("mtime/ctime hit for %s", path);				continue;			} else {				cc_log("mtime/ctime miss for %s", path);			}		}		struct file_hash *actual = hashtable_search(hashed_files, path);		if (!actual) {			struct mdfour hash;			hash_start(&hash);			int result = hash_source_code_file(conf, &hash, path);			if (result & HASH_SOURCE_CODE_ERROR) {				cc_log("Failed hashing %s", path);				return 0;			}			if (result & HASH_SOURCE_CODE_FOUND_TIME) {				return 0;			}			actual = x_malloc(sizeof(*actual));			hash_result_as_bytes(&hash, actual->hash);			actual->size = hash.totalN;			hashtable_insert(hashed_files, x_strdup(path), actual);		}		if (memcmp(fi->hash, actual->hash, mf->hash_size) != 0		    || fi->size != actual->size) {			return 0;		}	}	return 1;}

static char *find_executable_in_path(const char *name, const char *exclude_name, char *path){	path = x_strdup(path);	// Search the path looking for the first compiler of the right name that	// isn't us.	char *saveptr = NULL;	for (char *tok = strtok_r(path, PATH_DELIM, &saveptr);	     tok;	     tok = strtok_r(NULL, PATH_DELIM, &saveptr)) {#ifdef _WIN32		char namebuf[MAX_PATH];		int ret = SearchPath(tok, name, NULL, sizeof(namebuf), namebuf, NULL);		if (!ret) {			char *exename = format("%s.exe", name);			ret = SearchPath(tok, exename, NULL, sizeof(namebuf), namebuf, NULL);			free(exename);		}		(void) exclude_name;		if (ret) {			free(path);			return x_strdup(namebuf);		}#else		struct stat st1, st2;		char *fname = format("%s/%s", tok, name);		// Look for a normal executable file.		if (access(fname, X_OK) == 0 &&		    lstat(fname, &st1) == 0 &&		    stat(fname, &st2) == 0 &&		    S_ISREG(st2.st_mode)) {			if (S_ISLNK(st1.st_mode)) {				char *buf = x_realpath(fname);				if (buf) {					char *p = basename(buf);					if (str_eq(p, exclude_name)) {						// It's a link to "ccache"!						free(p);						free(buf);						continue;					}					free(buf);					free(p);				}			}			// Found it!			free(path);			return fname;		}		free(fname);#endif	}	free(path);	return NULL;}

static voidalloc_pw(struct passwd *target, struct passwd *source){    *target = *source;    /* we care only about these strings */    target->pw_dir = x_strdup(source->pw_dir);    target->pw_name = x_strdup(source->pw_name);    target->pw_shell = x_strdup(source->pw_shell);}

/* return the base name of a file - caller frees */char *str_basename(const char *s){	char *p = strrchr(s, '/');	if (p) {		return x_strdup(p+1);	} 	return x_strdup(s);}

static int _pam_parse(int flags, int argc, const char **argv, char **maildir,		      int *hashcount){    int ctrl=0;    if (flags & PAM_SILENT) {	ctrl |= PAM_MAIL_SILENT;    }    *hashcount = 0;    /* step through arguments */    for (; argc-- > 0; ++argv) {	/* generic options */	if (!strcmp(*argv,"debug"))	    ctrl |= PAM_DEBUG_ARG;	else if (!strcmp(*argv,"quiet"))	    ctrl |= PAM_QUIET_MAIL;	else if (!strcmp(*argv,"standard"))	    ctrl |= PAM_STANDARD_MAIL | PAM_EMPTY_TOO;	else if (!strncmp(*argv,"dir=",4)) {	    *maildir = x_strdup(4+*argv);	    if (*maildir != NULL) {		D(("new mail directory: %s", *maildir));		ctrl |= PAM_NEW_MAIL_DIR;	    } else {		_log_err(LOG_CRIT,			 "failed to duplicate mail directory - ignored");	    }	} else if (!strncmp(*argv,"hash=",5)) {	    char *ep = NULL;	    *hashcount = strtol(*argv+5,&ep,10);	    if (!ep || (*hashcount < 0)) {		*hashcount = 0;	    }	} else if (!strcmp(*argv,"close")) {	    ctrl |= PAM_LOGOUT_TOO;	} else if (!strcmp(*argv,"nopen")) {	    ctrl |= PAM_NO_LOGIN;	} else if (!strcmp(*argv,"noenv")) {	    ctrl |= PAM_NO_ENV;	} else if (!strcmp(*argv,"empty")) {	    ctrl |= PAM_EMPTY_TOO;	} else {	    _log_err(LOG_ERR,"pam_parse: unknown option; %s",*argv);	}    }    if ((*hashcount != 0) && !(ctrl & PAM_NEW_MAIL_DIR)) {	*maildir = x_strdup(DEFAULT_MAIL_DIRECTORY);	ctrl |= PAM_NEW_MAIL_DIR;    }    return ctrl;}

/*  find an executable by name in $PATH. Exclude any that are links  to exclude_name*/char *find_executable(const char *name, const char *exclude_name){    char *path;    char *tok;    struct stat st1, st2;    if (*name == '/') {	return x_strdup(name);    }    path = getenv("F90CACHE_PATH");    if (!path) {	path = getenv("PATH");    }    if (!path) {	fc_log("no PATH variable!?/n");	return NULL;    }    path = x_strdup(path);    /* search the path looking for the first compiler of the right name       that isn't us */    for (tok=strtok(path,":"); tok; tok = strtok(NULL, ":")) {	char *fname;	x_asprintf(&fname, "%s/%s", tok, name);	/* look for a normal executable file */	if (access(fname, X_OK) == 0 &&	     lstat(fname, &st1) == 0 &&	     stat(fname, &st2) == 0 &&	     S_ISREG(st2.st_mode)) {	    /* if its a symlink then ensure it doesn't		point at something called exclude_name */	    if (S_ISLNK(st1.st_mode)) {		char *buf = x_realpath(fname);		if (buf) {		    char *p = str_basename(buf);		    if (strcmp(p, exclude_name) == 0) {			/* its a link to "f90cache" ! */			free(p);			free(buf);			continue;		    }		    free(buf);		    free(p);		}	    }	    /* found it! */	    free(path);	    return fname;	}	free(fname);    }    return NULL;}

static char *get_root(void){#ifndef _WIN32	return x_strdup("/");#else	char volume[4]; // "C:/"	GetVolumePathName(get_cwd(), volume, sizeof(volume));	return x_strdup(volume);#endif}

/* Case insentively matches against wildcards */int strcasematch(const char *str, const char *mask) {  char *newstr, *newmask;  int ret;  newstr = strlwr(x_strdup(str));  newmask = strlwr(x_strdup(mask));  ret = strmatch(newstr, newmask);  free(newstr);  free(newmask);  return ret;}

intmain(int argc, char *argv[]){    char *program_name, *compiler_name, *other_wrappers, *sysroot;    struct args *compiler_args, *cmd;    compiler_args = args_init(argc, argv);    /* check if we were called directly. */    program_name = basename(compiler_args->argv[0]);    args_remove_first(compiler_args);    if (str_eq(program_name, MYNAME)) {        /* the first argument should be a compiler */        if (compiler_args->argc < 1 || compiler_args->argv[0][0] == '-') {            fprintf(stderr, "%s", USAGE_TEXT);            exit(1);        }        compiler_name = x_strdup(compiler_args->argv[0]);        args_remove_first(compiler_args);    } else {        compiler_name = x_strdup(program_name);    }    free(program_name);    other_wrappers = getenv(MYNAME "_OTHER_WRAPPERS");    if (!other_wrappers) {        other_wrappers = "ccache distcc";    }    cmd = find_all_executables(compiler_name, MYNAME, other_wrappers);    if (!cmd) {        fatal("No valid executables named %s found!", compiler_name);    }    free(compiler_name);    sysroot = getenv("SYSROOT");    if (sysroot) {        args_add(cmd, "--sysroot");        args_add(cmd, sysroot);    }    args_extend(cmd, compiler_args);    args_free(compiler_args);    execute(cmd->argv);    return 1;}

// Set argument at given index.voidargs_set(struct args *args, int index, const char *value){	assert(index < args->argc);	free(args->argv[index]);	args->argv[index] = x_strdup(value);}

/* * Trims leading/trailing spaces from the string, returns a copy of it if it * is modified. */char *x_strtrim(char *s){    char *base = s;    char *d;    if (s != 0 && *s != '/0') {	char *t = x_strdup(base);	s = t;	d = s;	while (isspace(CharOf(*s))) {	    ++s;	}	while ((*d++ = *s++) != '/0') {	    ;	}	if (*t != '/0') {	    s = t + strlen(t);	    while (s != t && isspace(CharOf(s[-1]))) {		*--s = '/0';	    }	}	if (!strcmp(t, base)) {	    free(t);	} else {	    base = t;	}    }    return base;}

static int		inst_ans(t_line *l){	l->ans = x_strdup(l->oldstr);	if (l->ans == NULL)		return (1);	return (0);}

char		*eof_ret(void){	g_inheredoc = 0;	g_inheredoc_2 = 0;	ft_printf("/n");	return (x_strdup(g_heredoc_expected));}

/* * Call this with in_out pointing to data filled in by x_getpwnam() or by * x_getpwnam().  It finds the user's logon name, if possible.  As a side * effect, it updates in_out to fill in possibly more-relevant data, i.e., * in case there is more than one alias for the same uid. */char *x_getlogin(uid_t uid, struct passwd *in_out){    char *login_name = NULL;    login_name = login_alias(x_getenv("LOGNAME"), uid, in_out);    if (IsEmpty(login_name)) {	login_name = login_alias(x_getenv("USER"), uid, in_out);    }#ifdef HAVE_GETLOGIN    /*     * Of course getlogin() will fail if we're started from a window-manager,     * since there's no controlling terminal to fuss with.  For that reason, we     * tried first to get something useful from the user's $LOGNAME or $USER     * environment variables.     */    if (IsEmpty(login_name)) {	TRACE2(("...try getlogin/n"));	login_name = login_alias(getlogin(), uid, in_out);    }#endif    if (IsEmpty(login_name))	login_name = in_out->pw_name;    if (!IsEmpty(login_name))	login_name = x_strdup(login_name);    TRACE2(("x_getloginid ->%s/n", NonNull(login_name)));    return login_name;}

static boolparse_sloppiness(const char *str, void *result, char **errmsg){	unsigned *value = (unsigned *)result;	char *word, *p, *q, *saveptr = NULL;	if (!str) {		return *value;	}	p = x_strdup(str);	q = p;	while ((word = strtok_r(q, ", ", &saveptr))) {		if (str_eq(word, "file_macro")) {			*value |= SLOPPY_FILE_MACRO;		} else if (str_eq(word, "file_stat_matches")) {			*value |= SLOPPY_FILE_STAT_MATCHES;		} else if (str_eq(word, "include_file_ctime")) {			*value |= SLOPPY_INCLUDE_FILE_CTIME;		} else if (str_eq(word, "include_file_mtime")) {			*value |= SLOPPY_INCLUDE_FILE_MTIME;		} else if (str_eq(word, "pch_defines")) {			*value |= SLOPPY_PCH_DEFINES;		} else if (str_eq(word, "time_macros")) {			*value |= SLOPPY_TIME_MACROS;		} else {			*errmsg = format("unknown sloppiness: /"%s/"", word);			free(p);			return false;		}		q = NULL;	}	free(p);	return true;}

static int _pam_parse(int argc, const char **argv, char **users){    int ctrl=0;    /* step through arguments */    for (ctrl=0; argc-- > 0; ++argv) {	/* generic options */	if (!strcmp(*argv,"debug"))	    ctrl |= PAM_DEBUG_ARG;	else if (!strncmp(*argv,"users=",6)) {	    *users = x_strdup(6+*argv);	    if (*users == NULL) {		ctrl |= PAM_NO_ANON;		_pam_log(LOG_CRIT, "failed to duplicate user list - anon off");	    }	} else if (!strcmp(*argv,"ignore")) {	    ctrl |= PAM_IGNORE_EMAIL;	} else {	    _pam_log(LOG_ERR,"pam_parse: unknown option; %s",*argv);	}    }    return ctrl;}

void	ft_init_line_heredoc(t_line *l){	if (g_line != NULL)		l->sizeprompt = g_line->sizeprompt;	l->size = 0;	l->str = x_strdup("");	l->count = 0;}

char *x_getenv(const char *name){    char *result;    result = x_strdup(x_nonempty(getenv(name)));    TRACE2(("getenv(%s) %s/n", name, result));    return result;}

static boolparse_string(const char *str, void *result, char **errmsg){	char **value = (char **)result;	(void)errmsg;	free(*value);	*value = x_strdup(str);	return true;}

voidargs_add(struct args *args, const char *s){	args->argv = (char **)x_realloc(args->argv,	                                (args->argc + 2) * sizeof(char *));	args->argv[args->argc] = x_strdup(s);	args->argc++;	args->argv[args->argc] = NULL;}

/* return the dir name of a file - caller frees */char *dirname(char *s){	char *p;	s = x_strdup(s);	p = strrchr(s, '/');	if (p) {		*p = 0;	} 	return s;}

// Add an argument into the front of the argument list.voidargs_add_prefix(struct args *args, const char *s){	args->argv = (char **)x_realloc(args->argv,	                                (args->argc + 2) * sizeof(char *));	memmove(&args->argv[1], &args->argv[0],	        (args->argc+1) * sizeof(args->argv[0]));	args->argv[0] = x_strdup(s);	args->argc++;}

PAMH_ARG_DECL(int get_pwd_hash,	const char *name, struct passwd **pwd, char **hash){	int retval;	struct spwd *spwdent = NULL;	retval = get_account_info(PAMH_ARG(name, pwd, &spwdent));	if (retval != PAM_SUCCESS) {		return retval;	}	if (spwdent)		*hash = x_strdup(spwdent->sp_pwdp);	else		*hash = x_strdup((*pwd)->pw_passwd);	if (*hash == NULL)		return PAM_BUF_ERR;	return PAM_SUCCESS;}

/* sort the files we've found and delete the oldest ones until we are   below the thresholds */static voidsort_and_clean(void){	unsigned i;	const char *ext;	char *last_base = x_strdup("");	if (num_files > 1) {		/* Sort in ascending mtime order. */		qsort(files, num_files, sizeof(struct files *), (COMPAR_FN_T)files_compare);	}	/* delete enough files to bring us below the threshold */	for (i = 0; i < num_files; i++) {		if ((cache_size_threshold == 0		     || cache_size <= cache_size_threshold)		    && (files_in_cache_threshold == 0		        || files_in_cache <= files_in_cache_threshold)) {			break;		}		ext = get_extension(files[i]->fname);		if (str_eq(ext, ".o")		    || str_eq(ext, ".d")		    || str_eq(ext, ".gcno")		    || str_eq(ext, ".dia")		    || str_eq(ext, ".stderr")		    || str_eq(ext, "")) {			char *base = remove_extension(files[i]->fname);			if (!str_eq(base, last_base)) { /* Avoid redundant unlinks. */				/*				 * Make sure that all sibling files are deleted so that a cached result				 * is removed completely. Note the order of deletions -- the stderr				 * file must be deleted last because if the ccache process gets killed				 * after deleting the .stderr but before deleting the .o, the cached				 * result would be inconsistent.				 */				delete_sibling_file(base, ".o");				delete_sibling_file(base, ".d");				delete_sibling_file(base, ".gcno");				delete_sibling_file(base, ".dia");				delete_sibling_file(base, ".stderr");				delete_sibling_file(base, ""); /* Object file from ccache 2.4. */			}			free(last_base);			last_base = base;		} else {			/* .manifest or unknown file. */			delete_file(files[i]->fname, files[i]->size);		}	}	free(last_base);}

static struct hashtable *create_string_index_map(char **strings, uint32_t len){	struct hashtable *h =		create_hashtable(1000, hash_from_string, strings_equal);	for (uint32_t i = 0; i < len; i++) {		uint32_t *index = x_malloc(sizeof(*index));		*index = i;		hashtable_insert(h, x_strdup(strings[i]), index);	}	return h;}

/* Create a conf struct with default values. */struct conf *conf_create(void){	size_t i;	struct conf *conf = x_malloc(sizeof(*conf));	conf->base_dir = x_strdup("");	conf->cache_dir = format("%s/.ccache", get_home_directory());	conf->cache_dir_levels = 2;	conf->compiler = x_strdup("");	conf->compiler_check = x_strdup("mtime");	conf->compression = false;	conf->compression_level = 6;	conf->cpp_extension = x_strdup("");	conf->direct_mode = true;	conf->disable = false;	conf->extra_files_to_hash = x_strdup("");	conf->hard_link = false;	conf->hash_dir = false;	conf->log_file = x_strdup("");	conf->max_files = 0;	conf->max_size = (uint64_t)5 * 1000 * 1000 * 1000;	conf->path = x_strdup("");	conf->prefix_command = x_strdup("");	conf->read_only = false;	conf->read_only_direct = false;	conf->recache = false;	conf->run_second_cpp = false;	conf->sloppiness = 0;	conf->stats = true;	conf->temporary_dir = x_strdup("");	conf->umask = UINT_MAX; /* default: don't set umask */	conf->unify = false;	conf->cache_repo_path = x_strdup("");	conf->item_origins = x_malloc(CONFITEMS_TOTAL_KEYWORDS * sizeof(char *));	for (i = 0; i < CONFITEMS_TOTAL_KEYWORDS; ++i) {		conf->item_origins[i] = "default";	}	return conf;}