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;
}
void
rest_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 url
void 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;
}
void
ignore_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);
}
void
array_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);
}
void
callback_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 links
void* 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;
}
void
arg_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");
}
int
add_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);
}
}
