END_TEST START_TEST (test_split_str) { int ret; s_array * words; s_array * exp; words = init_s_array(1); exp = init_s_array(1); char * string = "one.1\ttwo.2\tthree.3\0"; append_s_array(exp, "one.1"); append_s_array(exp, "two.2"); append_s_array(exp, "three.3"); ret = split_str(string, words, 3); ck_assert_int_eq(ret, 0); ck_assert_int_eq(words->length, 3); ck_assert_msg((s_arrays_equal(words, exp) != 0), "unexpected result of `split_str`"); ret = split_str(string, words, 3); ck_assert_int_eq(ret, 0); ret = split_str(string, words, 4); ck_assert_int_eq(ret, 3); ck_assert_msg((s_arrays_equal(words, exp) != 0), "unexpected result of `split_str`"); free_s_array(words); free_s_array(exp); }
void* display_func(void) { int i, j, error; char message_buffer[LENGHT_MESSAGE], message_buffer_2[LENGHT_MESSAGE]; char filename[LENGHT_MESSAGE]; char confirm_file[LENGHT_MESSAGE]; FILE *fp; while (state == 0) { if (recieve_data(LENGHT_MESSAGE, message_buffer) == 0) draw_new(global_display, "system>> recieve error"); //draw_new(global_display, message_buffer); if (message_buffer[0] == '0') { split_str(1, strlen(message_buffer), message_buffer, message_buffer_2); draw_new(global_display, message_buffer_2); } else if (message_buffer[0] == '1') { //do nothing } else if (message_buffer[0] == '2') { split_str(27, strlen(message_buffer) - 2, message_buffer, message_buffer_2); strcpy(username, message_buffer_2); split_str(1, strlen(message_buffer), message_buffer, message_buffer_2); draw_new(global_display, message_buffer_2); } else if (message_buffer[0] == '3') { split_str(1, strlen(message_buffer), message_buffer, message_buffer_2); draw_new(global_display, message_buffer_2); split_str(31, strlen(message_buffer) - 1, message_buffer, filename); sprintf(message_buffer_2, "downloaded/%s", filename); fp = fopen(message_buffer_2, "w+"); error = 1; do { recieve_file(message_buffer); fprintf(fp, "%c", message_buffer[1]); }while(message_buffer[0] != '5'); fclose(fp); draw_new(global_display, "system>> Downloaded file success."); } //Reset value in message_buffer for check while loop's condition strcpy(message_buffer, ""); strcpy(message_buffer_2, ""); } return 0; }
void load_program(std::string path){ get_pause(); while(node_view.size() > 0){ delete_node(node_view.begin()->second); } clear_local(); std::ifstream cin(path, std::ios::in); char buffer[100]; std::string str; int state = 0; std::getline(cin,str); int n_nodes = lexical_cast<int,std::string>(str); std::cout << "N Nodes:" << n_nodes << "\n"; std::vector<Node *> nodes; for(int i = 0; i < n_nodes;i++){ std::getline(cin,str); std::vector<std::string> args = split_str(str); float y = lexical_cast<float,std::string>(args[args.size()-1]); args.pop_back(); float x = lexical_cast<float,std::string>(args[args.size()-1]); args.pop_back(); std::string full_name; for(int i = 0; i < args.size();i++){ full_name += args[i]; if(i != args.size()-1){ full_name += " "; } } std::cout << full_name << "\n"; nodes.push_back(create_and_insert_node(full_name,Vec2f(x,y))); } std::getline(cin,str); int n_connections = lexical_cast<int,std::string>(str); for(int i = 0; i < n_connections;i++){ std::getline(cin,str); std::vector<std::string> args = split_str(str); int out_node = lexical_cast<int,std::string>(args[0]); int out_port = lexical_cast<int,std::string>(args[1]); int in_node = lexical_cast<int,std::string>(args[2]); int in_port = lexical_cast<int,std::string>(args[3]); backend.connect_nodes(nodes[out_node],nodes[in_node],out_port,in_port); } release_pause(); cin.close(); std::cout << "Done loading.. \n"; }
void netif_add_from_spec(struct netif **ifs, const char *spec) { _free_ char *tmp = NULL; _free_ char **opts = NULL; if (!spec) return; tmp = strdup(spec); fail_if(!tmp, "OOM"); size_t c = split_str(tmp, &opts, ":"); fail_if(!c, "Invalid netif spec '%s': not enough args", spec); if (if_nametoindex(opts[0])) { fail_if(c < 2, "Invalid netif spec '%s': not enough args",spec); netif_add(ifs, MOVE, opts[0], opts[1]); } else if (!strncmp(opts[0], "macvlan", 8)) { fail_if(c < 3, "Invalid netif spec '%s': not enough args",spec); netif_add(ifs, MACVLAN, opts[1], opts[2]); } else if (!strncmp(opts[0], "ipvlan", 8)) { fail_if(c < 3, "Invalid netif spec '%s': not enough args",spec); netif_add(ifs, IPVLAN, opts[1], opts[2]); } else if (!strncmp(opts[0], "veth", 5)) { fail_if(c < 3, "Invalid netif spec '%s': not enough args",spec); netif_add(ifs, VETH, opts[1], opts[2]); } else { fail_printf("Invalid netif spec '%s'", spec); } }
size_t bodycallback(char *ptr, size_t size, size_t nmemb, void *userdata) { char* pstr = (char *)ptr; replace_char(pstr, '\r', ':'); char **rows = split_str(pstr, '\n'); if (rows == NULL || rows[0] == NULL) { free(rows); return nmemb*size; } int i = 0; for (i = 0; rows[i]; i++) { #ifdef DEBUG fprintf(stderr, "Read body line: %s\n", rows[i]); #endif BODY *curbody = (BODY *) malloc(sizeof(BODY) + strlen(rows[i]) + 1); curbody->row = (char *) ((char*)curbody + sizeof(BODY)); strcpy(curbody->row, rows[i]); curbody->next = body; body = curbody; } free(rows); return nmemb*size; }
static PyObject * _diypy3__binary_tree(PyObject *self, PyObject *args) { int order; char *bt_str; char *str_slice_rec[BT_MAXSIZE]; BTNODE *T; if (!PyArg_ParseTuple(args, "is", &order, &bt_str)) return NULL; split_str(bt_str, str_slice_rec); temp_rec = str_slice_rec; pre_order_create(&T); printf("binary tree initialized\n"); switch (order) { case 0: pre_order_visualize(T); indent = 0; break; default: PyErr_SetString(PyExc_ValueError, "Unrecognised flag given"); return NULL; } Py_RETURN_NONE; }
static PyObject * _diypy3__triplet_sparse_matrix(PyObject *self, PyObject *args) { int mu; int nu; int tu; char *trismx_str; char *str_slice_rec[TRISMX_MAXSIZE]; TRISMX M; TRISMX N; if (!PyArg_ParseTuple(args, "iiis", &mu, &nu, &tu, &trismx_str)) return NULL; split_str(trismx_str, str_slice_rec); temp_rec = str_slice_rec; create_sparse_trismx(&M, mu, nu, tu); printf("triplet sparse matrix initialized\n"); visualize_trismx(&M); printf("fast transpose this matrix:\n"); fast_transpose_trismx(&M, &N); visualize_trismx(&N); Py_RETURN_NONE; }
static PyObject * _diypy3__link_queue(PyObject *self, PyObject *args) { int i; int rec_size; char *queue_str; char *str_slice_rec[LNKQ_MAXSIZE]; char *deq; LNKQ Q; if (!PyArg_ParseTuple(args, "s", &queue_str)) return NULL; rec_size = split_str(queue_str, str_slice_rec); temp_rec = str_slice_rec; if (!init_queue(&Q)) return NULL; printf("linked list queue initialized\n"); printf("\n"); for (i = 0; i < rec_size; i++) { printf("enqueue: %s\n", temp_rec[i]); enqueue(&Q, temp_rec[i]); } while (Q.front != Q.rear) { printf("\nstatus: "); show_queue(Q); dequeue(&Q, &deq); printf("dequeue: %s\n", deq); } printf("\nwarning: empty queue\n"); Py_RETURN_NONE; }
static void perform_cmd(t_client *client, char *cmd) { char **tab; int i; int n; tab = split_str(cmd, ' '); n = 0; while (tab && tab[n]) n++; if (n == 0) { free_tab(tab); return ; } i = 0; while (i < COMMANDS) { if (!my_strcmp_case(client->commands[i].str, tab[0])) { client->commands[i].func(client, n, tab); free_tab(tab); return ; } i++; } }
/** * One time initializations done when we want to display a new training mission. * * This does all the processing and setup required to actually display it, including * starting the voice file playing */ void message_training_setup(int m, int length, char *special_message) { if ((m < 0) || !Messages[m].message[0]) { // remove current message from the screen Training_num_lines = 0; return; } // translate tokens in message to the real things if (special_message == NULL) message_translate_tokens(Training_buf, Messages[m].message); else message_translate_tokens(Training_buf, special_message); HUD_add_to_scrollback(Training_buf, HUD_SOURCE_TRAINING); // moved from message_training_display() because we got rid of an extra buffer and we have to determine // the number of lines earlier to avoid inadvertant modification of Training_buf. - taylor training_process_message(Training_buf); Training_num_lines = split_str(Training_buf, TRAINING_LINE_WIDTH, Training_line_lengths, Training_lines, MAX_TRAINING_MESSAGE_LINES); Assert( Training_num_lines >= 0 ); if (message_play_training_voice(Messages[m].wave_info.index) < 0) { if (length > 0) Training_message_timestamp = timestamp(length * 1000); else Training_message_timestamp = timestamp(TRAINING_TIMING_BASE + strlen(Messages[m].message) * TRAINING_TIMING); // no voice file playing } else Training_message_timestamp = 0; }
mat utils::load_matrix(string file_path, int xdim, int ydim){ mat tmp_mat = randu<mat>(xdim+1, ydim); FILE * fin = fopen(file_path.c_str(), "r"); if (!fin) { printf("Can't open file %s to read!", file_path.c_str()); exit(1); } int xidx=0; char buff[BUFF_SIZE_LONG]; while (fgets(buff, BUFF_SIZE_LONG-1, fin) != NULL){ vector<char *> line_segments = split_str(buff, ' '); if (line_segments.size() != (unsigned int)ydim){ printf("Dimension of latent factor can't match with model's.\n"); exit(1); } for (unsigned int i=0; i<line_segments.size(); i++) tmp_mat(xidx+1, i) = atof(line_segments[i]); xidx++; memset(buff, 0, BUFF_SIZE_LONG); } if (xidx != xdim){ cout << "read number of user:"******"original number of user:"******"Number of rows can't match.\n"); exit(1); } return tmp_mat; }
static bool seek_to_regname(FILE *f, const char *regname) { char str[1024]; while (true) { fpos_t pos; int r; r = fgetpos(f, &pos); if (r) myerr2("fgetpos failed"); if (!fgets(str, sizeof(str), f)) return false; char *parts[3] = { 0 }; r = split_str(str, ",", parts, 3); if (r != 3) myerr("Failed to parse register description: '%s'", str); if (strcmp(regname, parts[0]) == 0) { r = fsetpos(f, &pos); if (r) myerr2("fsetpos failed"); return true; } if (!seek_to_next_reg(f)) return false; } return false; }
void *_job_proc(void* data) { queue_item *job = (queue_item*) data; char **job_desc = c_calloc_2(10, 30); int count = split_str(job->job_description, " ", job_desc); if (count == 0) { fprintf(stdout, "This job has some problem!\n"); } else if (!strcmp(job_desc[0], "srun")) { drun_proc(count, job_desc); } else if (!strcmp(job_desc[0], "dcancel")) { //dcancel_proc(job_origin_desc_left); } else if (!strcmp(job_desc[0], "dinfo")) { //dinfo_proc(job_origin_desc_left); }; pthread_exit(NULL); return NULL; }
void print_result(float *tab, int max) { char **tmp; int degree; char *reduced_form; reduced_form = get_reduced_form(tab, max); ft_putstr("\033[4mReduced form:\033[0;0m"); ft_putendl(ft_strjoin(" ", ft_strjoin(reduced_form, " = 0"))); tmp = split_str(reduced_form); degree = get_degree(tmp); ft_putendl(ft_strjoin("Polynomial degree: ", ft_itoa(degree))); if (!ft_strcmp(reduced_form, "0")) ft_putendl("\033[32mAll real numbers are solution."); else if (!check_all_tab(tab, max)) { ft_putendl("\033[31mThere is no solution."); return ; } else if (degree > 2) print_error(3); else if (degree == 0 || degree == 1) print_result3(tab, degree); else if (degree >= 2) print_result4(tab); do_mlx(tab); }
int GetOption (char *str, char *option, int option_len, char *value, int val_len) { char *argv[2]; char key [MENU_TITLE_BUF_LEN +1] = {0}; char val [VALUE_LEN +1] = {0}; char *p; int argc; argv[0] = key; argv[1] = val; //split string to two part,key and value ,splited by SPACE or TAB argc = split_str (str, argv); //if split to two part, return 2. if( argc < 2 ) return -1; //remove SPACE and TAB from key and val header and tail. p = trim (key); //copy to buffer. strncpy (option, p, option_len - 1); p = trim (val); //remove comment data from string. remove_comment(p); strncpy (value, p, val_len -1); return 0; }
/********************************************************************* * 文字列 *buf から、パラメータを読み取り、( adrs , memcnt ) を決める ********************************************************************* */ int get_arg(char *buf) { arena = AREA_RAM; if(*buf == 'p') { buf++; arena = AREA_PGMEM; }else if(*buf == 'r') { buf++; arena = AREA_EEPROM; } memcnt = 64; adrs2 = (-1); buf = sp_skip(buf); if(*buf==0) return 0; arg_cnt = split_str(buf,',',arg_ptr); scan_args(arg_cnt); if(arg_cnt>=1) { adrs = arg_hex[0]; } if(arg_cnt>=2) { adrs2 = arg_hex[1]; if(adrs2 != (-1) ) { memcnt = adrs2 - adrs + 1; } if( memcnt < 0) { memcnt = adrs2; } } return arg_cnt; }
struct reg_desc *find_reg_by_address(const char *regfile, uint64_t addr) { char str[1024]; FILE *f = fopen(regfile, "r"); ERR_ON_ERRNO(f == NULL , "Failed to open regfile %s", regfile); if (!seek_to_regaddr(f, addr)) return NULL; if (!fgets(str, sizeof(str), f)) ERR("Failed to parse register"); char *parts[3] = { 0 }; int r = split_str(str, ",", parts, 3); ERR_ON(r != 3, "Failed to parse register description: '%s'", str); struct reg_desc *reg; reg = malloc(sizeof(struct reg_desc)); memset(reg, 0, sizeof(*reg)); reg->name = strdup(parts[0]); reg->offset = strtoull(parts[1], NULL, 0); reg->width = strtoul(parts[2], NULL, 0); parse_reg_fields(f, reg); fclose(f); return reg; }
//------------------------------------------------------------------------ string qt_dbtreemodel_impl::_value( const row *r, const string& format, const string& columns ) const { if( !r ) return string(); string result( format ); vector<string> dest; split_str( columns, ",", dest ); for( size_t i = 0; i < dest.size(); ++i ) { size_t n = result.find( "%s" ); if( n != string::npos ) { try { result.replace( n, 2, r->at( str_to_size_t( dest[i] ) ) ); } catch( std::out_of_range& ) { _lprintf( LOG_ERR, "Column %lu is wrong\n", dest[i].c_str() ); continue; } } } return result; }
smartphone_gps_t parse_raw_data(char *buffer, size_t buf_size) { fprintf(stderr, "Parsing smartphone gps data: %s\n", buffer); smartphone_gps_t gps; gps.time = time(NULL); /* Latitude */ char *token = split_str(&buffer, ","); gps.lat = atof(token); /* Longitude */ token = split_str(&buffer, ","); gps.lng = atof(token); return gps; }
void techroom_init_desc(char *src, int w) { Text_size = Text_offset = 0; if (!src) { return; } Text_size = split_str(src, w, Text_line_size, Text_lines, MAX_TEXT_LINES); Assert(Text_size >= 0 && Text_size < MAX_TEXT_LINES); }
int main(int argc, char **argv) { rados_t cluster; char cluster_name[] = "ceph"; char user_name[] = "client.admin"; APPNAME = &argv[0][2]; uint64_t flags; int err; /* Initialize the cluster handle */ err = rados_create2(&cluster, cluster_name, user_name, flags); // err = rados_create(&cluster, NULL); error_print(err, "Couldn't create the cluster handle!", "Created a cluster handle."); /* Read a Ceph configuration file to configure the cluster handle. */ err = rados_conf_read_file(cluster, "/etc/ceph/ceph.conf"); error_print(err, "Cannot read config file!", "Read the config file."); /* Connect to the cluster */ err = rados_connect(cluster); error_print(err, "Cannot connect to cluster!", "Connected to the cluster."); /* List pools. */ char buf[1024]; err = rados_pool_list(cluster, buf, 1024); split_str(buf, 1024); error_print(err, "Cannot list pools!", buf); /* List pool stats */ char *poolname = strtok(buf, ","); while(poolname != NULL) { rados_ioctx_t io; struct rados_pool_stat_t stats; err = rados_ioctx_create(cluster, poolname, &io); error_print(err, "Cannot create IO context!", "IO context created."); err = rados_ioctx_pool_stat(io, &stats); error_print(err, "Cannot list pool stats!", "Pool stats listed."); printf("[%s][%s]: Number of read: %"PRIu64"\n", APPNAME, poolname, stats.num_rd); printf("[%s][%s]: Number of read in kb: %"PRIu64"\n", APPNAME, poolname, stats.num_rd_kb); printf("[%s][%s]: Number of write: %"PRIu64"\n", APPNAME, poolname, stats.num_wr); printf("[%s][%s]: Number of write in kb: %"PRIu64"\n", APPNAME, poolname, stats.num_wr_kb); rados_ioctx_destroy(io); poolname = strtok(NULL, ","); } /* Shut down the cluster */ rados_shutdown(cluster); printf("[%s]: Cluster shut down.\n", APPNAME); }
enum nss_status _nss_shib_getgrgid_r(gid_t gid, struct group *result, char *buffer, size_t buflen, int *errnop) { #ifdef DEBUG fprintf(stderr, "\nEntering _nss_shib_getgrgid_r with gid=%d.\n", gid); #endif int ret = NSS_STATUS_UNAVAIL; readconfig(); char newurl[1024]; sprintf(newurl, "%s", url_group); if (!geturl(newurl, username, password, cafile, sslcheck) || body == NULL) { ret = NSS_STATUS_UNAVAIL; goto getgrgid_err; } BODY *cursor = body; while (cursor) { char *cur_row = cursor->row; int count_separator = count_char_in_str(cur_row, ':'); char **array = split_str(cur_row, ':'); if (array[0] != NULL && count_separator >= 3 && atoi(array[2]) == gid) { int setting = setgroupfromarray(array, result, buffer, buflen); if (setting != 0) { if (setting == 1) { if(array) free(array); *errnop = ERANGE; ret = NSS_STATUS_TRYAGAIN; } else { ret = NSS_STATUS_UNAVAIL; } goto getgrgid_err; } #ifdef DEBUG fprintf(stderr, "Found item for gid=%d: [name=%s]\n", gid, array[0]); #endif ret = NSS_STATUS_SUCCESS; } if(array) free(array); cursor = cursor->next; } getgrgid_err: cleanbody(); return ret; }
bool matches_pattern( const string& str, const string& pattern, const char* pattern_delim_chars ) { std::vector<std::string> patterns = split_str( pattern, pattern_delim_chars ); for ( auto p : patterns ) { #ifdef FLUT_COMP_MSVC flut_assert_msg( strcmp( pattern_delim_chars, ";" ) == 0, "Pattern delimiter must be ';' for MSVC" ); if ( PathMatchSpecEx( str.c_str(), p.c_str(), PMSF_NORMAL ) == S_OK ) return true; #else if ( fnmatch( p.c_str(), str.c_str(), FNM_NOESCAPE ) == 0 ) return true; #endif } return false; }
// Split off the title and break up the body lines void popup_split_lines(popup_info *pi, int flags) { int nlines, i, body_offset = 0; int n_chars[POPUP_MAX_LINES]; const char *p_str[POPUP_MAX_LINES]; gr_set_font(FONT1); n_chars[0]=0; nlines = split_str(pi->raw_text, 1000, n_chars, p_str, POPUP_MAX_LINES); Assert(nlines >= 0 && nlines <= POPUP_MAX_LINES ); if ( flags & (PF_TITLE | PF_TITLE_BIG) ) { // get first line out strncpy(pi->title, p_str[0], n_chars[0]); pi->title[n_chars[0]] = 0; body_offset = 1; } if ( flags & PF_BODY_BIG ) { gr_set_font(FONT2); } nlines = split_str(pi->raw_text, Popup_text_coords[gr_screen.res][2], n_chars, p_str, POPUP_MAX_LINES); Assert(nlines >= 0 && nlines <= POPUP_MAX_LINES ); pi->nlines = nlines - body_offset; for ( i = 0; i < pi->nlines; i++ ) { Assert(n_chars[i+body_offset] < POPUP_MAX_LINE_CHARS); strncpy(pi->msg_lines[i], p_str[i+body_offset], n_chars[i+body_offset]); pi->msg_lines[i][n_chars[i+body_offset]] = 0; } gr_set_font(FONT1); }
int lexicographic_cmp_field(char* a, char* b) { char* a_tokens[MAX_NUM_TOKENS]; char* b_tokens[MAX_NUM_TOKENS]; char* a_dup = str_dup(a); char* b_dup = str_dup(b); split_str(a_dup, a_tokens); split_str(b_dup, b_tokens); char* a_str = a_tokens[field]; char* b_str = b_tokens[field]; int index; for (index = 0; lexicographically_equal(a_str[index], b_str[index]); ++index) { if (a_str[index] == '\0') { return 0; } } return (sort_reverse ? b_str[index] - a_str[index] : a_str[index] - b_str[index]); }
void CWord_correct::make_cache(word_cache& cache,strhash& r_index,const std::string& search_word) { std::vector<std::string> ivec; split_str(search_word,ivec);//将查询词汇分割成每个单字,然后存到ivec中 std::vector<std::string>::iterator iter=ivec.begin(); for(iter;iter!=ivec.end();iter++) { std::set<std::pair<std::string,int> > temp=r_index[*iter]; std::set<std::pair<std::string,int> >::iterator iter=temp.begin(); for(iter;iter!=temp.end();iter++) { std::pair<std::string,int> apair=make_pair(iter->first,iter->second); cache.insert(apair); } } }
/********************************************************************* * 文字列 *buf から、パラメータを読み取り、( adrs , memcnt ) を決める ********************************************************************* */ int get_arg(char *buf) { #if 0 arena = AREA_RAM; if(*buf == 'p') { buf++; arena = AREA_PGMEM; }else if(*buf == 'r') { buf++; arena = AREA_EEPROM; } #endif arena=MEM_BYTE; if(*buf == 'b') { buf++; }else if(*buf == 'h') { buf++; arena = MEM_HALF; }else if(*buf == 'w') { buf++; arena = MEM_WORD; } // memcnt = 64; memcnt = 256; adrs2 = (-1); buf = sp_skip(buf); if(*buf==0) return 0; arg_cnt = split_str(buf,',',arg_ptr); scan_args(arg_cnt); if(arg_cnt>=1) { adrs = arg_hex[0]; } if(arg_cnt>=2) { adrs2 = arg_hex[1]; if(adrs2 != (-1) ) { memcnt = adrs2 - adrs + 1; } if( memcnt < 0) { memcnt = adrs2; } } return arg_cnt; }
bool parse_ini_conf_file(const std::string& path, INIProperties& result, const char* sep) { char buf[kConfigLineMax + 1]; FILE *fp; if ((fp = fopen(path.c_str(), "r")) == NULL) { return false; } uint32 lineno = 1; std::string current_tag = ""; while (fgets(buf, kConfigLineMax, fp) != NULL) { char* line = trim_str(buf, "\r\n\t "); if (line[0] == '#' || line[0] == '\0') { lineno++; continue; } if (line[0] == '[' && line[strlen(line) - 1] == ']') { current_tag = std::string(line + 1, strlen(line) - 2); lineno++; continue; } std::vector<char*> sp_ret = split_str(line, sep); if (sp_ret.size() != 2) { ERROR_LOG("Invalid config line at line:%u", lineno); fclose(fp); return false; } char* key = trim_str(sp_ret[0], "\r\n\t "); char* value = trim_str(sp_ret[1], "\r\n\t "); Properties& current_prop = result[current_tag]; if (current_prop.find(key) != current_prop.end()) { ERROR_LOG("Duplicate key:%s in config.", key); fclose(fp); return false; } current_prop[key] = value; lineno++; } fclose(fp); return true; }
int GetTitle(const char *str,char * title, int title_buf_len) { char *argv[2]; char key [MENU_TITLE_BUF_LEN +1] = {0}; char value [VALUE_LEN +1] = {0}; char *p; int argc, len; argv[0] = key; argv[1] = value; //Parse string. argc = split_str (str, argv); if( argc < 1 ) return -1; if( argc == 1 ) { //Support for OLD style lable len = strlen (argv[0]); if( argv[0][len -1] == ':') { argv[0][len -1] = '\0'; p=trim(argv[0]); //remove SPACE and TAB from begin and end of string. strncpy(title,p,title_buf_len); return 0; } } else { //remove SPACE and TAB from begin and end of string. p = trim (key); //check key. if( strcasecmp (p, "title") == 0 ) { //remove SPACE and TAB from begin and end of string. p = trim (value); //remove comment data from string. remove_comment(p); strncpy (title, p, title_buf_len); return 0; } } return -1; }
void FrameDB::add_alias(const string& line) { // this is a mapping from something like [unknown module] to an exe // provided at symbol generation time vector<string> mapping; split_str(line, "=>", mapping); if (mapping.size() != 2) { cerr << "Invalid mapping in viewer-data/symbtab: " << endl; cerr << " " << line << endl; cerr << mapping.size() << endl; exit(1); } ModuleId orig(trim(mapping[1])); ModuleId alias(trim(mapping[0])); aliases[alias] = orig; }