00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00037 #include <stdio.h>
00038 #include <stdlib.h>
00039 #include <string.h>
00040
00041 #include <assert.h>
00042 #include <stdarg.h>
00043
00044 #include <ctype.h>
00045
00046 #include "splt.h"
00047
00048 void splt_su_replace_all_char(char *str, char to_replace, char replacement)
00049 {
00050 if (str == NULL)
00051 {
00052 return;
00053 }
00054
00055 int i = 0;
00056 for (i = 0;i < strlen(str);i++)
00057 {
00058 if (str[i] == to_replace)
00059 {
00060 str[i] = replacement;
00061 }
00062 }
00063 }
00064
00065 char *splt_su_replace_all(const char *str, char *to_replace,
00066 char *replacement, int *error)
00067 {
00068 if (str == NULL)
00069 {
00070 return NULL;
00071 }
00072
00073 char *new_str = NULL;
00074 int err = SPLT_OK;
00075
00076 if (to_replace == NULL || replacement == NULL)
00077 {
00078 int err = splt_su_copy(str, &new_str);
00079 if (err < 0) { *error = err; }
00080 return new_str;
00081 }
00082
00083 const char *ptr = str;
00084 const char *prev_ptr = ptr;
00085 while ((ptr = strstr(ptr, to_replace)) != NULL)
00086 {
00087 err = splt_su_append(&new_str, prev_ptr, ptr - prev_ptr,
00088 replacement, strlen(replacement), NULL);
00089 if (err != SPLT_OK) { goto error; }
00090 ptr += strlen(to_replace);
00091 prev_ptr = ptr;
00092 }
00093
00094 if (prev_ptr != NULL)
00095 {
00096 err = splt_su_append(&new_str, prev_ptr, (str + strlen(str)) - prev_ptr, NULL);
00097 if (err != SPLT_OK) { goto error; }
00098 }
00099
00100 return new_str;
00101
00102 error:
00103 if (new_str)
00104 {
00105 free(new_str);
00106 }
00107 *error = err;
00108
00109 return NULL;
00110 }
00111
00112 int splt_su_append_str(char **str, const char *to_append, ...)
00113 {
00114 int err = SPLT_OK;
00115 va_list ap;
00116
00117 va_start(ap, to_append);
00118
00119 while (to_append)
00120 {
00121 size_t to_append_size = strlen(to_append);
00122 err = splt_su_append(str, to_append, to_append_size, NULL);
00123 if (err < 0) { break; }
00124 to_append = va_arg(ap, const char *);
00125 }
00126
00127 va_end(ap);
00128
00129 return err;
00130 }
00131
00132 static int splt_su_append_one(char **str, const char *to_append, size_t to_append_size)
00133 {
00134 if (str == NULL || to_append == NULL || to_append[0] == '\0' || to_append_size == 0)
00135 {
00136 return SPLT_OK;
00137 }
00138
00139 size_t new_size = 0;
00140
00141 if (*str == NULL)
00142 {
00143 new_size = to_append_size + 1;
00144 *str = malloc(new_size);
00145 if (*str == NULL)
00146 {
00147 return SPLT_ERROR_CANNOT_ALLOCATE_MEMORY;
00148 }
00149
00150 *str[0] = '\0';
00151 }
00152 else
00153 {
00154 new_size = to_append_size + strlen(*str) + 1;
00155 *str = realloc(*str, new_size);
00156 if (*str == NULL)
00157 {
00158 return SPLT_ERROR_CANNOT_ALLOCATE_MEMORY;
00159 }
00160 }
00161
00162 strncat(*str, to_append, to_append_size);
00163
00164 return SPLT_OK;
00165 }
00166
00167 int splt_su_append(char **str, const char *to_append, ...)
00168 {
00169 int err = SPLT_OK;
00170 va_list ap;
00171
00172 va_start(ap, to_append);
00173
00174 while (to_append)
00175 {
00176 size_t to_append_size = va_arg(ap, size_t);
00177 err = splt_su_append_one(str, to_append, to_append_size);
00178 if (err < 0) { break; }
00179 to_append = va_arg(ap, const char *);
00180 }
00181
00182 va_end(ap);
00183
00184 return err;
00185 }
00186
00187 int splt_su_set(char **str, const char *to_append, ...)
00188 {
00189 if (!str)
00190 {
00191 return SPLT_OK;
00192 }
00193
00194 if (*str)
00195 {
00196 free(*str);
00197 *str = NULL;
00198 }
00199
00200 int err = SPLT_OK;
00201 va_list ap;
00202
00203 va_start(ap, to_append);
00204
00205 while (to_append)
00206 {
00207 size_t to_append_size = va_arg(ap, size_t);
00208 err = splt_su_append_one(str, to_append, to_append_size);
00209 if (err < 0) { break; }
00210 to_append = va_arg(ap, const char *);
00211 }
00212
00213 va_end(ap);
00214
00215 return err;
00216 }
00217
00218 void splt_su_free_replace(char **str, char *replacement)
00219 {
00220 if (!str)
00221 {
00222 return;
00223 }
00224
00225 if (*str)
00226 {
00227 free(*str);
00228 }
00229
00230 *str = replacement;
00231 }
00232
00233 int splt_su_copy(const char *src, char **dest)
00234 {
00235 if (!dest)
00236 {
00237 return SPLT_OK;
00238 }
00239
00240 if (*dest)
00241 {
00242 free(*dest);
00243 *dest = NULL;
00244 }
00245
00246 if (src == NULL)
00247 {
00248 *dest = NULL;
00249 return SPLT_OK;
00250 }
00251
00252 int length = strlen(src) + 1;
00253 if ((*dest = malloc(sizeof(char) * length)) == NULL)
00254 {
00255 return SPLT_ERROR_CANNOT_ALLOCATE_MEMORY;
00256 }
00257
00258 snprintf(*dest, length, "%s", src);
00259
00260 return SPLT_OK;
00261 }
00262
00263 static int splt_su_is_illegal_char(char c, int ignore_dirchar)
00264 {
00265 if ((ignore_dirchar) && (c == SPLT_DIRCHAR))
00266 {
00267 return SPLT_FALSE;
00268 }
00269
00270
00271
00272 if ((c == '\\') || (c == '/') || (c == ':') || (c == '*') ||
00273 (c == '?') || (c == '"') || (c == '<') ||
00274 (c == '>') || (c == '|') || (c == '\r'))
00275 {
00276 return SPLT_TRUE;
00277 }
00278
00279 return SPLT_FALSE;
00280 }
00281
00282 static void splt_su_clean_string_(splt_state *state, char *s, int *error, int ignore_dirchar)
00283 {
00284 int i = 0, j=0;
00285 char *copy = NULL;
00286 if (s)
00287 {
00288 copy = strdup(s);
00289 if (copy)
00290 {
00291 for (i=0; i<=strlen(copy); i++)
00292 {
00293 if (! splt_su_is_illegal_char(copy[i], ignore_dirchar))
00294 {
00295 s[j++] = copy[i];
00296 }
00297 else
00298 {
00299 s[j++] = '_';
00300 }
00301 }
00302 free(copy);
00303 copy = NULL;
00304
00305
00306 for (i=strlen(s)-1; i >= 0; i--)
00307 {
00308 if (s[i]==' ')
00309 {
00310 s[i] = '\0';
00311 }
00312 else
00313 {
00314 break;
00315 }
00316 }
00317 }
00318 else
00319 {
00320 *error = SPLT_ERROR_CANNOT_ALLOCATE_MEMORY;
00321 }
00322 }
00323 }
00324
00325 void splt_su_clean_string(splt_state *state, char *s, int *error)
00326 {
00327 splt_su_clean_string_(state, s, error, SPLT_FALSE);
00328 }
00329
00330 char *splt_su_cut_spaces(char *c)
00331 {
00332 while (isspace(*c))
00333 {
00334 c++;
00335 }
00336
00337 return c;
00338 }
00339
00340 const char *splt_su_skip_spaces(const char *c)
00341 {
00342 while (*c == ' ' || *c == '\t')
00343 {
00344 c++;
00345 }
00346
00347 return c;
00348 }
00349
00350 void splt_su_cut_spaces_from_end(char *c)
00351 {
00352 if (c == NULL || *c == '\0')
00353 {
00354 return;
00355 }
00356
00357 char *end = strchr(c, '\0');
00358 if (!end)
00359 {
00360 return;
00361 }
00362
00363 end--;
00364
00365 while (isspace(*end))
00366 {
00367 *end = '\0';
00368 end--;
00369 }
00370 }
00371
00372 char *splt_su_trim_spaces(char *c)
00373 {
00374 splt_su_cut_spaces_from_end(c);
00375 return splt_su_cut_spaces(c);
00376 }
00377
00378 int splt_su_is_empty_line(const char *line)
00379 {
00380 if (!line)
00381 {
00382 return SPLT_TRUE;
00383 }
00384
00385 size_t size = strlen(line);
00386 int i = 0;
00387 for (i = 0;i < size;i++)
00388 {
00389 if (!isspace(line[i]))
00390 {
00391 return SPLT_FALSE;
00392 }
00393 }
00394
00395 return SPLT_TRUE;
00396 }
00397
00398 void splt_su_line_to_unix(char *line)
00399 {
00400 size_t line_size = strlen(line);
00401 if (line_size > 1)
00402 {
00403 if (line[line_size-2] == '\r')
00404 {
00405 line[line_size-2] = '\n';
00406 line[line_size-1] = '\0';
00407 }
00408 }
00409 }
00410
00411 void splt_su_keep_path_and_remove_filename(char *path)
00412 {
00413 char *last_dirchar = strrchr(path, SPLT_DIRCHAR);
00414 if (last_dirchar == NULL)
00415 {
00416 return;
00417 }
00418
00419 *(last_dirchar+1) = '\0';
00420
00421 #ifdef __WIN32__
00422 if (!splt_w32_str_is_drive_root_directory(path))
00423 {
00424 *last_dirchar = '\0';
00425 }
00426 #else
00427 if (last_dirchar != path)
00428 {
00429 *last_dirchar = '\0';
00430 }
00431 #endif
00432 }
00433
00434 const char *splt_su_get_fname_without_path(const char *filename)
00435 {
00436 char *c = NULL;
00437 while ((c = strchr(filename, SPLT_DIRCHAR)) != NULL)
00438 {
00439 filename = c + 1;
00440 }
00441
00442 return filename;
00443 }
00444
00445 char *splt_su_get_fname_without_path_and_extension(const char *filename, int *error)
00446 {
00447 const char *fname_without_path = splt_su_get_fname_without_path(filename);
00448
00449 char *fname_without_path_and_extension = NULL;
00450 int err = splt_su_copy(fname_without_path, &fname_without_path_and_extension);
00451 if (err < 0) {
00452 *error = err;
00453 return NULL;
00454 }
00455
00456 splt_su_cut_extension(fname_without_path_and_extension);
00457
00458 return fname_without_path_and_extension;
00459 }
00460
00461 char *splt_su_get_fname_with_path_and_extension(splt_state *state, int *error)
00462 {
00463 int err = SPLT_OK;
00464 char *output_fname_with_path = NULL;
00465
00466 int current_split = splt_t_get_current_split(state);
00467 const char *output_fname = splt_sp_get_splitpoint_name(state, current_split, error);
00468
00469 if (!output_fname)
00470 {
00471 char *stdout_str = NULL;
00472 err = splt_su_copy("-", &stdout_str);
00473 if (err < 0) { *error = err; }
00474 return stdout_str;
00475 }
00476
00477 if (strcmp(output_fname, "-") == 0)
00478 {
00479 char *result = NULL;
00480 err = splt_su_copy(output_fname, &result);
00481 if (err < 0) { goto error; }
00482 return result;
00483 }
00484
00485 const char *extension = splt_p_get_extension(state, &err);
00486 if (err < 0) { goto error; }
00487
00488 const char *new_filename_path = splt_t_get_new_filename_path(state);
00489 if (new_filename_path[0] == '\0')
00490 {
00491 err = splt_su_append_str(&output_fname_with_path, output_fname,
00492 extension, NULL);
00493 if (err < 0) { goto error; }
00494 }
00495 else
00496 {
00497 if (new_filename_path[strlen(new_filename_path)-1] == SPLT_DIRCHAR)
00498 {
00499 err = splt_su_append_str(&output_fname_with_path, new_filename_path,
00500 output_fname, extension, NULL);
00501 }
00502 else
00503 {
00504 err = splt_su_append_str(&output_fname_with_path, new_filename_path,
00505 SPLT_DIRSTR, output_fname, extension, NULL);
00506 }
00507 if (err < 0) { goto error; }
00508 }
00509
00510 const char *filename = splt_t_get_filename_to_split(state);
00511 if (splt_io_check_if_file(state, output_fname_with_path))
00512 {
00513 if (splt_check_is_the_same_file(state, filename, output_fname_with_path, &err))
00514 {
00515 splt_e_set_error_data(state,filename);
00516 err = SPLT_ERROR_INPUT_OUTPUT_SAME_FILE;
00517 goto error;
00518 }
00519 }
00520
00521
00522
00523 return output_fname_with_path;
00524
00525 error:
00526 if (output_fname_with_path)
00527 {
00528 free(output_fname_with_path);
00529 output_fname_with_path = NULL;
00530 }
00531
00532 *error = err;
00533
00534 return NULL;
00535 }
00536
00537 void splt_su_cut_extension(char *str)
00538 {
00539 char *point = strrchr(str , '.');
00540 if (point)
00541 {
00542 *point = '\0';
00543 }
00544 }
00545
00546 void splt_su_str_cut_last_char(char *str)
00547 {
00548 if (!str)
00549 {
00550 return;
00551 }
00552
00553 str[strlen(str)-1] = '\0';
00554 }
00555
00556 double splt_su_str_line_to_double(const char *str)
00557 {
00558 if (!str)
00559 {
00560 return 0.0;
00561 }
00562
00563 while ((*str != '\0') && (isdigit(*str) == 0))
00564 {
00565 str++;
00566 }
00567
00568 return atof(str);
00569 }
00570
00571 char *splt_su_get_file_with_output_path(splt_state *state, char *filename, int *error)
00572 {
00573 int err = SPLT_OK;
00574 char *new_fname = NULL;
00575
00576 if (filename == NULL)
00577 {
00578 return NULL;
00579 }
00580
00581 splt_su_clean_string(state, filename, error);
00582 if (error < 0) { return NULL; }
00583
00584 const char *path_of_split = splt_t_get_path_of_split(state);
00585 if (path_of_split)
00586 {
00587 if (path_of_split[strlen(path_of_split)] == SPLT_DIRCHAR)
00588 {
00589 splt_su_append_str(&new_fname, path_of_split, filename, NULL);
00590 if (err < 0) { *error = err; }
00591 return new_fname;
00592 }
00593
00594 splt_su_append_str(&new_fname, path_of_split, SPLT_DIRSTR, filename, NULL);
00595 if (err < 0) { *error = err; }
00596 return new_fname;
00597 }
00598
00599 err = splt_su_copy(filename, &new_fname);
00600 if (err < 0) { *error = err; }
00601 return new_fname;
00602 }
00603
00604 int splt_su_str_ends_with(const char *str1, const char *str2)
00605 {
00606 if (!str1 || !str2)
00607 {
00608 return SPLT_FALSE;
00609 }
00610
00611 int str1_end_index = strlen(str1) - 1;
00612 int str2_end_index = strlen(str2) - 1;
00613
00614 while (str1_end_index >= 0 && str2_end_index >= 0)
00615 {
00616 if (str1[str1_end_index] != str2[str2_end_index])
00617 {
00618 return SPLT_FALSE;
00619 }
00620
00621 str1_end_index--;
00622 str2_end_index--;
00623 }
00624
00625 return SPLT_TRUE;
00626 }
00627
00628 char *splt_su_format_messagev(splt_state *state, const char *message, va_list ap)
00629 {
00630 int counter = 0;
00631
00632 int written_chars = 0;
00633
00634 int size = 255;
00635 char *mess = malloc(sizeof(char) * size);
00636 if (mess == NULL)
00637 {
00638 splt_d_send_memory_error_message(state);
00639 splt_e_error(SPLT_IERROR_CHAR, __func__, 0, _("not enough memory"));
00640 return NULL;
00641 }
00642
00643 while (counter < LONG_MAX)
00644 {
00645 written_chars = vsnprintf(mess, size, message, ap);
00646
00647 if ((written_chars > -1) &&
00648 (written_chars+1 < size))
00649 {
00650 break;
00651 }
00652 else {
00653 size += 255;
00654 }
00655
00656 if ((mess = realloc(mess, size)) == NULL)
00657 {
00658 free(mess);
00659 splt_d_send_memory_error_message(state);
00660 splt_e_error(SPLT_IERROR_CHAR, __func__, 0, _("not enough memory"));
00661 return NULL;
00662 }
00663
00664 counter++;
00665 }
00666
00667 return mess;
00668 }
00669
00670 char *splt_su_get_formatted_message(splt_state *state, const char *message, ...)
00671 {
00672 char *mess = NULL;
00673
00674 va_list ap;
00675 va_start(ap, message);
00676 mess = splt_su_format_messagev(state, message, ap);
00677 va_end(ap);
00678
00679 return mess;
00680 }
00681
00682 int splt_su_str_line_has_digit(const char *str)
00683 {
00684 while (*str != '\0')
00685 {
00686 if (isdigit(*str))
00687 {
00688 return SPLT_TRUE;
00689 }
00690
00691 str++;
00692 }
00693
00694 return SPLT_FALSE;
00695 }
00696
00697 static char *splt_su_str_to_func(const char *str, int (*conversion_func)(int), int *error)
00698 {
00699 int err = SPLT_OK;
00700
00701 if (!str)
00702 {
00703 return NULL;
00704 }
00705
00706 char *result = NULL;
00707 err = splt_su_copy(str, &result);
00708 if (err < 0)
00709 {
00710 *error = err;
00711 return NULL;
00712 }
00713
00714 int i = 0;
00715 for (i = 0;i < strlen(str);i++)
00716 {
00717 result[i] = conversion_func(str[i]);
00718 }
00719
00720 return result;
00721 }
00722
00723
00724 char *splt_su_convert(const char *str, splt_str_format format, int *error)
00725 {
00726 if (str == NULL)
00727 {
00728 return NULL;
00729 }
00730
00731 char *new_str = NULL;
00732
00733 int lastspace = 1;
00734 int i = 0;
00735
00736 if (format != SPLT_TO_LOWERCASE && format != SPLT_TO_UPPERCASE)
00737 {
00738 int err = splt_su_copy(str, &new_str);
00739 if (err < 0)
00740 {
00741 *error = err;
00742 return NULL;
00743 }
00744 }
00745
00746 switch (format)
00747 {
00748 case SPLT_NO_CONVERSION:
00749 return new_str;
00750 break;
00751 case SPLT_TO_LOWERCASE:
00752 return splt_su_str_to_func(str, tolower, error);
00753 break;
00754 case SPLT_TO_UPPERCASE:
00755 return splt_su_str_to_func(str, toupper, error);
00756 break;
00757 case SPLT_TO_FIRST_UPPERCASE:
00758 new_str[0] = toupper(new_str[0]);
00759 return new_str;
00760 break;
00761 case SPLT_TO_WORD_FIRST_UPPERCASE:
00762 for (i = 0; i < strlen(new_str); i++)
00763 {
00764 if (lastspace && new_str[i] != ' ')
00765 {
00766 new_str[i] = toupper(new_str[i]);
00767 }
00768
00769 if (new_str[i] == ' ')
00770 {
00771 lastspace = 1;
00772 }
00773 else
00774 {
00775 lastspace = 0;
00776 }
00777 }
00778 return new_str;
00779 break;
00780 }
00781
00782 return NULL;
00783 }
00784