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

void KX_FontObject::UpdateBuckets(){	// Update datas and add mesh slot to be rendered only if the object is not culled.	if (m_bVisible && m_meshUser) {		if (m_pSGNode->IsDirty()) {			GetOpenGLMatrix();		}		// Allow for some logic brick control		if (GetProperty("Text")) {			m_text = split_string(GetProperty("Text")->GetText());		}		// update the animated color		GetObjectColor().getValue(m_color);		// Font Objects don't use the glsl shader, this color management code is copied from gpu_shader_material.glsl		float color[4];		if (m_do_color_management) {			linearrgb_to_srgb_v4(color, m_color);		}		else {			copy_v4_v4(color, m_color);		}		// HARDCODED MULTIPLICATION FACTOR - this will affect the render resolution directly		const float RES = BGE_FONT_RES * m_resolution;		const float size = m_fsize * NodeGetWorldScaling()[0] * RES;		const float aspect = m_fsize / size;		// Account for offset		MT_Vector3 offset = NodeGetWorldOrientation() * m_offset * NodeGetWorldScaling();		// Orient the spacing vector		MT_Vector3 spacing = NodeGetWorldOrientation() * MT_Vector3(0.0f, m_fsize * m_line_spacing, 0.0f) * NodeGetWorldScaling()[1];		RAS_TextUser *textUser = (RAS_TextUser *)m_meshUser;		textUser->SetColor(MT_Vector4(color));		textUser->SetFrontFace(!m_bIsNegativeScaling);		textUser->SetFontId(m_fontid);		textUser->SetSize(size);		textUser->SetDpi(m_dpi);		textUser->SetAspect(aspect);		textUser->SetOffset(offset);		textUser->SetSpacing(spacing);		textUser->SetTexts(m_text);		textUser->ActivateMeshSlots();	}}

	void SettingItem::AddValues(string vals) {		if (vals.find(MULTIVAL_DELIMITER) != -1) {			// more than one value			vector<string> multiVals; 			split_string(vals, MULTIVAL_DELIMITER, multiVals);						for (string valpart : multiVals) {				values.push_back(valpart);			}		}		else {			values.push_back(vals);		}	}

static void enable_display(){    current_bindings.clear();    sorted_keys.clear();    display_active = true;    skip_frames = 2;    page = 0;    vector<string> generic_keys;    auto focus_string = "@" + Gui::getFocusString(Core::getTopViewscreen());    for (int shifted = 0; shifted < 2; shifted++)    {        for (int ctrl = 0; ctrl < 2; ctrl++)        {            for (int alt = 0; alt < 2; alt++)            {                for (char c = 'A'; c <= 'Z'; c++)                {                    string sym;                    if (shifted) sym += "Shift-";                    if (ctrl) sym += "Ctrl-";                    if (alt) sym += "Alt-";                    sym += c;                    auto list = Core::getInstance().ListKeyBindings(sym);                    for (auto mode = list.begin(); mode != list.end(); mode++)                    {                        if (mode->find(":") == string::npos)                        {                            current_bindings[sym] = *mode;                            generic_keys.push_back(sym);                        }                        else                        {                            vector<string> tokens;                            split_string(&tokens, *mode, ":");                            if (tokens[0] == focus_string)                            {                                current_bindings[sym] = tokens[1];                                sorted_keys.push_back(sym);                            }                        }                    }                }            }        }    }    sorted_keys.insert(sorted_keys.end(), generic_keys.begin(), generic_keys.end());    resize();}

int roll_dice(const std::string& die){  auto num_and_sides = split_string(die, 'd');  int num = atoi(num_and_sides[0].c_str());  int sides = atoi(num_and_sides[1].c_str());  int sum = 0;  for (int i = 0; i < num; i++)  {    sum += random(1, sides);  }  return sum;}

voidrest_test2d (void){  GOptionContext *context;  gboolean retval;  GError *error = NULL;  gchar **argv;  int argc;#ifndef SYMBIAN    GOptionEntry entries [] = {       { "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },      { NULL }   };#else    GOptionEntry entries [2];    entries[0].long_name = "test";  entries[0].short_name = 0;  entries[0].flags = 0;  entries[0].arg = G_OPTION_ARG_NONE;  entries[0].arg_data = (gpointer)&ignore_test1_boolean;  entries[0].description =  NULL;  entries[0].arg_description = NULL;        entries[1].long_name = NULL;  entries[1].short_name = 0;  entries[1].arg_data = NULL;  entries[1].description =  NULL;  entries[1].arg_description = NULL;#endif          context = g_option_context_new (NULL);  g_option_context_add_main_entries (context, entries, NULL);  /* Now try parsing */  argv = split_string ("program --test -- -bar", &argc);    retval = g_option_context_parse (context, &argc, &argv, &error);  g_assert (retval);  /* Check array */  g_assert (ignore_test1_boolean);  g_assert (strcmp (argv[0], "program") == 0);  g_assert (strcmp (argv[1], "--") == 0);  g_assert (strcmp (argv[2], "-bar") == 0);  g_assert (argv[3] == NULL);  g_strfreev (argv);  g_option_context_free (context);}

int parse_ip_port(char *line, t_ip_addr *ip, int *port) {	char *s_ip, *s_port, sep = '?';	if ((line == NULL) || (ip == NULL) || (port == NULL)) {		return -1;	}#ifdef ENABLE_IPV6	if (split_string(line, &s_ip, &s_port, ']') == 0) {		if ((*s_ip != '[') || (*s_port != ':')) {			return -1;		}		s_ip = remove_spaces(s_ip + 1);		s_port = remove_spaces(s_port + 1);	} else#endif	{		s_port = line + strlen(line);		do {			if (s_port <= line) {				return -1;			}			s_port--;		} while ((*s_port != ':') && (*s_port != '.'));		sep = *s_port;		*s_port = '/0';		s_ip = remove_spaces(line);		s_port = remove_spaces(s_port + 1);	}	if (parse_ip(s_ip, ip) == -1) {		return -1;	} else if ((*port = str2int(s_port)) <= 0) {		return -1;	}	if (sep != '?') {		if ((ip->family == AF_INET) && (sep != ':')) {			return -1;		}#ifdef ENABLE_IPV6		if ((ip->family == AF_INET6) && (sep != '.')) {			return -1;		}#endif	}	return 0;}

// Parse given urlvoid URI :: parse( std::string url ){	// Part url into (protocol, rest)	std::vector< std::string > parts = split_string( url, "://" ); 	std::string rest;		// If something essential is missing....	if( parts.size() < 2 ){		// error handling		throw std::string( "Invalid URI!" );		return;		}		protocol = parts[0];		// If there was more of the "://" parts in the url, parse them back together	if( parts.size() > 2 ){		for( size_t i = 1 ; i < parts.size()-1 ; ++i ){			rest += parts[i] + std::string( "://" );			}		rest += parts[parts.size()-1];		}	else{		rest = parts[1];		}		size_t pos = rest.find_first_of( "/" );	// If path separator is not there default into "/"	if( pos == std::string::npos ){		port = "80";		path = "/";		host = rest;		return;		}	host = rest.substr( 0, pos );	path = rest.substr( pos, rest.size() - pos );		// If no port provided	if( host.find_first_of( ":" ) == std::string::npos ){		port = "80";		}	else{		// Parse port, find_last_of is used because of the ivp6-addresses		pos = host.find_last_of( ":" );		port = host.substr( pos+1, host.size()-pos );		host = host.substr( 0, pos );		}		}

  std::vector<libtocc::FileInfo> FSHandler::query_by_path(std::string path)  {    // We assume that each element of the path is a tag, and return    // everything matches with it.    std::vector<std::string> path_items = split_string(path, '/');    // The previous step didn't find the correct result. Now, assuming    // that all the elements in path are tags.    std::vector<std::string>::iterator path_items_iterator = path_items.begin();    // Adding first element to the And.    libtocc::Tag first_tag(path_items_iterator->c_str());    libtocc::And third_main_and(first_tag);    path_items_iterator++;    for (; path_items_iterator != path_items.end(); path_items_iterator++)    {      if (*path_items_iterator == ".." || *path_items_iterator == ".")      {        // Ignore . or ..        continue;      }      libtocc::Tag tag_expr(path_items_iterator->c_str());      third_main_and.add(tag_expr);    }    // Executing the query.    libtocc::Query third_query(third_main_and);    libtocc::FileInfoCollection third_query_result =        this->libtocc_manager->search_files(third_query);    if (third_query_result.size() > 0)    {      std::vector<libtocc::FileInfo> result;      libtocc::FileInfoCollection::Iterator query_result_iterator(&third_query_result);      for (; !query_result_iterator.is_finished(); query_result_iterator.next())      {        result.push_back(*query_result_iterator.get());      }      return result;    }    // Nothing found? Returning an empty result.    std::vector<libtocc::FileInfo> result;    return result;  }

voidignore_test2 (void){  GOptionContext *context;  gboolean retval;  GError *error = NULL;  gchar **argv;  int argc;  gchar *arg;#ifndef SYMBIAN    GOptionEntry entries [] =    { { "test", 't', 0, G_OPTION_ARG_NONE, &ignore_test2_boolean, NULL, NULL },      { NULL } };#else        GOptionEntry entries [2];    entries[0].long_name = "test";  entries[0].short_name = 't';  entries[0].flags = 0;  entries[0].arg = G_OPTION_ARG_NONE;  entries[0].arg_data = (gpointer)&ignore_test2_boolean;  entries[0].description =  NULL;  entries[0].arg_description = NULL;        entries[1].long_name = NULL;  entries[1].short_name = 0;  entries[1].arg_data = NULL;  entries[1].description =  NULL;  entries[1].arg_description = NULL;#endif        context = g_option_context_new (NULL);  g_option_context_set_ignore_unknown_options (context, TRUE);  g_option_context_add_main_entries (context, entries, NULL);  /* Now try parsing */  argv = split_string ("program -test", &argc);    retval = g_option_context_parse (context, &argc, &argv, &error);  g_assert (retval);  /* Check array */  arg = join_stringv (argc, argv);  g_assert (strcmp (arg, "program -es") == 0);  g_free (arg);  g_strfreev (argv);  g_option_context_free (context);}

voidarray_test1 (void){  GOptionContext *context;  gboolean retval;  GError *error = NULL;  gchar **argv;  int argc;#ifndef SYMBIAN    GOptionEntry entries [] =    { { "test", 0, 0, G_OPTION_ARG_STRING_ARRAY, &array_test1_array, NULL, NULL },      { NULL } };#else       GOptionEntry entries [2];    entries[0].long_name = "test";  entries[0].short_name = 0;  entries[0].flags = 0;  entries[0].arg = G_OPTION_ARG_STRING_ARRAY;  entries[0].arg_data = (gpointer)&array_test1_array;  entries[0].description =  NULL;  entries[0].arg_description = NULL;        entries[1].long_name = NULL;  entries[1].short_name = 0;  entries[1].arg_data = NULL;  entries[1].description =  NULL;  entries[1].arg_description = NULL;#endif                context = g_option_context_new (NULL);  g_option_context_add_main_entries (context, entries, NULL);  /* Now try parsing */  argv = split_string ("program --test foo --test bar", &argc);    retval = g_option_context_parse (context, &argc, &argv, &error);  g_assert (retval);  /* Check array */  g_assert (strcmp (array_test1_array[0], "foo") == 0);  g_assert (strcmp (array_test1_array[1], "bar") == 0);  g_assert (array_test1_array[2] == NULL);  g_strfreev (array_test1_array);    g_strfreev (argv);  g_option_context_free (context);}

voidcallback_test_optional_4 (void){  GOptionContext *context;  gboolean retval;  GError *error = NULL;  gchar **argv;  int argc;#ifndef SYMBIAN    GOptionEntry entries [] =    { { "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK, 	callback_parse_optional, NULL, NULL },      { NULL } };#else        GOptionEntry entries [2];    entries[0].long_name = "test";  entries[0].short_name = 't';  entries[0].flags = G_OPTION_FLAG_OPTIONAL_ARG;  entries[0].arg = G_OPTION_ARG_CALLBACK;  entries[0].arg_data = (gpointer)callback_parse_optional;  entries[0].description =  NULL;  entries[0].arg_description = NULL;        entries[1].long_name = NULL;  entries[1].short_name = 0;  entries[1].arg_data = NULL;  entries[1].description =  NULL;  entries[1].arg_description = NULL;#endif          context = g_option_context_new (NULL);  g_option_context_add_main_entries (context, entries, NULL);  /* Now try parsing */  argv = split_string ("program -t", &argc);    retval = g_option_context_parse (context, &argc, &argv, &error);  g_assert (retval);  g_assert (callback_test_optional_string == NULL);    g_assert (callback_test_optional_boolean);  g_free (callback_test_optional_string);    g_strfreev (argv);  g_option_context_free (context);}

void		case_content(t_server *server, t_client *client, char *str){  t_case	*pos;  char		*x;  char		*y;  if ((x = split_string(str, ' ', 1)) != NULL)    {      if ((y = split_string(str, ' ', 2)) != NULL)	{	  pos = find_case_by_index(server->map, atoi(x), atoi(y));	  if (pos != NULL)	    print_resources(client, pos, atoi(x), atoi(y));	  else	    client->messages = append_list(client->messages, strdup("sbp/n"));	  free(y);	}      else	client->messages = append_list(client->messages, strdup("sbp/n"));      free(x);    }  else    client->messages = append_list(client->messages, strdup("sbp/n"));}

void		makedir(t_server *serv, char *cmd){  char		*dir;  dir = split_string(cmd, ' ', 1);  if (dir != NULL)    {      if (mkdir(dir, 0775) == -1)	swrite(serv->cfd, "552 Folder exists/r/n");      else	swrite(serv->cfd, "257 Folder create/r/n");    }  else    swrite(serv->cfd, "501 You must enter a folder name/r/n");}

// parallel update new web linksvoid* parallel_update(void* _parallel_init_info) {	assert(_parallel_init_info != NULL);	parallel_i_info* info = (parallel_i_info*) _parallel_init_info;	assert(info->w != NULL);	assert(info->c != NULL);		web* w = info->w;	redisContext **c = info->c;	size_t n_threads = info->n_threads;	size_t id = info->id;	int mod = (int)n_threads;	redisReply *reply;		reply = redisCommand(c[id], "RENAME newly.edited.linkfrom reading.edited.linkfrom");	freeReplyObject(reply);	reply = redisCommand(c[id], "LRANGE reading.edited.linkfrom 0 -1");		//printf("LRANGE reading.edited.linkfrom 0 -1/n");	if (reply->type == REDIS_REPLY_ARRAY) {		for (unsigned int i = 0; i < reply->elements; ++i) {			char* uid1 = calloc(12, sizeof(char));			char* uid2 = calloc(12, sizeof(char));			split_string(reply->element[i]->str, uid1, uid2, ':');						int from_uid = atoi(uid2);			int to_uid = atoi(uid1);			int lock_id = to_uid % mod;						vec_push(w->webnodes[to_uid]->in_links, from_uid);#ifdef USE_SPINLOCK			pthread_spin_lock(&g_spin_locks[lock_id]);#else			pthread_mutex_lock(&g_mutex_locks[lock_id]);#endif			++w->webnodes[from_uid]->out_links_num;#ifdef USE_SPINLOCK			pthread_spin_unlock(&g_spin_locks[lock_id]);#else			pthread_mutex_unlock(&g_mutex_locks[lock_id]);#endif		}	}	freeReplyObject(reply);	reply = redisCommand(c[id], "DEL reading.edited.linkfrom");	//printf("DEL reading.edited.linkfrom/n");	freeReplyObject(reply);	return NULL;}

	void Master::AddSlave(Channel* slave, RedisCommandFrame& cmd)	{		DEBUG_LOG("Recv sync command:%s", cmd.ToString().c_str());		slave->Flush();		SlaveConnection* conn = NULL;		NEW(conn, SlaveConnection);		conn->conn = slave;		if (!strcasecmp(cmd.GetCommand().c_str(), "sync"))		{			//Redis 2.6/2.4 send 'sync'			conn->isRedisSlave = true;			conn->sync_offset = -1;		} else		{			conn->server_key = cmd.GetArguments()[0];			const std::string& offset_str = cmd.GetArguments()[1];			if (!string_toint64(offset_str, conn->sync_offset))			{				ERROR_LOG("Invalid offset argument:%s", offset_str.c_str());				slave->Close();				DELETE(conn);				return;			}			//Redis 2.8+ send psync, Ardb send psync2			if (!strcasecmp(cmd.GetCommand().c_str(), "psync"))			{				conn->isRedisSlave = true;			} else			{				conn->isRedisSlave = false;				if (cmd.GetArguments().size() >= 3)				{					std::vector<std::string> ss = split_string(cmd.GetArguments()[2], "|");					for (uint32 i = 0; i < ss.size(); i++)					{						DBID id;						if (string_touint32(ss[i], id))						{							conn->syncdbs.insert(id);						}					}				}			}		}		m_server->m_service->DetachChannel(slave, true);		ReplicationInstruction inst(conn, REPL_INSTRUCTION_ADD_SLAVE);		OfferReplInstruction(inst);	}

int main( int argc, char **argv ){	IrrealContext context;	IrrealStack code;	if( argc < 2 ){		fprintf( stderr, "Usage: %s file/n/n", argv[0] );		return 1;		}	init_threading();		std::string text = read_file( argv[1] );	//printf( "'%s'/n", text.c_str() );	std::vector<std::string> tokens = split_string( text );	for( size_t i = 0 ; i < tokens.size() ; ++i ){		//printf( "%s/n", tokens[i].c_str() );		code.push( extract_value( tokens[i] ) );		}		//code._debug_print();		context.getCodeStack()->merge( &code, true );	global_vm_queue.push_front( context.get_id() );		++global_running_vms;		pthread_t workers[ NUM_OF_THREADS ];	pthread_attr_t attr;		void *status;		pthread_attr_init( &attr );	pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );		for( size_t i = 0 ; i < NUM_OF_THREADS ; ++i ){		pthread_create( &workers[i], &attr, worker_thread, (void *)i );		}		pthread_attr_destroy( &attr );		for( size_t i = 0 ; i < NUM_OF_THREADS ; ++i ){		pthread_join( workers[i], &status ); 		}	pthread_exit( NULL );	return 0;	}

bool	StringToPoint2( const std::string& str , SsPoint2& point ){	std::vector<SsString>	str_list;	split_string( str , ' ' , str_list );	if ( str_list.size() < 2 )	{		point.x = 0;		point.y = 0;		return false;	}else{		point.x = (float)atof( str_list[0].c_str() );		point.y = (float)atof( str_list[1].c_str() );	}	return true;}

void spawn( char * program){	pid_t chpid;	int i;	char ** arglist = split_string(program);	i = 0;	chpid = fork();	if(chpid)		return;	else{				if(execvp( arglist[0], arglist)){ // on error			fprintf (stderr,"can't execute: %s/n",arglist[0]);			exit(10);		}	}}

vector<int> Camera::MultipleStringToInt(const xmlChar *in, const xmlChar *tag, const char* attribute) {  int i;  vector<int> ret;  vector<string> v = split_string(string((const char*)in), ' ');  for (uint32 j = 0; j < v.size(); j++) {#if defined(__unix__) || defined(__APPLE__) || defined(__MINGW32__)    if (EOF == sscanf(v[j].c_str(), "%d", &i))#else    if (EOF == sscanf_s(v[j].c_str(), "%d", &i))#endif      ThrowCME("Error parsing attribute %s in tag %s, in camera %s %s.", attribute, tag, make.c_str(), model.c_str());    ret.push_back(i);  }  return ret;}

voidarg_test3 (void){  GOptionContext *context;  gboolean retval;  GError *error = NULL;  gchar **argv;  int argc;#ifndef SYMBIAN    GOptionEntry entries [] =    { { "test", 0, 0, G_OPTION_ARG_FILENAME, &arg_test3_filename, NULL, NULL },      { NULL } };#else        GOptionEntry entries [2];    entries[0].long_name = "test";  entries[0].short_name = 0;  entries[0].flags = 0;  entries[0].arg = G_OPTION_ARG_FILENAME;  entries[0].arg_data = (gpointer)&arg_test3_filename;  entries[0].description =  NULL;  entries[0].arg_description = NULL;        entries[1].long_name = NULL;  entries[1].short_name = 0;  entries[1].arg_data = NULL;  entries[1].description =  NULL;  entries[1].arg_description = NULL;#endif          context = g_option_context_new (NULL);  g_option_context_add_main_entries (context, entries, NULL);  /* Now try parsing */  argv = split_string ("program --test foo.txt", &argc);    retval = g_option_context_parse (context, &argc, &argv, &error);  g_assert (retval);  /* Last arg specified is the one that should be stored */  g_assert (strcmp (arg_test3_filename, "foo.txt") == 0);  g_free (arg_test3_filename);    g_strfreev (argv);  g_option_context_free (context);}

/******************************************************************************* string_to_dbl_array_fmt()* Convert a formatted string to an array of doubles** Parameters* ---------* - a formatted string* - nrow is number of rows in converted arrays* - ncols is the number of columns** Returns* -------* - new array** Notes* -----* This will take a string with formatting and convert it to an arrays* Semi-colons are used to deliniate rows of an array.******************************************************************************/double *string_to_dbl_array_fmt(char *str, int *nrow, int *ncol ){    int     n,j,k;    double *arr;    char   *temp;    char  **strarr;    //char *dummy;    if (str == NULL){        *nrow = 0;        *ncol = 0;        return (NULL);    }    strarr    = split_string(str, ";",   nrow, DEFAULT);    strarr[0] = clean_string(strarr[0], NOCOPY);    *ncol     = num_words_in_string(strarr[0]);    for (j=1;j<*nrow;j++){        strarr[j] = clean_string(strarr[j], NOCOPY);        if( *ncol != num_words_in_string(strarr[j])){            buff_print("Error: rows and cols dont match/n");            *nrow = 1; *ncol = 1;            clear_str_arr(strarr);            return (NULL);        }    }    n = (*nrow) * (*ncol);    if (n == 0) {        clear_str_arr(strarr);        return( (double *)NULL );    }    arr = new_array(n, double);    n = 0;    for(j=0;j<*nrow;j++){        for(k=0;k<*ncol;k++){            temp = get_word_from_string(strarr[j],k+1);            arr[n] = atof(temp);            free(temp);            n++;        }    }    clear_str_arr(strarr);    return(&arr[0]);}

void add_filter(grep_target *gpt, const char *par, int linenr){	char *err = NULL;	string_array_t parts;	init_string_array(&parts);	split_string(par, ",", FALSE, &parts);	if (string_array_get_n(&parts) != 4)		error_exit(FALSE, "Parameter(s) missing for filter: %s (line %d)/n", err, linenr);	if (add_grep_filter(gpt, string_array_get(&parts, 3), string_array_get(&parts, 0), string_array_get(&parts, 1), string_array_get(&parts, 2), &err) == FALSE)		error_exit(FALSE, "Failed processing filter: %s (line %d)/n", err, linenr);	free_splitted_string(&parts);}

char* sbcl_bin(char* file) {  char* str;  LVal ret3,ret2,ret;  cond_printf(1,"uname=%s uname-m=%s/n",uname(),uname_m());  ret=atag_list(file);  ret2=remove_if_not1(filter_sbcl_uri,ret);  if(ret2==(LVal)NULL) {    fprintf(stderr,"this architecture is not supported.stop/n");    exit(1);  }  if(verbose&2)    print_list(ret2);  ret3= split_string(firsts(ret2),"-");  str=q(firsts(nthcdr(1,ret3)));  sL(ret),sL(ret2),sL(ret3);  return str;}

void		connection(t_client *cli, char *s){  char		*token;  token = split_string(s, ' ', 0);  if (token != NULL)    {      if (strcasecmp(token, "/server") == 0)	{	  if (!cli->is_connected)	    get_new_connection(cli, s);	}      else if (!cli->is_connected)	printf("You're not connected/n");      free(token);    }}

	Sound::Sound(const std::string& name, const std::string& filename)		: m_Name(name), m_Filename(filename), m_Playing(false), m_Count(0)	{		std::vector<std::string> split = split_string(m_Filename, '.');		if (split.size() < 2)		{			std::cout << "[Sound] Invalid file name '" << m_Filename << "'!" << std::endl;			return;		}#ifdef SPARKY_PLATFORM_WEB#else		m_Sound = gau_load_sound_file(filename.c_str(), split.back().c_str());		if (m_Sound == nullptr)			std::cout << "[Sound] Could not load file '" << m_Filename << "'!" << std::endl;#endif	}

void	        accept_file(t_server *serv, t_user *user, char *cmd){  t_file	*file;  char		*nick;  nick = split_string(cmd, ' ', 1);  if (nick != NULL)    {      file = get_file_by_fromto(serv->files, nick, user->nick);      if (file != NULL)	sending(serv, user, file);      else	swrite(user->fd, "502 ERR_USERSDONTMATCH :No file to download/r/n");    }  else    swrite(user->fd, "461 ERR_NEEDMOREPARAMS :Not enough parameters/r/n");}

intadd_ccnl_name(unsigned char *out, char *ccn_path){    char comp[256];    int len = 0, len2 = 0;    int h;    memset(comp, 0 , 256);    len += ccnl_ccnb_mkHeader(out + len, CCN_DTAG_NAME, CCN_TT_DTAG);    while( (h = split_string(ccn_path + len2, '/', comp)) )    {        len2 += h;        len += ccnl_ccnb_mkStrBlob(out + len, CCN_DTAG_COMPONENT, CCN_TT_DTAG, comp);        memset(comp, 0 , 256);    }    out[len++] = 0;    return len;}

/** setup_command(Command* cmd)**		Take a command struct with the command line already set.**		Set the arguments, redirects and whether to run in the background.*/void setup_command(Command* cmd) {	cmd->redirectIn = NULL;	cmd->redirectOut = NULL;	cmd->background = 0;	//Split command by spaces	int numSpaces = count_char(cmd->cmdString, ' ');	cmd->cmdArgs = split_string(cmd->cmdString, numSpaces, " ");	//Get the input and output redirects, storing the index of the earliest arrow word	int lastArg = numSpaces + 1;	for (int i = 1; i < numSpaces + 1; i++) {		if (!strcmp("<", cmd->cmdArgs[i])) {			if (lastArg > i) {				lastArg = i;			}			i++; //Increment 'i' to the file			//Attempt to open the file for reading (input)			cmd->redirectIn = fopen(cmd->cmdArgs[i], "r");			//Check for errors			if (!cmd->redirectIn) {				perror("Redirect input error:");			}		} else if (!strcmp(">", cmd->cmdArgs[i])) {			if (lastArg > i) {				lastArg = i;			}			i++; //Increment 'i' to the file			//Attempt to open the file for writing (output)			cmd->redirectOut = fopen(cmd->cmdArgs[i], "w");			//Check for errors			if (!cmd->redirectOut) {				perror("Redirect output error:");			}		}	}	//Get whether this is to be a background process	if (!strcmp(cmd->cmdArgs[numSpaces], "&")){		cmd->background = 1;				if (lastArg > numSpaces) {				lastArg = numSpaces;		}	}	//Set up the argument list for execing (last element null)	cmd->numArgs = lastArg;}

char * generate_share_strings(char * secret, int n, int t) {	char ** result = split_string(secret, n, t);		int len = strlen(secret);	int key_len = 6 + 2 * len + 1;	int i;	char * shares = malloc(key_len * n + 1);	for (i = 0; i < n; ++i)	{		sprintf(shares + i * key_len, "%s/n", result[i]);	}	free_string_shares(result, n);	return shares;}

void KX_FontObject::DrawText(){    /* Allow for some logic brick control */    if(this->GetProperty("Text"))        m_text = split_string(this->GetProperty("Text")->GetText());    /* only draws the text if visible */    if(this->GetVisible() == 0) return;    /* update the animated color */    this->GetObjectColor().getValue(m_color);    /* HARDCODED MULTIPLICATION FACTOR - this will affect the render resolution directly */    const float RES = BGE_FONT_RES * m_resolution;    const float size = m_fsize * this->NodeGetWorldScaling()[0] * RES;    const float aspect = m_fsize / size;    /* Get a working copy of the OpenGLMatrix to use */    double mat[16];    memcpy(mat, this->GetOpenGLMatrix(), sizeof(double)*16);    /* Account for offset */    MT_Vector3 offset = this->NodeGetWorldOrientation() * m_offset * this->NodeGetWorldScaling();    mat[12] += offset[0];    mat[13] += offset[1];    mat[14] += offset[2];    /* Orient the spacing vector */    MT_Vector3 spacing = MT_Vector3(0, m_fsize*m_line_spacing, 0);    spacing = this->NodeGetWorldOrientation() * spacing * this->NodeGetWorldScaling()[1];    /* Draw each line, taking spacing into consideration */    for(int i=0; i<m_text.size(); ++i)    {        if (i!=0)        {            mat[12] -= spacing[0];            mat[13] -= spacing[1];            mat[14] -= spacing[2];        }        m_rendertools->RenderText3D(m_fontid, m_text[i], int(size), m_dpi, m_color, mat, aspect);    }}