cline: src/regex_parser.c@68018eac46c3

     1 /*

     2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

     3  * Copyright 2018 Mike Becker. All rights reserved.

     4  *

     5  * Redistribution and use in source and binary forms, with or without

     6  * modification, are permitted provided that the following conditions are met:

     7  *

     8  * 1. Redistributions of source code must retain the above copyright

     9  * notice, this list of conditions and the following disclaimer.

    10  *

    11  * 2. Redistributions in binary form must reproduce the above copyright

    12  * notice, this list of conditions and the following disclaimer in the

    13  * documentation and/or other materials provided with the distribution.

    14  *

    15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

    16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    18  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

    19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

    20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

    21  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

    22  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

    23  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    25  */

    27 #include "regex_parser.h"

    29 regex_parser_t* new_regex_parser_t() {

    30   regex_parser_t* ret = malloc(sizeof(regex_parser_t));

    31   if (ret != NULL) {

    32     ret->pattern_list = new_string_list_t();

    33     ret->matched_lines = 0;

    34     ret->pattern_match = 0;

    35     ret->compiled_patterns = NULL;

    36     ret->compiled_pattern_count = 0;

    37   }

    38   return ret;

    39 }

    41 void regex_parser_reset(regex_parser_t* parser) {

    42   parser->pattern_match = parser->matched_lines = 0;

    43 }

    45 void regex_destcomppats(regex_parser_t* parser) {

    46   if (parser->compiled_patterns != NULL) {

    47     for (int i = 0 ; i < parser->compiled_pattern_count ; i++) {

    48       if (parser->compiled_patterns[i] != NULL) {

    49         free(parser->compiled_patterns[i]);

    50       }

    51     }

    52     free(parser->compiled_patterns);

    53     parser->compiled_patterns = NULL;

    54     parser->compiled_pattern_count = 0;

    55   }

    56 }

    58 void destroy_regex_parser_t(regex_parser_t* parser) {

    59   regex_destcomppats(parser);

    60   destroy_string_list_t(parser->pattern_list);

    61   free(parser);

    62 }

    64 bool regex_parser_matching(regex_parser_t* parser) {

    65   return parser->pattern_match > 0;

    66 }

    68 int regex_parser_do(regex_parser_t* parser, char* input) {

    69   int err = REG_NOMATCH;

    70   if (parser->compiled_pattern_count > 0) {

    71     regmatch_t match;

    73     if (regex_parser_matching(parser)) {

    74       parser->matched_lines++;

    76       err = regexec(parser->compiled_patterns[parser->pattern_match],

    77           input, 1, &match, 0);

    78       if (err > 0 && err != REG_NOMATCH) {

    79         fprintf(stderr, "Regex-Error: 0x%08x", err);

    80       }

    81       if (err == 0) {

    82         parser->pattern_match = 0;

    83         /* do not match line, if it does not end with the pattern */

    84         if (match.rm_eo < strlen(input)) {

    85           parser->matched_lines--;

    86         }

    87       }

    88     } else {

    89       for (int i = 0 ; i < parser->compiled_pattern_count - 1 ; i += 2) {

    90         err = regexec(parser->compiled_patterns[i], input, 1, &match, 0);

    91         if (err > 0 && err != REG_NOMATCH) {

    92           fprintf(stderr, "Regex-Error: 0x%08x", err);

    93         }

    94         if (err == 0) {

    95           parser->pattern_match = i+1;

    96           parser->matched_lines = 0;

    97           /* Check, if end pattern is also in this line */

    98           regex_parser_do(parser, input);

    99           /* do not match line, if it does not start with the pattern */

   100           if (match.rm_so > 0 && parser->matched_lines > 0) {

   101             parser->matched_lines--;

   102           }

   103           break;

   104         }

   105       }

   106     }

   107   }

   108   return err;

   109 }

   111 bool regex_compile_all(regex_parser_t* parser) {

   112   bool success = true;

   113   size_t pcount = parser->pattern_list->count;

   114   if (pcount > 0) {

   115     regex_destcomppats(parser);

   116     parser->compiled_patterns = calloc(pcount, sizeof(regex_t));

   117     parser->compiled_pattern_count = pcount;

   119     regex_t* re;

   120     for (int i = 0 ; i < pcount ; i++) {

   121       re = malloc(sizeof(regex_t));

   122       if (regcomp(re, parser->pattern_list->items[i], REG_EXTENDED) == 0) {

   123         parser->compiled_patterns[i] = re;

   124       } else {

   125         fprintf(stderr, "Cannot compile pattern: %s\n",

   126             (parser->pattern_list->items[i]));

   127         parser->compiled_patterns[i] = NULL;

   128         success = false;

   129       }

   130     }

   131   }

   132   return success;

   133 }

Mercurial > hg > cline / file revision