void device_opencl_info(vector<DeviceInfo>& devices) { vector<OpenCLPlatformDevice> usable_devices; OpenCLInfo::get_usable_devices(&usable_devices); /* Devices are numbered consecutively across platforms. */ int num_devices = 0; foreach(OpenCLPlatformDevice& platform_device, usable_devices) { const string& platform_name = platform_device.platform_name; const cl_device_type device_type = platform_device.device_type; const string& device_name = platform_device.device_name; string hardware_id = platform_device.hardware_id; if(hardware_id == "") { hardware_id = string_printf("ID_%d", num_devices); } DeviceInfo info; info.type = DEVICE_OPENCL; info.description = string_remove_trademark(string(device_name)); info.num = num_devices; /* We don't know if it's used for display, but assume it is. */ info.display_device = true; info.advanced_shading = OpenCLInfo::kernel_use_advanced_shading(platform_name); info.pack_images = true; info.use_split_kernel = OpenCLInfo::kernel_use_split(platform_name, device_type); info.id = string("OPENCL_") + platform_name + "_" + device_name + "_" + hardware_id; devices.push_back(info); num_devices++; } }
void RedScreen::set_name(const std::string& name) { if (!name.empty()) { string_printf(_name, name.c_str(), _id); } _window.set_title(_name); }
char *uri2filename(UriUriA *uri) { char *furi_str = uri2string(uri); char *newfilename = NULL; if (!furi_str) return NULL; string_replace_with_char(furi_str, "//", *DIR_SEPAR_STR); string_replace_with_char(furi_str, "/", *DIR_SEPAR_STR); #ifdef _WIN32 string_replace_with_char(furi_str, ":", '_'); #endif if (furi_str) { string_printf(&newfilename, "%s%s", option_values.file_output_directory, furi_str); if (newfilename[strlen(newfilename)-1] == *DIR_SEPAR_STR) string_cat(&newfilename, "index.html"); } string_free(furi_str); return newfilename; }
bool load_kernels(bool experimental) { /* check if cuda init succeeded */ if(cuContext == 0) return false; if(!support_device(experimental)) return false; /* get kernel */ string cubin = compile_kernel(); if(cubin == "") return false; /* open module */ cuda_push_context(); CUresult result = cuModuleLoad(&cuModule, cubin.c_str()); if(cuda_error(result)) cuda_error(string_printf("Failed loading CUDA kernel %s.", cubin.c_str())); cuda_pop_context(); return (result == CUDA_SUCCESS); }
char *get_host(UriUriA *uri) { char *ret_str = NULL; int i, len = 0; if (uri->hostData.ip4) return *string_printf(&ret_str, "%d.%d.%d.%d", uri->hostData.ip4->data[0], uri->hostData.ip4->data[1], uri->hostData.ip4->data[2], uri->hostData.ip4->data[3]); if (uri->hostData.ip6) { ret_str = string_alloc(40); for (i = 0; i < 16; i++) { len += sprintf(ret_str + len, "%2.2x", uri->hostData.ip6->data[i]); if (i % 2 == 1 && i < 15) ret_str[len++] = ':'; } return ret_str; } if (uri->hostData.ipFuture.first) return string_nnew(uri->hostData.ipFuture.first, uri->hostData.ipFuture.afterLast - uri->hostData.ipFuture.first); if (uri->hostText.first) return string_nnew(uri->hostText.first, uri->hostText.afterLast - uri->hostText.first); return NULL; }
extern void add_aws_nodes ( KConfig *self ) { char home [ 4096 ] = ""; size_t num_writ; char path [ 4096 ]; rc_t rc; check_env ( self, home, sizeof home ); /* if home environtment is found, create AWS root node */ if ( home [ 0 ] != 0 ) { rc = string_printf ( path, sizeof path, &num_writ, "%s/.aws", home ); if ( rc == 0 && num_writ != 0 ) { KConfigNode *aws_node; /* create aws node */ rc = KConfigOpenNodeUpdate ( self, &aws_node, "AWS", NULL ); if ( rc == 0 ) rc = aws_find_nodes ( aws_node, path ); rc = KConfigNodeRelease ( aws_node ); } } }
static bool CC write_to_file_cb( stat_row * row, void * f_data ) { write_ctx * wctx = ( write_ctx * ) f_data; char buffer[ 256 ]; size_t num_writ; rc_t rc = string_printf ( buffer, sizeof buffer, &num_writ, "%s\t%u\t%u\t%s\t%u\t%u\t%u\t%u\t%u\t%u\n", row->spotgroup, row->base_pos, row->n_read, row->dimer, row->gc_content, row->hp_run, row->max_qual_value, row->quality, row->count, row->mismatch_count ); if ( rc == 0 ) { size_t f_writ; rc = KFileWrite ( wctx->out, wctx->pos, buffer, num_writ, &f_writ ); if ( rc == 0 ) { uint32_t percent = progressbar_percent( wctx->entries, ++wctx->lines, wctx->fract_digits ); update_progressbar( wctx->progress, percent ); wctx->pos += f_writ; } } return ( rc == 0 ); }
void BlenderSession::update_status_progress() { string timestatus, status, substatus; float progress; double total_time; char time_str[128]; float mem_used = (float)session->stats.mem_used / 1024.0f / 1024.0f; float mem_peak = (float)session->stats.mem_peak / 1024.0f / 1024.0f; get_status(status, substatus); get_progress(progress, total_time); timestatus = string_printf("Mem: %.2fM, Peak: %.2fM | ", mem_used, mem_peak); timestatus += b_scene.name(); if(b_rlay_name != "") timestatus += ", " + b_rlay_name; timestatus += " | "; BLI_timestr(total_time, time_str, sizeof(time_str)); timestatus += "Elapsed: " + string(time_str) + " | "; if(substatus.size() > 0) status += " | " + substatus; if(status != last_status) { b_engine.update_stats("", (timestatus + status).c_str()); b_engine.update_memory_stats(mem_used, mem_peak); last_status = status; } if(progress != last_progress) { b_engine.update_progress(progress); last_progress = progress; } }
GuessedTimeZone() { time_t the_time = time(0); struct tm tmbuf; struct tm *ta = localtime_r(&the_time, &tmbuf); const char *tzid = nullptr; if (ta) { tzid = timelib_timezone_id_from_abbr(ta->tm_zone, ta->tm_gmtoff, ta->tm_isdst); } if (!tzid) { tzid = "UTC"; } m_tzid = tzid; #define DATE_TZ_ERRMSG \ "It is not safe to rely on the system's timezone settings. Please use " \ "the date.timezone setting, the TZ environment variable or the " \ "date_default_timezone_set() function. In case you used any of those " \ "methods and you are still getting this warning, you most likely " \ "misspelled the timezone identifier. " string_printf(m_warning, DATE_TZ_ERRMSG "We selected '%s' for '%s/%.1f/%s' instead", tzid, ta ? ta->tm_zone : "Unknown", ta ? (float) (ta->tm_gmtoff / 3600) : 0, ta ? (ta->tm_isdst ? "DST" : "no DST") : "Unknown"); }
static void print_matchcount( char * buffer, size_t buf_len, size_t *buf_idx, int *match_count ) { size_t num_writ; string_printf( &buffer[ *buf_idx ], buf_len - *buf_idx, &num_writ, "%d", *match_count ); *match_count = 0; *buf_idx += num_writ; }
static ShaderOutput *node_find_output_by_name(ShaderNode *node, BL::Node& b_node, BL::NodeSocket& b_socket) { string name = b_socket.name(); if(node_use_modified_socket_name(node)) { BL::Node::outputs_iterator b_output; bool found = false; int counter = 0, total = 0; for(b_node.outputs.begin(b_output); b_output != b_node.outputs.end(); ++b_output) { if(b_output->name() == name) { if(!found) counter++; total++; } if(b_output->ptr.data == b_socket.ptr.data) found = true; } /* rename if needed */ if(name == "Shader") name = "Closure"; if(total > 1) name = string_printf("%s%d", name.c_str(), counter); } return node->output(name.c_str()); }
Variant HHVM_FUNCTION(vprintf, const Variant& vformat, const Variant& args) { String format = vformat.toString(); String output = string_printf(format.data(), format.size(), args.toArray()); if (output.isNull()) return false; g_context->write(output.data(), output.size()); return output.size(); }
//============================================================================= // y-func : Functions for Neutrino //============================================================================= //------------------------------------------------------------------------- // y-func : mount_get_list //------------------------------------------------------------------------- std::string CNeutrinoYParser::func_mount_get_list(CyhookHandler *, std::string) { CConfigFile *Config = new CConfigFile(','); std::string ysel, ytype, yip, ylocal_dir, ydir, ynr, yresult; int yitype; Config->loadConfig(NEUTRINO_CONFIGFILE); for(unsigned int i=0; i <= 7; i++) { ynr=itoa(i); ysel = ((i==0) ? "checked=\"checked\"" : ""); yitype = Config->getInt32("network_nfs_type_"+ynr,0); ytype = ( (yitype==0) ? "NFS" :((yitype==1) ? "CIFS" : "FTPFS") ); yip = Config->getString("network_nfs_ip_"+ynr,""); ydir = Config->getString("network_nfs_dir_"+ynr,""); ylocal_dir = Config->getString("network_nfs_local_dir_"+ynr,""); if(!ydir.empty()) ydir="("+ydir+")"; yresult += string_printf("<input type='radio' name='R1' value='%d' %s />%d %s - %s %s %s<br/>", i,ysel.c_str(),i,ytype.c_str(),yip.c_str(),ylocal_dir.c_str(), ydir.c_str()); } delete Config; return yresult; }
static rc_t CC KStsDefaultFormatter( void* self, KWrtHandler* writer, size_t argc, const wrt_nvp_t args[], size_t envc, const wrt_nvp_t envs[] ) { rc_t rc = 0; size_t num_writ, nsize; uint32_t mlen; char buffer[8192], *nbuffer; const char* msg, *mend; /* if writer is null than silence */ if( writer == NULL || writer->writer == NULL ) { return rc; } msg = wrt_nvp_find_value(envc, envs, "message"); if( msg != NULL ) { mend = msg + strlen(msg); /* strip trailing newlines */ while( mend != msg && (*mend == '\n' || *mend == '\r') ) { --mend; } mlen = ( uint32_t ) ( mend - msg ); } else { mlen = 0; } nbuffer = buffer; nsize = sizeof(buffer); do { rc = string_printf(nbuffer, nsize, & num_writ, "%s %s.%s: %.*s\n", wrt_nvp_find_value(envc, envs, "timestamp"), wrt_nvp_find_value(envc, envs, "app"), wrt_nvp_find_value(envc, envs, "version"), ( uint32_t ) mlen, msg); if( num_writ > nsize ) { assert ( nbuffer == buffer ); nbuffer = malloc(nsize = num_writ + 2); if( nbuffer == NULL ) { rc = RC(rcRuntime, rcLog, rcLogging, rcMemory, rcExhausted); break; } continue; } /* replace newlines with spaces, excluding last one */ for(nsize = 0; nsize < num_writ - 1; nsize++) { if( nbuffer[nsize] == '\n' || nbuffer[nsize] == '\r' ) { nbuffer[nsize] = ' '; } } break; } while(true); if( rc == 0 ) { rc = LogFlush(writer, nbuffer, num_writ); } if( nbuffer != buffer ) { free(nbuffer); } return rc; }
/* * parse_SIZE * * %SIZE(structure-attribute) * * Returns the number of addressable units that would * be allocated for a data segment with the specified * structure attribute. */ static int parse_SIZE (parse_ctx_t pctx, void *vctx, quotelevel_t ql, lextype_t lt) { expr_ctx_t ctx = vctx; lexeme_t *lex; strudef_t *stru; unsigned int units; if (!parser_expect(pctx, QL_NORMAL, LEXTYPE_DELIM_LPAR, 0, 1)) { expr_signal(ctx, STC__DELIMEXP, "("); return 0; } units = 0; if (!parser_expect(pctx, QL_NORMAL, LEXTYPE_NAME_STRUCTURE, &lex, 1)) { expr_signal(ctx, STC__STRUNMEXP); return 1; } if (!structure_allocate(ctx, lexeme_ctx_get(lex), &stru, &units, 0, 0)) { expr_signal(ctx, STC__SYNTAXERR); } if (!parser_expect(pctx, QL_NORMAL, LEXTYPE_DELIM_RPAR, 0, 1)) { expr_signal(ctx, STC__DELIMEXP, ")"); } parser_insert(pctx, parser_lexeme_create(pctx, LEXTYPE_NUMERIC, string_printf(expr_strctx(ctx), 0, "%u", units))); return 1; } /* expr_parse_SIZE */
static void display_info(Progress& progress) { static double latency = 0.0; static double last = 0; double elapsed = time_dt(); string str, interactive; latency = (elapsed - last); last = elapsed; int sample, tile; double total_time, sample_time; string status, substatus; sample = progress.get_sample(); progress.get_tile(tile, total_time, sample_time); progress.get_status(status, substatus); if(substatus != "") status += ": " + substatus; interactive = options.interactive? "On":"Off"; str = string_printf("%s Time: %.2f Latency: %.4f Sample: %d Average: %.4f Interactive: %s", status.c_str(), total_time, latency, sample, sample_time, interactive.c_str()); view_display_info(str.c_str()); if(options.show_help) view_display_help(); }
static rc_t enter_vdbcopy_node( KMetadata *dst_meta, const bool show_meta ) { rc_t rc; KMDataNode *hist_node; if ( show_meta ) KOutMsg( "--- entering Copy entry...\n" ); rc = KMetadataOpenNodeUpdate ( dst_meta, &hist_node, "HISTORY" ); DISP_RC( rc, "enter_vdbcopy_node:KMetadataOpenNodeUpdate('HISTORY') failed" ); if ( rc == 0 ) { char event_name[ 32 ]; uint32_t index = get_child_count( hist_node ) + 1; rc = string_printf ( event_name, sizeof( event_name ), NULL, "EVENT_%u", index ); DISP_RC( rc, "enter_vdbcopy_node:string_printf(EVENT_NR) failed" ); if ( rc == 0 ) { KMDataNode *event_node; rc = KMDataNodeOpenNodeUpdate ( hist_node, &event_node, event_name ); DISP_RC( rc, "enter_vdbcopy_node:KMDataNodeOpenNodeUpdate('EVENT_NR') failed" ); if ( rc == 0 ) { rc = enter_date_name_vers( event_node ); KMDataNodeRelease ( event_node ); } } KMDataNodeRelease ( hist_node ); } return rc; }
static void display_info(Progress& progress) { static double latency = 0.0; static double last = 0; double elapsed = time_dt(); string str; latency = (elapsed - last); last = elapsed; int sample, tile; double total_time, sample_time; string status, substatus; sample = progress.get_sample(); progress.get_tile(tile, total_time, sample_time); progress.get_status(status, substatus); if(substatus != "") status += ": " + substatus; str = string_printf("latency: %.4f sample: %d total: %.4f average: %.4f %s", latency, sample, total_time, sample_time, status.c_str()); view_display_info(str.c_str()); }
static void _doc_process_var(doc_ptr doc, cptr name) { if (strcmp(name, "version") == 0) { string_ptr s = string_alloc_format("%d.%d.%d", VER_MAJOR, VER_MINOR, VER_PATCH); doc_insert(doc, string_buffer(s)); string_free(s); } else if (strlen(name) > 3 && strncmp(name, "FF_", 3) == 0) { char buf[100]; int f_idx; sprintf(buf, "%s", name + 3); f_idx = f_tag_to_index(buf); if (0 <= f_idx && f_idx < max_f_idx) { string_ptr s = string_alloc(); feature_type *feat = &f_info[f_idx]; string_printf(s, "<color:%c>%c</color>", attr_to_attr_char(feat->d_attr[F_LIT_STANDARD]), feat->d_char[F_LIT_STANDARD]); doc_insert(doc, string_buffer(s)); string_free(s); } } }
static void get_string_cell( char * buffer, size_t buffer_size, const VTable * tab, int64_t row, const char * column ) { if ( has_col( tab, column ) ) { const VCursor * cur; rc_t rc = VTableCreateCursorRead( tab, &cur ); if ( rc == 0 ) { uint32_t idx; rc = VCursorAddColumn( cur, &idx, column ); if ( rc == 0 ) { rc = VCursorOpen( cur ); if ( rc == 0 ) { const char * src; uint32_t row_len; rc = VCursorCellDataDirect( cur, row, idx, NULL, (const void**)&src, NULL, &row_len ); if ( rc == 0 ) { size_t num_writ; string_printf( buffer, buffer_size, &num_writ, "%.*s", row_len, src ); } } } VCursorRelease( cur ); } } }
//----------------------------------------------------------------------------- // parse parameter string // parameter = attribute "=" value // attribute = token // value = token | quoted-string // // If parameter attribute is multiple times given, the values are stored like this: // <attribute>=<value1>,<value2>,..,<value n> //----------------------------------------------------------------------------- bool CWebserverRequest::ParseParams(std::string param_string) { bool ende = false; std::string param, name="", value, number; while(!ende) { if(!ySplitStringExact(param_string,"&",param,param_string)) ende = true; if(ySplitStringExact(param,"=",name,value)) { name = decodeString(name); value = trim(decodeString(value)); if(ParameterList[name].empty()) ParameterList[name] = value; else { ParameterList[name] += ","; ParameterList[name] += value; } } else name = trim(decodeString(name)); number = string_printf("%d", ParameterList.size()+1); log_level_printf(7,"ParseParams: name: %s value: %s\n",name.c_str(), value.c_str()); ParameterList[number] = name; } return true; }
//------------------------------------------------------------------------- // y-func : get_bouquets_as_dropdown [<bouquet>] <doshowhidden> //------------------------------------------------------------------------- std::string CNeutrinoYParser::func_get_bouquets_as_dropdown(CyhookHandler *, std::string para) { std::string yresult, sel, nr_str, do_show_hidden; int nr=1; ySplitString(para," ",nr_str, do_show_hidden); if(!nr_str.empty()) nr = atoi(nr_str.c_str()); int mode = NeutrinoAPI->Zapit->getMode(); for (int i = 0; i < (int) g_bouquetManager->Bouquets.size(); i++) { //ZapitChannelList &channels = mode == CZapitClient::MODE_RADIO ? g_bouquetManager->Bouquets[i]->radioChannels : g_bouquetManager->Bouquets[i]->tvChannels; ZapitChannelList channels; if (mode == CZapitClient::MODE_RADIO) g_bouquetManager->Bouquets[i]->getRadioChannels(channels); else g_bouquetManager->Bouquets[i]->getTvChannels(channels); sel=(nr==(i+1)) ? "selected=\"selected\"" : ""; if(!channels.empty() && (!g_bouquetManager->Bouquets[i]->bHidden || do_show_hidden == "true")) yresult += string_printf("<option value=%u %s>%s</option>\n", i + 1, sel.c_str(), std::string(g_bouquetManager->Bouquets[i]->bFav ? g_Locale->getText(LOCALE_FAVORITES_BOUQUETNAME) :g_bouquetManager->Bouquets[i]->Name.c_str()).c_str()); //yresult += string_printf("<option value=%u %s>%s</option>\n", i + 1, sel.c_str(), (encodeString(std::string(g_bouquetManager->Bouquets[i]->Name.c_str()))).c_str()); } return yresult; }
static void test_encrypted(string* x,string* y,string *pri) { string mess,messb,encrypted_mess,xx,yy,tag; INIT(mess); INIT(messb); INIT(encrypted_mess); INIT(xx); INIT(yy); INIT(tag); mess.len = 10; mess.buf = (u8*)malloc(10); mess.buf[0] = 'h'; mess.buf[1] = 'e'; mess.buf[2] = 'l'; mess.buf[3] = 'l'; mess.buf[4] = 'o'; mess.buf[5] = 'w'; mess.buf[6] = 'o'; mess.buf[7] = 'r'; mess.buf[8] = 'd'; mess.buf[9] = '\0'; int res; printf("%s %d\n",__FILE__,__LINE__); res = crypto_ECIES_encrypto_message(&mess,x,y,&xx,&yy,&encrypted_mess,&tag); string_printf("xx",&xx); string_printf("yy",&yy); string_printf("encryptd_mess",&encrypted_mess); string_printf("tag",&tag); FILE *fd; fd = fopen("encrypted_mess","w"); fwrite(encrypted_mess.buf,1,encrypted_mess.len,fd); fd = fopen("xx","w"); fwrite(xx.buf,1,xx.len,fd); fd = fopen("yy","w"); fwrite(yy.buf,1,yy.len,fd); fd = fopen("tag","w"); fwrite(tag.buf,1,tag.len,fd); if(res != 0) { error(); return; } res = crypto_ECIES_decrypto_message(&encrypted_mess,&xx,&yy,&tag,pri,&messb); printf("res :%d\n",res); }
static void CC num_gen_as_string_cb( void *item, void *data ) { char temp[40]; p_num_gen_node node = ( p_num_gen_node )item; long unsigned int start = node->start; long unsigned int end = ( start + node->count - 1 ); switch( node->count ) { case 0 : temp[0]=0; break; case 1 : string_printf ( temp, sizeof temp, NULL, "%lu,", start ); break; default: string_printf ( temp, sizeof temp, NULL, "%lu-%lu,", start, end ); break; } string_ctx_add( ( p_string_ctx )data, temp ); }
static SCM ppscm_make_pp_type_error_exception (const char *message, SCM object) { std::string msg = string_printf ("%s: ~S", message); return gdbscm_make_error (pp_type_error_symbol, NULL /* func */, msg.c_str (), scm_list_1 (object), scm_list_1 (object)); }
static std::string i386_windows_core_pid_to_str (struct gdbarch *gdbarch, ptid_t ptid) { if (ptid.lwp () != 0) return string_printf ("Thread 0x%lx", ptid.lwp ()); return normal_pid_to_str (ptid); }
lfl_string as_loadvars::create_request(const lfl_string& method, const lfl_string& uri, bool send_data) { lfl_string information; //create information in the form of name=value (urlencoded) string_hash<lfl_string>::iterator it = m_values.begin(); for(bool first = true; it != m_values.end(); ++it) { lfl_string name, value; name = it->first; value = it->second; url_encode( &name ); url_encode( &value ); information += string_printf("%s%s=%s", first? "":"&",name.c_str(), value.c_str() ); first = false; } if( method == "POST") { lfl_string request = string_printf( "POST %s HTTP/1.1\r\n", uri.c_str() ); m_headers.set("Content-Length", string_printf( "%i", information.size())); request += create_header(); request += "\r\n"; request += information; return request; } else if(method == "GET") { lfl_string request = string_printf( "GET %s?%s HTTP/1.1\r\n", uri.c_str(), information.c_str() ); request += create_header(); request += "\r\n"; return request; } else { assert(0 && "unsupported"); } return ""; }
static string line_directive(const string& path, int line) { string escaped_path = path; string_replace(escaped_path, "\"", "\\\""); string_replace(escaped_path, "\'", "\\\'"); string_replace(escaped_path, "\?", "\\\?"); string_replace(escaped_path, "\\", "\\\\"); return string_printf("#line %d \"%s\"", line, escaped_path.c_str()); }
string string_human_readable_size(size_t size) { static const char suffixes[] = "BKMGTPEZY"; const char* suffix = suffixes; size_t r = 0; while(size >= 1024) { r = size % 1024; size /= 1024; suffix++; } if(*suffix != 'B') return string_printf("%.2f%c", double(size*1024+r)/1024.0, *suffix); else return string_printf("%zu", size); }
string NamedSizeStats::full_report(int indent_level) { const string indent(indent_level * kIndentNumSpaces, ' '); const string double_indent = indent + indent; string result = ""; result += string_printf("%sTotal memory: %s (%s)\n", indent.c_str(), string_human_readable_size(total_size).c_str(), string_human_readable_number(total_size).c_str()); sort(entries.begin(), entries.end(), namedSizeEntryComparator); foreach(const NamedSizeEntry& entry, entries) { result += string_printf( "%s%-32s %s (%s)\n", double_indent.c_str(), entry.name.c_str(), string_human_readable_size(entry.size).c_str(), string_human_readable_number(entry.size).c_str()); }