/* * Copyright (c) 2014 * Tama Communications Corporation * * This file is part of GNU GLOBAL. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #ifdef HAVE_CONFIG_H #include #endif #ifdef HAVE_STRING_H #include #else #include #endif #include #include "checkalloc.h" #include "rewrite.h" /* Rewrite: sed style rewriting module. usage: REWRITE *rewrite = rewrite_open("xyz", "<&>", 0); rewrite_string(rewrite, "xyzABCxzy", 0); => ABCxzy rewrite_pattern(rewrite, "abc", REG_ICASE); rewrite_string(rewrite, "xxxABCyyy", 0); => xxxyyy rewrite_close(rewrite); */ /** * rewrite_open: open rewrite object * * @param[in] pattern * accepts NULL * @param[in] replace (allows '&') * @param[in] flags for regcomp(3) * @return rewrite REWRITE structure * NULL: invalid regular expression */ REWRITE * rewrite_open(const char *pattern, const char *replace, int flags) { REWRITE *rewrite = (REWRITE *)check_calloc(sizeof(REWRITE), 1); char *p; if (pattern) { if (regcomp(&rewrite->reg, pattern, flags) != 0) { free(rewrite); return NULL; } rewrite->pattern = check_strdup(pattern); } rewrite->replace = check_strdup(replace); if ((p = strchr(rewrite->replace, '&')) != NULL) { if (p > rewrite->replace) { *p = '\0'; rewrite->part[REWRITE_LEFT] = rewrite->replace; rewrite->len[REWRITE_LEFT] = strlen(rewrite->replace); } if (*++p != 0) { rewrite->part[REWRITE_RIGHT] = p; rewrite->len[REWRITE_RIGHT] = strlen(p); } } else { rewrite->part[REWRITE_CENTER] = rewrite->replace; rewrite->len[REWRITE_CENTER] = strlen(rewrite->replace); } return rewrite; } /** * rewrite_pattern: set pattern to the rewrite object * * @param[in] rewrite object * @param[in] pattern * @param[in] flags for regcomp(3) * @return 0: normal * -1: invalid regular expression */ int rewrite_pattern(REWRITE *rewrite, const char *pattern, int flags) { int status = 0; if (rewrite->pattern) { free(rewrite->pattern); regfree(&rewrite->reg); } status = regcomp(&rewrite->reg, pattern, flags); rewrite->pattern = (status == 0) ? check_strdup(pattern) : NULL; return status; } /** * rewrite_string: execute rewrite against string * * @param[in] rewrite object * NULL: just print string * @param[in] string * @param[in] offset start point of the rewriting * */ const char * rewrite_string(REWRITE *rewrite, const char *string, int offset) { STATIC_STRBUF(sb); regmatch_t m; /* if rewrite object is NULL or does not match, just return the string. */ if (rewrite == NULL || rewrite->pattern == NULL) return string; if (regexec(&rewrite->reg, string + offset, 1, &m, 0) != 0) return string; strbuf_clear(sb); strbuf_nputs(sb, string, offset); string += offset; strbuf_nputs(sb, string, m.rm_so); if (rewrite->part[REWRITE_CENTER]) { strbuf_puts(sb, rewrite->part[REWRITE_CENTER]); } else { if (rewrite->part[REWRITE_LEFT]) strbuf_puts(sb, rewrite->part[REWRITE_LEFT]); strbuf_nputs(sb, string + m.rm_so, m.rm_eo - m.rm_so); if (rewrite->part[REWRITE_RIGHT]) strbuf_puts(sb, rewrite->part[REWRITE_RIGHT]); } strbuf_puts(sb, string + m.rm_eo); return (const char *)strbuf_value(sb); } /** * rewrite_cancel: cancel rewriting. * * @param[in] rewrite object */ void rewrite_cancel(REWRITE *rewrite) { if (rewrite->pattern) { free(rewrite->pattern); rewrite->pattern = NULL; } } /** * rewrite_dump: dump rewrite object * * @param[in] rewrite object */ void rewrite_dump(REWRITE *rewrite) { int i; if (rewrite->pattern) fprintf(stdout, "pattern: %s\n", rewrite->pattern); for (i = 0; i < REWRITE_PARTS; i++) { if (rewrite->part[i]) fprintf(stdout, "%d: %s\n", i, rewrite->part[i]); } } /** * rewrite_close: free rewrite object. * * @param[in] rewrite object */ void rewrite_close(REWRITE *rewrite) { if (rewrite->pattern) free(rewrite->pattern); if (rewrite->replace) free(rewrite->replace); free(rewrite); }