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

static void_ifparser_source (const char *path, const char *en_dir, int quiet){	char *abs_path;	wordexp_t we;	uint i;	if (g_path_is_absolute (path))		abs_path = g_strdup (path);	else		abs_path = g_build_filename (en_dir, path, NULL);	if (!quiet)		nm_log_info (LOGD_SETTINGS, "      interface-parser: source line includes interfaces file(s) %s/n", abs_path);	/* ifupdown uses WRDE_NOCMD for wordexp. */	if (wordexp (abs_path, &we, WRDE_NOCMD)) {		if (!quiet)			nm_log_warn (LOGD_SETTINGS, "word expansion for %s failed/n", abs_path);	} else {		for (i = 0; i < we.we_wordc; i++)			_recursive_ifparser (we.we_wordv[i], quiet);		wordfree (&we);	}	g_free (abs_path);}

char * word_expansion(char * line){    //on traite les caractères spéciaux    char * new_line = replace_char(line, "|");    char * new_line_2 = replace_char(new_line, "<");    char * new_line_3 = replace_char(new_line_2, ">");    char * new_line_4 = replace_char(new_line_3, "&");    wordexp_t result;    wordexp(new_line_4, &result, 0);    free(new_line_4);    int cmd_offset = 0;    //on calcule la longueur de la nouvelle commande    for(int i=0; i<result.we_wordc; i++)    {        cmd_offset += strlen(result.we_wordv[i]);        cmd_offset++; //derrière chaque commande, il y a un espace    }    //cmd_offset--;    char * max_cmd = malloc(sizeof(char)*cmd_offset);    //initialisation à '/0'    for(int i=0; i<cmd_offset; i++)        max_cmd[i] = '/0';    int tmp_cmd_offset = 0;    //on fait la recopie    for(int i=0; tmp_cmd_offset<cmd_offset; i++)    {        strcat(max_cmd, result.we_wordv[i]);        tmp_cmd_offset += (int)strlen(result.we_wordv[i]);        max_cmd[tmp_cmd_offset++] = ' ';    }    max_cmd[cmd_offset] = '/0';    wordfree(&result);    return max_cmd;}

g_vector<g_string> PinCmd::getFullCmdArgs(uint32_t procIdx, const char** inputFile) {    assert(procIdx < procInfo.size()); //must be one of the topmost processes    g_vector<g_string> res = getPinCmdArgs(procIdx);    g_string cmd = procInfo[procIdx].cmd;    /* Loader injection: Turns out that Pin mingles with the simulated binary, which decides the loader used,     * even when PIN_VM_LIBRARY_PATH is used. This kill the invariance on libzsim.so's loaded address, because     * loaders in different children have different sizes. So, if specified, we prefix the program with the     * given loader. This is optional because it won't work with statically linked binaries.     *     * BTW, thinking of running pin under a specific loaderto fix this instead? Nope, it gets into an infinite loop.     */    if (procInfo[procIdx].loader != "") {        cmd = procInfo[procIdx].loader + " " + cmd;        info("Injected loader on process%d, command line: %s", procIdx, cmd.c_str());        warn("Loader injection makes Pin unaware of symbol routines, so things like routine patching"             "will not work! You can homogeneize the loaders instead by editing the .interp ELF section");    }    //Parse command -- use glibc's wordexp to parse things like quotes, handle argument expansion, etc correctly    wordexp_t p;    wordexp(cmd.c_str(), &p, 0);    for (uint32_t i = 0; i < p.we_wordc; i++) {        res.push_back(g_string(p.we_wordv[i]));    }    wordfree(&p);    //Input redirect    *inputFile = (procInfo[procIdx].input == "")? nullptr : procInfo[procIdx].input.c_str();    return res;}

std::string expandPath(const char* file){	if (!file)		return "";	std::string f;	size_t size = strlen(file);	f.reserve(size);	for (size_t x=0; x<size; x++)	{		if (file[x] == ' ')			f.push_back('//');		f.push_back(file[x]);	}	wordexp_t exp_result;	memset(&exp_result, 0, sizeof(wordexp_t));	int res = wordexp(f.c_str(), &exp_result, 0);	if (res != 0)		return "";	std::string r;	if (exp_result.we_wordv[0])		r = exp_result.we_wordv[0];	wordfree(&exp_result);	return r;}

const char *az_get_app_data_directory(void) {  static char path_buffer[PATH_MAX];  if (path_buffer[0] == '/0') {    // First, do tilde-expansion so we get a path in the user's homedir.    wordexp_t words;    wordexp("~/.azimuth-game", &words, 0);    if (words.we_wordc < 1) {      wordfree(&words);      return NULL;    }    strncpy(path_buffer, words.we_wordv[0], sizeof(path_buffer) - 1);    wordfree(&words);    struct stat stat_buffer;    // Try to stat the desired path.    if (stat(path_buffer, &stat_buffer) == 0) {      // If the path exists but isn't a directory, we fail.      if (!S_ISDIR(stat_buffer.st_mode)) {        path_buffer[0] = '/0';        return NULL;      }    }    // If the directory doesn't exist, try to create it.  If we can't create    // it, or if stat failed for some other reason, we fail.    else if (errno != ENOENT || mkdir(path_buffer, 0700) != 0) {      path_buffer[0] = '/0';      return NULL;    }  }  return path_buffer;}

static char*do_wordexp (const char *path){#ifdef HAVE_WORDEXP_H	wordexp_t wexp;	char *dir;	if (!path) {		/* g_debug ("%s: path is empty", __FUNCTION__); */		return NULL;	}	if (wordexp (path, &wexp, 0) != 0) {		/* g_debug ("%s: expansion failed for %s", __FUNCTION__, path); */		return NULL;	}	/* we just pick the first one */	dir = g_strdup (wexp.we_wordv[0]);	/* strangely, below seems to lead to a crash on MacOS (BSD);	   so we have to allow for a tiny leak here on that	   platform... maybe instead of __APPLE__ it should be	   __BSD__?*/#ifndef __APPLE__	wordfree (&wexp);#endif /*__APPLE__*/	return dir;# else /*!HAVE_WORDEXP_H*//* E.g. OpenBSD does not have wordexp.h, so we ignore it */	return path ? g_strdup (path) : NULL;#endif /*HAVE_WORDEXP_H*/}

static voidmame_expand_string (gchar **p_string){#if HAVE_WORDEXP_H        wordexp_t words;        g_return_if_fail (p_string != NULL);        g_return_if_fail (*p_string != NULL);        /* MAME configurations often use shell variables like $HOME         * in its search and output paths, so we need to expand them. */        if (wordexp (*p_string, &words, WRDE_NOCMD) == 0)        {                GString *buffer;                gsize ii;                buffer = g_string_sized_new (strlen (*p_string));                for (ii = 0; ii < words.we_wordc; ii++)                {                        if (ii > 0)                                g_string_append_c (buffer, ' ');                        g_string_append (buffer, words.we_wordv[ii]);                }                g_free (*p_string);                *p_string = g_string_free (buffer, FALSE);                wordfree (&words);        }#endif}

void NaiveAlgorithm::logPopulationStatistics(){    if (!currentLogFile.is_open()) {        time_t now = time(NULL);        std::stringstream s;        wordexp_t directory;        memset(&directory, 0, sizeof(wordexp_t));        wordexp("~/temp/machines/", &directory, 0);        s << directory.we_wordv[0];        s << "log" << now << ".log";        std::string filename = s.str();                currentLogFile.open(filename.c_str());    }        // write generation #: <list of fitnesses>    currentLogFile << generations << ": ";    std::vector<SystemInfo *>::iterator popIter = population.begin();    while (popIter != population.end()) {        currentLogFile << (*popIter)->fitness << " ";        popIter++;    }    currentLogFile << "/n";    currentLogFile.flush();}

/* @brief Draw an image at the given offset. * * @param cr A cairo context for drawing to the screen. * @param file The image to be drawn. * @return The advance in the x direction. */static uint32_t draw_image(cairo_t *cr, const char *file, offset_t offset) {  wordexp_t expanded_file;  if (wordexp(file, &expanded_file, 0)) {    fprintf(stderr, "Error expanding file %s/n", file);  } else {    file = expanded_file.we_wordv[0];  }  if (access(file, F_OK) == -1) {    fprintf(stderr, "Cannot open image file %s/n", file);    return 0;  }  cairo_surface_t *img;  img = cairo_image_surface_create_from_png(file);  int w = cairo_image_surface_get_width(img);  int h = cairo_image_surface_get_height(img);  int neww = (int)(((float)(settings.height) * ((float)(w) / (float)(h))) + 0.49999999);  img = scale_surface (img, w, h, neww, settings.height);  h = settings.height;  w = neww;  /* Attempt to center the image if it is not the height of the line. */   int image_offset = (h - settings.height) / 2;  cairo_set_source_surface(cr, img, offset.x, offset.image_y - h + image_offset);  cairo_mask_surface(cr, img, offset.x, offset.image_y - h + image_offset);  return w;}

std::string DataDirLocater::SubstEnvVars(const std::string& in) const{	std::string out;#ifdef _WIN32	const size_t maxSize = 32 * 1024;	char out_c[maxSize];	ExpandEnvironmentStrings(in.c_str(), out_c, maxSize); // expands %HOME% etc.	out = out_c;#else	std::string previous = in;	for (int i = 0; i < 10; ++i) { // repeat substitution till we got a pure absolute path		wordexp_t pwordexp;		int r = wordexp(previous.c_str(), &pwordexp, WRDE_NOCMD); // expands $FOO, ${FOO}, ${FOO-DEF} ~/, etc.		if (r == EXIT_SUCCESS) {			if (pwordexp.we_wordc > 0) {				out = pwordexp.we_wordv[0];;				for (unsigned int w = 1; w < pwordexp.we_wordc; ++w) {					out += " ";					out += pwordexp.we_wordv[w];				}			}			wordfree(&pwordexp);		} else {			out = in;		}		if (previous == out) {			break;		}		previous.swap(out);	}#endif	return out;}

static voidxdg_open_selection_cb (GtkClipboard *clipboard, const char *string, gpointer data){    char *command;    wordexp_t result;    gboolean spawn;    GError *spawn_error = NULL;    command = g_strconcat ("xdg-open ", string, NULL);    switch (wordexp (command, &result, WRDE_NOCMD)) {        case 0:            break;        case WRDE_BADCHAR:            fprintf (stderr, "'%s' contains an invalid character/n", string);            goto finalize;        case WRDE_CMDSUB:            fprintf (stderr, "'%s' uses command substitution, which is not allowed/n", string);            goto finalize;        case WRDE_NOSPACE:            fprintf (stderr, "Could not allocate enough memory when parsing '%s'/n", string);            goto finalize;        case WRDE_SYNTAX:            fprintf (stderr, "Syntax error in '%s'/n", string);            goto finalize;    }    spawn = g_spawn_async (NULL, result.we_wordv, NULL, G_SPAWN_SEARCH_PATH,                           NULL, NULL, NULL, &spawn_error);    if (!spawn) {        fprintf (stderr, "%s/n", spawn_error->message);        g_error_free (spawn_error);    }    finalize:        wordfree (&result);}

static char *get_config_path(void) {	static const char *config_paths[] = {		"$HOME/.sway/config",		"$XDG_CONFIG_HOME/sway/config",		"$HOME/.i3/config",		"$XDG_CONFIG_HOME/i3/config",                FALLBACK_CONFIG_DIR "/config",		"/etc/i3/config",	};	if (!getenv("XDG_CONFIG_HOME")) {		char *home = getenv("HOME");		char *config_home = malloc(strlen("home") + strlen("/.config") + 1);		strcpy(config_home, home);		strcat(config_home, "/.config");		setenv("XDG_CONFIG_HOME", config_home, 1);		sway_log(L_DEBUG, "Set XDG_CONFIG_HOME to %s", config_home);	}	wordexp_t p;	char *path;	int i;	for (i = 0; i < (int)(sizeof(config_paths) / sizeof(char *)); ++i) {		if (wordexp(config_paths[i], &p, 0) == 0) {			path = p.we_wordv[0];			if (file_exists(path)) {				return path;			}		}	}	return NULL; // Not reached}

static intglob_for_cachedir(char *path){    int ret = 1;    if (!str_endswith(path, "XXXXXX"))	return ret;    wordexp_t word_vector;    char *p = solv_strdup(path);    const int len = strlen(p);    struct stat s;    ret = 2;    p[len-6] = '*';    p[len-5] = '/0';    if (wordexp(p, &word_vector, 0)) {	solv_free(p);	return ret;    }    for (int i = 0; i < word_vector.we_wordc; ++i) {	char *entry = word_vector.we_wordv[i];	if (stat(entry, &s))	    continue;	if (S_ISDIR(s.st_mode) &&	    s.st_uid == getuid()) {	    assert(strlen(path) == strlen(entry));	    strcpy(path, entry);	    ret = 0;	    break;	}    }    wordfree(&word_vector);    solv_free(p);    return ret;}

std::string ConfigurationManager::retrieveAsPath(std::string namespaceName, std::string identifier, std::string defaultValue){	std::string result = defaultValue;		EntriesMap::const_iterator iter = entries->find(std::make_pair(namespaceName, identifier));	if(iter != entries->end())	{		wordexp_t expansion;		int expansionResult = 0;			expansionResult = wordexp(iter->second.c_str(), &expansion, WRDE_NOCMD);		if(expansionResult == 0 && expansion.we_wordc > 0)		{			result.clear();			for(int i=0;i<expansion.we_wordc;i++)			{				result += expansion.we_wordv[i];			}		}		wordfree(&expansion);		if(result[0] != '/') // relative path, need to prefix with workingDir		{			result = workingDir + result;		}	}	return result;}

static int get_dclick_time (void){    FILE *fp;    char buf[256];    int val;    wordexp_t exp;    struct stat st;    // check to see if there is a gtkrc file in the home directory    wordexp ("~/.gtkrc-2.0", &exp, 0);    if (stat (exp.we_wordv[0], &st) != 0)    {        // there isn't - create one with default value        sprintf (buf, "echo gtk-double-click-time=250 > %s", exp.we_wordv[0]);        system (buf);        return 250;    }    // there is a file - does it contain a value?    fp = popen ("grep gtk-double-click-time ~/.gtkrc-2.0", "r");    if (fp == NULL) return 0;  // should never happen...    if (fgets (buf, sizeof (buf) - 1, fp) != NULL)    {        if (sscanf (buf, "gtk-double-click-time=%d", &val) == 1) return val;    }    // no matching parameter in file - prepend one	sprintf (buf, "sed -i /"1i gtk-double-click-time=250/" %s", exp.we_wordv[0]);    system (buf);    return 250;}

void files(void) {    FILE *inputFile;    //Expand filename from leading tilde    wordexp_t exp_result;	wordexp("~/.bash_profile", &exp_result, 0);    char* filename = exp_result.we_wordv[0];            int c; //getc returns an int to allow for EOF        if ( (inputFile = fopen(filename, "r")) != NULL) {        printf("Opened file: %s/n/n", filename);        while( (c = getc(inputFile)) != EOF ) {            putchar(c);        }                //Extraneous, for example        if (feof(inputFile)) {            printf("End of file confirmed!/n");        }                fclose(inputFile);        printf("Closed file: %s/n", filename);    }    else {        //stdin, stdout, stderr are always available        fprintf(stderr, "Failed to open file: %s/n", strerror( errno ));    }    }

char *swaynag_get_config_path(void) {	static const char *config_paths[] = {		"$HOME/.swaynag/config",		"$XDG_CONFIG_HOME/swaynag/config",		SYSCONFDIR "/swaynag/config",	};	char *config_home = getenv("XDG_CONFIG_HOME");	if (!config_home || config_home[0] == '/0') {		config_paths[1] = "$HOME/.config/swaynag/config";	}	wordexp_t p;	for (size_t i = 0; i < sizeof(config_paths) / sizeof(char *); ++i) {		if (wordexp(config_paths[i], &p, 0) == 0) {			char *path = strdup(p.we_wordv[0]);			wordfree(&p);			if (file_exists(path)) {				return path;			}			free(path);		}	}	return NULL;}

static void expansion_demo(char const *str){  printf("Before expansion: %s/n", str);  wordexp_t exp;  wordexp(str, &exp, 0);  printf("After expansion: %s/n", exp.we_wordv[0]);  wordfree(&exp);}

struct LineNode *GetLines(const char *FilePath){    FILE *file = NULL;    struct LineNode *head = NULL;    struct LineNode *tail = NULL;    char *currentLine = NULL;    size_t lineLength = 0;    wordexp_t expanded;    memset(&expanded, 0, sizeof(wordexp_t));    //Expand the path based on any shell characters given.    wordexp(FilePath, &expanded, 0);    check(expanded.we_wordv[0] != NULL, "Unable to expand file path for %s", FilePath);    file = fopen(expanded.we_wordv[0], "r");    check(file != NULL, "Unable to open file: %s.", FilePath);        //Get the first line and set it to the head of the list.    check(getline(&currentLine, &lineLength, file) != -1, "Unable to read line, or EOF.");    head = GetNode(currentLine, 1);    check(head != NULL, "Unable to get the first line of the file.");    tail = head;    //We have to set currentLine to NULL, otherwise     //we're reusing the same memory for each line...    currentLine = NULL;    //Get the rest of the lines...    while(getline(&currentLine, &lineLength, file) != -1)    {        int LineNumber = tail->LineNumber + 1;        struct LineNode *newNode = GetNode(currentLine, LineNumber);        check(newNode != NULL, "Unable to get line %d.", LineNumber);        tail->Next = newNode;        tail = newNode;        currentLine = NULL;    }    if(file)        fclose(file);    return head;    error:    //We clean up whatever has been constructed of the linked list...    DeleteLines(head);    if(file)        fclose(file);    return NULL;}

static void include_file(char *file){	wordexp_t exp_result;	wordexp(file,&exp_result,0);	strcpy(file,exp_result.we_wordv[0]);	g_print("Including %s file/n",file);	proc_lines(file);	g_print("Finished including %s file/n",file);	return;}

void Process(const char * i_lpszType, const char ** i_lpszCol_Names){    XDATASET	cFile;    XDATASET	cCombined;    wordexp_t cResults;    char lpszSearchFile[64];    char lpszOutputFile[64];    unsigned int uiColors[8][2] =    {        {2,4}, // u - v        {2,3}, // u - b        {3,4}, // b - v        {7,5}, // uvm2 - uvw1        {6,5}, // uvw2 - uvw1        {7,4}, // uvm2 - v        {6,4}, // uw2 - v        {5,4} // uw1 - v    };    sprintf(lpszSearchFile,"*%s*photometry.csv",i_lpszType);    sprintf(lpszOutputFile,"%s_photometry.csv",i_lpszType);    if (wordexp(lpszSearchFile,&cResults,WRDE_NOCMD|WRDE_UNDEF) == 0)    {        if (cResults.we_wordc > 0)        {            printf("Count %i/n",cResults.we_wordc);            unsigned int uiCount = cResults.we_wordc;            for (unsigned int uiI = 0; uiI < cResults.we_wordc; uiI++)                if (strcmp(cResults.we_wordv[uiI],lpszOutputFile) == 0)                    uiCount--;            if (uiCount > 0)                cCombined.Allocate(17,uiCount);            uiCount = 0;            for (unsigned int uiI = 0; uiI < cResults.we_wordc; uiI++)            {                if (strcmp(cResults.we_wordv[uiI],lpszOutputFile) != 0)                {                    printf("Reading %s/n",cResults.we_wordv[uiI]);                    cFile.ReadDataFile(cResults.we_wordv[uiI],false,false,',',1);                    for(unsigned int uiJ = 0; uiJ < 9; uiJ++)                        cCombined.SetElement(uiJ,uiCount,cFile.GetElement(uiJ,0));                    for (unsigned int uiJ = 0; uiJ < 8; uiJ++)                        cCombined.SetElement(9 + uiJ,uiCount,cFile.GetElement(uiColors[uiJ][0],0) - cFile.GetElement(uiColors[uiJ][1],0));                    uiCount++;                }            }            if (uiCount > 0)                cCombined.SaveDataFileCSV(lpszOutputFile,i_lpszCol_Names);            wordfree(&cResults);        }    }}

static char* icon_file(char *menu_file, char *icon){	wordexp_t exp_result;	if(find_match(menu_file,"^(.*//[begin//]) (.*) (<)(.+)(>)",4,icon)==NULL)		return NULL;	wordexp(icon,&exp_result,0);	strcpy(icon,exp_result.we_wordv[0]);	return icon;}

char *expand_path(char *path){    wordexp_t exp_result;    wordexp(path, &exp_result, 0);    char *expanded = strdup(exp_result.we_wordv[0]);    wordfree(&exp_result);    return expanded;}

/** * A simple ASON REPL shell. **/intmain(void){	ason_ns_t *ns = ason_ns_create(ASON_NS_RAM, "");	char *line;	ason_t *value;	wordexp_t exp;	if (wordexp("~/.asonq", &exp, 0))		errx(1, "Could not perform shell expansion");	if (! ns)		errx(1, "Could not create namespace");	using_history();	read_history(exp.we_wordv[0]);	for (;;) {		line = readline("> ");		if (! line) {			printf("/n");			break;		}		if (! *line) {			free(line);			continue;		}		add_history(line);		write_history(exp.we_wordv[0]);		if (command(line, ns)) {			free(line);			continue;		}		value = ason_ns_read(ns, line);		free(line);		if (! value) {			printf("Syntax Error/n");			continue;		}		line = ason_asprint_unicode(value);		if (! line)			errx(1, "Could not serialize value");		printf("%s/n", line);		free(line);	}}

static voidcommand_line_test (const char *words){  wordexp_t we;  int i;  int retval = wordexp (words, &we, 0);  printf ("wordexp returned %d/n", retval);  for (i = 0; i < we.we_wordc; i++)    printf ("we_wordv[%d] = /"%s/"/n", i, we.we_wordv[i]);}

int ush_wordexp(char *s, wordexp_t *exp, int flags){	int ret = wordexp(s, exp, flags);	if(ret == 0){		/* TODO: $(cmd), `cmd` */	}	return ret;}

int main(int argc, char *argv[]){pid_t nb_pid;struct winsize ws;wordexp_t env_wordexp;char *env_progress_args;char *env_progress_args_full;env_progress_args = getenv("PROGRESS_ARGS");if (env_progress_args) {    int full_len;    // prefix with (real) argv[0]    // argv[0] + ' ' + env_progress_args + '/0'    full_len = strlen(argv[0]) + 1 + strlen(env_progress_args) + 1;    env_progress_args_full = malloc(full_len * sizeof(char));    sprintf(env_progress_args_full, "%s %s", argv[0], env_progress_args);    if (wordexp(env_progress_args_full, &env_wordexp, 0)) {        fprintf(stderr,"Unable to parse PROGRESS_ARGS environment variable./n");        exit(EXIT_FAILURE);    }    parse_options(env_wordexp.we_wordc,env_wordexp.we_wordv);}parse_options(argc,argv);// ws.ws_row, ws.ws_colioctl(STDOUT_FILENO, TIOCGWINSZ, &ws);if (flag_monitor || flag_monitor_continuous) {    if ((mainwin = initscr()) == NULL ) {        fprintf(stderr, "Error initialising ncurses./n");        exit(EXIT_FAILURE);    }    if (!flag_throughput) {      flag_throughput = 1;      throughput_wait_secs = 1;    }    set_hlist_size(throughput_wait_secs);    signal(SIGINT, int_handler);    do {        monitor_processes(&nb_pid);        refresh();        if(flag_monitor_continuous && !nb_pid) {          usleep(1000000 * throughput_wait_secs);        }    } while ((flag_monitor && nb_pid) || flag_monitor_continuous);    endwin();}else {    set_hlist_size(throughput_wait_secs);    monitor_processes(&nb_pid);}return 0;}

/* * Transforms the properties read from the repository for a method into a * method_info_t and returns a pointer to it. If expansion of the exec * property fails, due to an invalid string or memory allocation failure, * NULL is returned and exec_invalid is set appropriately to indicate whether * it was a memory allocation failure or an invalid exec string. */static method_info_t *create_method_info(const inetd_prop_t *mprops, boolean_t *exec_invalid){	method_info_t	*ret;	int		i;	debug_msg("Entering create_method_info");	if ((ret = calloc(1, sizeof (method_info_t))) == NULL)		goto alloc_fail;	/* Expand the exec string. */	if ((i = wordexp(get_prop_value_string(mprops, PR_EXEC_NAME),	    &ret->exec_args_we, WRDE_NOCMD|WRDE_UNDEF)) != 0) {		if (i == WRDE_NOSPACE)			goto alloc_fail;		*exec_invalid = B_TRUE;		free(ret);		return (NULL);	}	if ((ret->exec_path = strdup(ret->exec_args_we.we_wordv[0])) == NULL)		goto alloc_fail;	if (mprops[MP_ARG0].ip_error == IVE_VALID) {	/* arg0 is set */		/*		 * Keep a copy of arg0 of the wordexp structure so that		 * wordfree() gets passed what wordexp() originally returned,		 * as documented as required in the man page.		 */		ret->wordexp_arg0_backup = ret->exec_args_we.we_wordv[0];		if ((ret->exec_args_we.we_wordv[0] =		    strdup(get_prop_value_string(mprops, PR_ARG0_NAME)))		    == NULL)			goto alloc_fail;	}	if (mprops[MP_TIMEOUT].ip_error == IVE_VALID) {		ret->timeout = get_prop_value_count(mprops,		    SCF_PROPERTY_TIMEOUT);	} else {		ret->timeout = DEFAULT_METHOD_TIMEOUT;	}	/* exec_invalid not set on success */	return (ret);alloc_fail:	error_msg(strerror(errno));	destroy_method_info(ret);	*exec_invalid = B_FALSE;	return (NULL);}

static char* fluxbox_menu_file(char* init_file, char *menu_file){	wordexp_t exp_result;	if(find_match(init_file,"^(session//.menuFile:)(.*)$",2,menu_file)==NULL){		g_error("Could not find the menu file on config in %s",init_file);		return NULL;	}	wordexp(menu_file,&exp_result,0);	strcpy(menu_file,exp_result.we_wordv[0]);	return menu_file;}