void Test_split_string(CuTest* tc) { int n = 255; /* Maximum n = 255 */ int t = 254; /* t <= n, we choose less than that so we have two tests */ char * phrase = "This is a test of Bücher and Später."; int count = 10; int i; for (i = 0; i < count; ++i) { char ** result = split_string(phrase, n, t); /* Extract secret using first t shares */ char * answer = join_strings(result, t); CuAssertStrEquals(tc, phrase, answer); free(answer); /* Extract secret using all shares */ answer = join_strings(result, n); CuAssertStrEquals(tc, phrase, answer); free(answer); free_string_shares(result, n); } }
int dash_eval(char *line, char *std_input, char *origin) { if (line == NULL) return 1; int num_tokens; char **tokens = str_split(line, " ", &num_tokens); char *token; int i; int remote_pipe_pos = -1; for (i = 0; i < num_tokens; i++) { if (strcmp(tokens[i], REMOTE_PIPE) == 0) { remote_pipe_pos = i; break; } } if (remote_pipe_pos == -1) // No remote pipes { char *msg_data = dash_exec_scmd(tokens, remote_pipe_pos + 1, num_tokens, std_input); if (std_input == NULL) { printf("%s", msg_data); return 1; } else { // Send to origin char *fio_msg = dashp_fio(msg_data); send_to_host(fio_msg, origin); return 1; } } else // Remote pipe at remote_pipe_pos { char *subcommand = join_strings(tokens, " ", remote_pipe_pos+1, num_tokens); char *remotehost = extract_host(subcommand); char *maincommand = join_strings(tokens, " ", 0, remote_pipe_pos); char *msg_data = dash_exec_scmd(tokens, 0, remote_pipe_pos, std_input); char *send_msg; if (std_input == NULL) { // TODO: MAKE IP ADDRESS FUNCTION WORK! char *fin_remote_host = (char *) malloc (strlen(remotehost) + 1); strcat(fin_remote_host, remotehost); strcat(fin_remote_host, ":"); remove_substring(subcommand, fin_remote_host); free (fin_remote_host); subcommand[strlen(subcommand)-1] = '\0'; send_msg = dashp_pip(msg_data, "127.0.0.1", subcommand); } else { send_msg = dashp_pip(msg_data, origin, subcommand); } send_to_host(send_msg, remotehost); printf("Sent"); return 2; } }
GRID *read_grid(char *keyname,short print) { /*! *\author Emanuele Cordano *\date May 2008 * */ GRID *grid; long j,c; grid=(GRID *)malloc(sizeof(GRID)); if (!grid) t_error("Grid in read_grid was not allocated"); grid->file_resume_lines=copy_string(join_strings(keyname,LINE_SUFFIX)); grid->file_resume_polygons=copy_string(join_strings(keyname,POLYGON_SUFFIX)); grid->file_resume_connections=copy_string(join_strings(keyname,CONNECTION_SUFFIX)); grid->lines=read_linevector(grid->file_resume_lines,print); grid->polygons=read_polygonvector(grid->file_resume_polygons,print); grid->links=read_connection_attribute_array(grid->file_resume_connections,print); /* check the boudaries */ if (grid->polygons->nh!=grid->links->nh) printf ("Error in read_grid inconstancy betenn numbers of polygons %ld and of connection attributes %ld \n",grid->lines->nh,grid->links->nh); //j=link->nl; //while ((cf==0) || (df==0)) { for (j=grid->links->nl;j<=grid->links->nh;j++) { if (grid->links->element[j]->connections->nh!=grid->polygons->element[j]->edge_indices->nh) printf ("Error in read_grid inconstancy between numbers of edge %ld and of connections %ld at the polygon %ld \n",grid->polygons->element[j]->edge_indices->nh,grid->links->element[j]->connections->nh,j); for (c=grid->links->element[j]->connections->nl;c<=grid->links->element[j]->connections->nh;c++) { if (grid->links->element[j]->connections->element[c]<0) grid->boundary_indicator=(long)grid->links->element[j]->connections->element[c]; } } //grid->boundary_indicator=-10; if (print==1) printf("\n Function read_grid was successfully executed (number of polygons: %ld - number of lines: %ld - boundary indactor : %ld) \n",grid->polygons->nh,grid->lines->nh,grid->boundary_indicator); //} // char *file_resume_lines_fine=join_strings(resume_filenames,"_lines_fine.txt"); // char *file_resume_polygons_fine=join_strings(resume_filenames,"_polygons_fine.txt"); // char *file_resume_connections_fine=join_strings(resume_filenames,"_connections_fine.txt"); // char *file_resume_c_polygon=join_strings(resume_filenames,"_c_polygon.txt"); // char *file_resume_c_line=join_strings(resume_filenames,"_c_line.txt"); return grid; }
DOUBLESQUARE_GRID *read_doublesquare_grid (DOUBLERASTER_MAP *draster, char *keyname,long (*index_pixel_from_a_bin_coarse)(long r, long c,LONGVECTOR *s_index),long (*index_pixel_from_a_bin_fine)(long r, long c,LONGVECTOR *s_index),short print){ /* * * \author Emanuele Cordano * \date May 2009 * *\param - DOUBLERASTER_MAP *draster *\param - (char *) root neme of textfiles containing the struct information. *\param long (*index_pixel_from_a_bin_coarse)(long r, long c,LONGVECTOR *s_index) - equation of the filling curve for the pixel of a coarse grid *\param long (*index_pixel_from_a_bin_fine)(long r, long c,LONGVECTOR *s_index),long d_coarse,long d_fine,short print) - equation of the filling curve for the pixel of a fine grid *\param (short) print * */ DOUBLESQUARE_GRID *dsq; char *keyname_coarse=join_strings(keyname,"__coarse"); char *keyname_fine=join_strings(keyname,"__fine"); char *filename_c_polygon=join_strings(keyname,"_c_polygon.txt"); char *filename_c_line=join_strings(keyname,"_c_line.txt"); dsq=(DOUBLESQUARE_GRID *)malloc(sizeof(DOUBLESQUARE_GRID)); if (!dsq) t_error("Double Square Grid dsq in read_doublesquare_grid was not allocated"); dsq->big=read_square_grid(keyname_coarse,draster->coarse->layer[draster->coarse->reference_index_map],index_pixel_from_a_bin_coarse,draster->coarse->UV->V,draster->coarse->check_novalues,print); dsq->fine=read_square_grid(keyname_fine,draster->fine->layer[draster->fine->reference_index_map],index_pixel_from_a_bin_fine,draster->fine->UV->V,draster->fine->check_novalues,print); dsq->file_resume_c_line=copy_string(filename_c_line); dsq->file_resume_c_polygon=copy_string(filename_c_polygon); dsq->small_content_line=read_line_indices(dsq->file_resume_c_line,print); dsq->small_content_polygon=read_fine_indices(dsq->file_resume_c_polygon,print); if (dsq->small_content_line->index->nh!=dsq->big->grid->lines->nh) { printf("Error in read_doublesquare_grid inconstancy with number of (big) lines %ld and %ld \n",dsq->small_content_line->index->nh,dsq->big->grid->lines->nh); stop_execution(); } if (dsq->small_content_polygon->nh!=dsq->big->grid->polygons->nh) { printf("Error in read_doublesquare_grid inconstancy with number of (big) lines %ld and %ld \n",dsq->small_content_polygon->nh,dsq->big->grid->polygons->nh); stop_execution(); } if (print==1) printf("Function read_doublesquare_grid was successfully executed! \n "); return dsq; }
/* This function performs what I'm calling the "gluing" together of strings. * For example, if you type * * $ echo "a"'b' * * at the shell, the double-quoted string "a" will be glued together with the * single-quoted string 'b' because they are not separated by any whitespace. * * This transformation occurs after parameter expansion and word splitting, but * before filename expansion. So, for example, "a"'b'* would be equivalent to * ab*, and ${a}b would be equivalent to "a" "cb" if the shell variable $a is * set to "a c". * * The input is a list @string_list that gives a list of strings passed to the * shell. Each string is glued to any adjacent, succeeding strings that have * the flag STRING_FLAG_PRECEDING_WHITESPACE set, which indicates that they * should be glued to the preceding string. The resulting list of "glued" * strings replaces the input list. * * This function also has a special responsibility where it looks for "glued" * strings that are constructed from an unquoted string that matches the regular * expression [A-Za-z_][A-Za-z_0-9]*=.*, followed by zero or more unquoted or * quoted strings. So, for example, * $ a="b" * $ a=b * $ a="b"'c' * $ a= # this is legal; it unsets the variable a * The glued strings of this form are interpreted as variable assignments, so * the STRING_FLAG_VAR_ASSIGNMENT flag is set on these glued strings. * */ static int glue_strings(struct list_head *string_list) { struct string *s, *tmp; LIST_HEAD(new_list); while (!list_empty(string_list)) { struct list_head *first = string_list->next; int flags; /* Glue one string */ LIST_HEAD(glue_list); list_move_tail(first, &glue_list); list_for_each_entry_safe(s, tmp, string_list, list) { if (s->flags & STRING_FLAG_PRECEDING_WHITESPACE) break; else list_move_tail(&s->list, &glue_list); } /* Detect variable assignments * TODO: Somehow make it so that unquoted strings where * parameter expansion has occurred on the left side of the * equals sign are not considered variable assignments. */ s = list_entry(first, struct string, list); if (s->flags & STRING_FLAG_UNQUOTED && string_matches_param_assignment(s)) flags = STRING_FLAG_VAR_ASSIGNMENT; else flags = 0; s = join_strings(&glue_list); s->flags = flags; list_add_tail(&s->list, &new_list); } /* Replace @string_list with the list of glued strings */ list_splice_tail(&new_list, string_list); return 0; }
int update(int socket, t_env *e) { t_client* tmp; int alive; alive = 0; tmp = e->clients; while (e->clients != NULL) { if (e->clients->socket == socket) { alive = 1; break; } e->clients = e->clients->next; } e->clients = tmp; if (alive == 0) { my_send(socket, "ko"); return -1; } char *map = join_strings(e->map, "\n", e->map_size[0] + 1); //puts(map); my_send(socket, map); return 0; }
std::string join_strings( const std::vector<std::string>& in, const std::string& separator ) { std::string result ; join_strings(in, separator, result) ; return result ; }
static void var_set_tag(DCVariable *var, int argc, char **argv) { char *new_value = join_strings(argv+1, argc-1, ' '); if (strpbrk(new_value, "$|") != NULL) { warn(_("Tag may not contain `$' or `|' characters.\n")); free(new_value); } else { free(my_tag); my_tag = new_value; } }
char * extract_secret_from_share_strings(const char * string) { char ** shares = malloc(sizeof(char *) * 255); char * share; char * saveptr = NULL; int i = 0; /* strtok_rr modifies the string we are looking at, so make a temp copy */ char * temp_string = strdup(string); /* Parse the string by line, remove trailing whitespace */ share = strtok_rr(temp_string, "\n", &saveptr); shares[i] = strdup(share); trim_trailing_whitespace(shares[i]); while ( (share = strtok_rr(NULL, "\n", &saveptr))) { i++; shares[i] = strdup(share); trim_trailing_whitespace(shares[i]); if ((shares[i] != NULL) && (strlen(shares[i]) == 0)) { /* Ignore blank lines */ free(shares[i]); i--; } } i++; char * secret = join_strings(shares, i); /* fprintf(stdout, "count: %d\n", i); for (int j = 0; j < i; ++j) { fprintf(stderr, "'%s'\n", shares[j]); } */ free_string_shares(shares, i); return secret; }
static void var_set_description(DCVariable *var, int argc, char **argv) { char *new_value = join_strings(argv+1, argc-1, ' '); if (strpbrk(new_value, "$|") != NULL) { warn(_("Description may not contain `$' or `|' characters.\n")); free(new_value); } else if (strnlen(new_value, 36) >= 36) { warn(_("Description is too long - max length is 35 characters.\n")); free(new_value); } else { free(my_description); my_description = new_value; } }
void write_esriascii(char *name, short type, DOUBLEMATRIX *DTM, T_INIT *UV, long novalue){ // type=0 floating point // type=1 integer FILE *f; long r,c; char *temp; if(UV->U->co[1]!=UV->U->co[2]){ printf("\nCannot export in esriascii, grid not square, Dx=%f Dy=%f \n",UV->U->co[2],UV->U->co[1]); t_error("Fatal error"); } temp = join_strings(name,ascii_esri); f=fopen(temp,"w"); fprintf(f,"ncols %ld\n",DTM->nch); fprintf(f,"nrows %ld\n",DTM->nrh); fprintf(f,"xllcorner %f\n",UV->U->co[4]); fprintf(f,"yllcorner %f\n",UV->U->co[3]); fprintf(f,"cellsize %f\n",UV->U->co[1]); fprintf(f,"NODATA_value %ld.0\n",novalue); for(r=1;r<=DTM->nrh;r++){ for(c=1;c<=DTM->nch;c++){ if((long)DTM->co[r][c]==novalue){ fprintf(f,"%ld.0",novalue); }else{ if(type==1){ fprintf(f,"%ld",(long)(DTM->co[r][c])); }else{ fprintf(f,"%f",DTM->co[r][c]); } } if(c<DTM->nch) fprintf(f," "); } if(r<DTM->nrh) fprintf(f,"\n"); } fclose(f); free(temp); }
static char* mid_stops_string(qgs_t *qgs) { int n = qgs->n; if (n < 3) return NULL; char *stops[n-2]; for (int i = 0 ; i < n-2 ; i++) { if ((stops[i] = mid_stop(qgs->entries + i + 1)) == NULL) return NULL; } char *buffer = join_strings(stops, n-2, ':'); for (int i = 0 ; i < n-2 ; i++) free(stops[i]); return buffer; }
void write_grassascii_vector(char *name, short type, DOUBLEVECTOR *DTM, long **j, long nr, long nc, T_INIT *UV, long novalue){ // type=0 floating point // type=1 integer FILE *f; char *temp; long r,c; temp = join_strings(name,ascii_grass); f=fopen(temp,"w"); fprintf(f,"north:%f\n",UV->U->co[3]+nr*UV->U->co[1]); fprintf(f,"south:%f\n",UV->U->co[3]); fprintf(f,"east:%f\n",UV->U->co[4]+nc*UV->U->co[2]); fprintf(f,"west:%f\n",UV->U->co[4]); fprintf(f,"rows:%ld\n",nr); fprintf(f,"cols:%ld\n",nc); for(r=1;r<=nr;r++){ for(c=1;c<=nc;c++){ if (j[r][c] > 0) { if(type==1){ fprintf(f,"%ld",(long)(DTM->co[j[r][c]])); }else{ fprintf(f,"%f",DTM->co[j[r][c]]); } }else { fprintf(f,"%ld.0",novalue); } if(c<nc) fprintf(f," "); } if(r<nr) fprintf(f,"\n"); } fclose(f); free(temp); }
void write_grassascii(char *name, short type, DOUBLEMATRIX *DTM, T_INIT *UV, long novalue){ // type=0 floating point // type=1 integer FILE *f; char *temp; long r,c; temp = join_strings(name,ascii_grass); f=fopen(temp,"w"); fprintf(f,"north:%f\n",UV->U->co[3]+DTM->nrh*UV->U->co[1]); fprintf(f,"south:%f\n",UV->U->co[3]); fprintf(f,"east:%f\n",UV->U->co[4]+DTM->nch*UV->U->co[2]); fprintf(f,"west:%f\n",UV->U->co[4]); fprintf(f,"rows:%ld\n",DTM->nrh); fprintf(f,"cols:%ld\n",DTM->nch); for(r=1;r<=DTM->nrh;r++){ for(c=1;c<=DTM->nch;c++){ if((long)DTM->co[r][c]==(long)novalue){ fprintf(f,"*"); }else{ if(type==1){ fprintf(f,"%ld",(long)(DTM->co[r][c])); }else{ fprintf(f,"%f",DTM->co[r][c]); } } if(c<DTM->nch) fprintf(f," "); } if(r<DTM->nrh) fprintf(f,"\n"); } fclose(f); free(temp); }
char * concat_strings (char *const *argv) { return join_strings ("", argv); }