static void strlist_free(struct strlist *strlist)
{
if(!strlist) return;
regex_free(&strlist->re);
free_w(&strlist->path);
free_v((void **)&strlist);
}
// Finds all tracks that match the given pattern.
//
// Prints track number and title.
void find_track_regex(char pattern[])
{
int i;
Regex *regex = make_regex(pattern, REG_EXTENDED | REG_NOSUB);
for (i=0; i<NUM_TRACKS; i++) {
if (regex_match(regex, tracks[i])) {
printf("Track %i: '%s'\n", i, tracks[i]);
}
}
regex_free(regex);
}
regex_t *regex_compile(const char *str)
{
regex_t *regex=NULL;
if((regex=(regex_t *)malloc_w(sizeof(regex_t), __func__))
&& !regcomp(regex, str, REG_EXTENDED
#ifdef HAVE_WIN32
// Give Windows another helping hand and make the regular expressions
// case insensitive.
| REG_ICASE
#endif
)) return regex;
regex_free(®ex);
return NULL;
}
int main(int argc, char **argv) {
FILE *f = fopen(argv[1], "r");
if (!f) {
fprintf(stderr, "Could not open tests\n");
exit(1);
}
int passed = 0,
failed = 0,
warning = 0;
regex_t *re = NULL;
char *re_str;
ssize_t len;
char *line = NULL;
size_t linecap = 0;
while ((len = getline(&line, &linecap, f)) > 0) {
if (line[len - 1] == '\n') {
line[len - 1] = 0;
--len;
}
if (strncmp(line, "regex ", 6) == 0) {
if (re) {
regex_free(re);
free(re_str);
}
re = regex_compile(line + 6);
if (!re) {
fprintf(stderr, "FAIL: /%s/ did not compile\n", line + 6);
++failed;
} else {
re_str = strdup(line + 6);
++passed;
}
} else if (strncmp(line, "noregex ", 8) == 0) {
if (re) {
regex_free(re);
free(re_str);
}
re = regex_compile(line + 8);
if (re) {
regex_free(re);
re = NULL;
fprintf(stderr, "FAIL: /%s/ did compile\n", line + 8);
++failed;
} else {
++passed;
}
} else if (strncmp(line, "match ", 6) == 0) {
if (!re) {
fprintf(stderr, "WARN: no regular expression for 'match'\n");
++warning;
} else {
if (!regex_match(re, line + 6)) {
fprintf(stderr, "FAIL: /%s/ should match %s\n", re_str, line + 6);
++failed;
} else {
++passed;
}
}
} else if (strncmp(line, "differ ", 7) == 0) {
if (!re) {
fprintf(stderr, "WARN: no regular expression for 'differ'\n");
++warning;
} else {
if (regex_match(re, line + 7)) {
fprintf(stderr, "FAIL: /%s/ should not match %s\n", re_str, line + 7);
++failed;
} else {
++passed;
}
}
} else if (strcmp(line, "matchnewline") == 0) {
if (!re) {
fprintf(stderr, "WARN: no regular expression for 'matchnewline'\n");
++warning;
} else {
if (!regex_match(re, "\n")) {
fprintf(stderr, "FAIL: /%s/ should match newline\n", re_str);
++failed;
} else {
++passed;
}
}
} else if (strcmp(line, "differnewline") == 0) {
if (!re) {
fprintf(stderr, "WARN: no regular expression for 'differnewline'\n");
++warning;
} else {
if (regex_match(re, "\n")) {
fprintf(stderr, "FAIL: /%s/ should not match newline\n", re_str);
++failed;
} else {
++passed;
}
}
} else if (len > 0 && line[0] != '#') {
fprintf(stderr, "WARN: unknown line: %s\n", line);
++warning;
}
}
fclose(f);
if (re) {
regex_free(re);
free(re_str);
}
if (line) {
free(line);
}
printf("%d passed, %d failed", passed, failed);
if (warning) {
printf(", %d warning%s", warning, warning == 1 ? "" : "s");
}
printf("\n");
return failed > 0 || warning > 0;
}
void list_server_free(void)
{
bu_list_free(&bu_list);
regex_free(®ex);
}
void free_term(TERM* term)
{
TERM_STRING* next;
TERM_STRING* tmp;
int i, count;
switch(term->type)
{
case TERM_TYPE_STRING:
next = ((TERM_STRING*) term)->next;
while (next != NULL)
{
tmp = next->next;
yr_free(next);
next = tmp;
}
break;
case TERM_TYPE_STRING_AT:
free_term(((TERM_STRING*)term)->offset);
break;
case TERM_TYPE_STRING_OFFSET:
free_term(((TERM_STRING*)term)->index);
break;
case TERM_TYPE_STRING_IN_RANGE:
free_term(((TERM_STRING*)term)->range);
break;
case TERM_TYPE_STRING_IN_SECTION_BY_NAME:
yr_free(((TERM_STRING*)term)->section_name);
break;
case TERM_TYPE_STRING_MATCH:
regex_free(&(((TERM_STRING_OPERATION*)term)->re));
break;
case TERM_TYPE_STRING_CONTAINS:
yr_free(((TERM_STRING_OPERATION*)term)->string);
break;
case TERM_TYPE_AND:
case TERM_TYPE_OR:
case TERM_TYPE_ADD:
case TERM_TYPE_SUB:
case TERM_TYPE_MUL:
case TERM_TYPE_DIV:
case TERM_TYPE_MOD:
case TERM_TYPE_GT:
case TERM_TYPE_LT:
case TERM_TYPE_GE:
case TERM_TYPE_LE:
case TERM_TYPE_EQ:
case TERM_TYPE_OF:
case TERM_TYPE_NOT_EQ:
case TERM_TYPE_SHIFT_LEFT:
case TERM_TYPE_SHIFT_RIGHT:
case TERM_TYPE_BITWISE_OR:
case TERM_TYPE_BITWISE_XOR:
case TERM_TYPE_BITWISE_AND:
free_term(((TERM_BINARY_OPERATION*)term)->op1);
free_term(((TERM_BINARY_OPERATION*)term)->op2);
break;
case TERM_TYPE_NOT:
case TERM_TYPE_BITWISE_NOT:
case TERM_TYPE_INT8_AT_OFFSET:
case TERM_TYPE_INT16_AT_OFFSET:
case TERM_TYPE_INT32_AT_OFFSET:
case TERM_TYPE_UINT8_AT_OFFSET:
case TERM_TYPE_UINT16_AT_OFFSET:
case TERM_TYPE_UINT32_AT_OFFSET:
free_term(((TERM_UNARY_OPERATION*)term)->op);
break;
case TERM_TYPE_RANGE:
free_term(((TERM_RANGE*)term)->min);
free_term(((TERM_RANGE*)term)->max);
free_term((TERM*) ((TERM_RANGE*)term)->current);
break;
case TERM_TYPE_VECTOR:
count = ((TERM_VECTOR*)term)->count;
for (i = 0; i < count; i++)
{
free_term(((TERM_VECTOR*)term)->items[i]);
}
break;
case TERM_TYPE_INTEGER_FOR:
free_term(((TERM_INTEGER_FOR*)term)->count);
free_term(((TERM_INTEGER_FOR*)term)->expression);
free_term((TERM*) ((TERM_INTEGER_FOR*)term)->items);
break;
case TERM_TYPE_STRING_FOR:
free_term(((TERM_TERNARY_OPERATION*)term)->op1);
free_term(((TERM_TERNARY_OPERATION*)term)->op2);
free_term(((TERM_TERNARY_OPERATION*)term)->op3);
break;
}
yr_free(term);
}
