正则表达式带回车符引起正则匹配失败

最新推荐文章于 2023-08-17 14:28:08 发布
最新推荐文章于 2023-08-17 14:28:08 发布
阅读量2k 收藏 1
点赞数

前言

在第三方正则工具中可以正常匹配的正则表达式和目标串，到了正式工程中，用regcomp设置正则没问题。但是regexec时，得不到正确的匹配结果。
在排查过程中，写了测试程序, 如果正则较简单，匹配结果正确。如果正则比较复杂，匹配结果不正确。
按照https://baike.baidu.com/item/%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/1700215的说法，将比较高级的正则语法换成等价的比较基本的正则语法. 这下过了.

难道linux的正则库这么衰，不至于啊。
再排查，发现工程中用法是用文本文件中读取一条一条的行，作为一个一个的正则表达式。单步时，打出正则表达式，发现是\n结尾的字符串。就试着在读文件取得正则表达式后，如果是\n结尾，就换成\0结尾，这下清静了. O了。

在解决这个bug的过程中，写了一个测试工具，用来检测写在文本文件中的正则表达式和要检测的目标字符串是否匹配。这样在出问题之前，就可以将正则表达式记录集合所在的文件校验正确，很适合运维的同事更换正则数据文件时用。

工程下载点

src_regex_rule_file_parser.7z

正则记录的数据文件样例

##代表注释
#代表要匹配的字符串
不带#，不带##的行当作正则表达式
每块正则数据之间用空行分开
## @file test_regex_rule.dat

## match
#select * from abc where 1=1
.*\s+[0-9]\s*=\s*[0-9]

## not match
#carry
\b[Cc][Aa][Rr]\b

## match
#carry
\b[Cc][Aa][Rr]

## match
#rycar
[Cc][Aa][Rr]\b

## match
#Hello, someone name is Ben. do you hear me?
Ben

## match
#sales1.xls
sales.

## match
#wsales1.xls
sales.

## match
## regex中 '.'代表一个字符
#wsales1xls
sales.

运行效果

root@debian750devmin:/home/test# ls
总用量 324
-rw-r--r-- 1 root root   1532  8月  8 15:19 ls_regex.cpp
-rw-r--r-- 1 root root    563  7月 17 17:27 ls_regex.h
-rw-r--r-- 1 root root  56784  8月  9 00:41 ls_regex.o
-rw-r--r-- 1 root root   7044  8月  8 17:13 main.cpp
-rw-r--r-- 1 root root 108632  8月  9 00:41 main.o
-rw-r--r-- 1 root root   1302  8月  8 16:14 Makefile
-rw-r--r-- 1 root root   1344 11月 14  2017 my_syslog.cpp
-rw-r--r-- 1 root root   4943  3月 11 15:07 my_syslog.h
-rw-r--r-- 1 root root  18432  8月  9 00:41 my_syslog.o
-rw-r--r-- 1 root root    187  8月  8 16:19 readme.txt
-rwxrwxr-x 1 root root 101111  8月  9 00:41 test_regex*
-rw-r--r-- 1 root root    368  8月  9 00:40 test_regex_rule.dat
root@debian750devmin:/home/test# ./test_regex ./test_regex_rule.dat 
--------------------------------------------------------------------------------
regex_filter = [.*\s+[0-9]\s*=\s*[0-9]]
sz_string_match = [select * from abc where 1=1]
--------------------------------------------------------------------------------
match ok!
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
regex_filter = [\b[Cc][Aa][Rr]\b]
sz_string_match = [carry]
--------------------------------------------------------------------------------
match error
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
regex_filter = [\b[Cc][Aa][Rr]]
sz_string_match = [carry]
--------------------------------------------------------------------------------
match ok!
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
regex_filter = [[Cc][Aa][Rr]\b]
sz_string_match = [rycar]
--------------------------------------------------------------------------------
match ok!
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
regex_filter = [Ben]
sz_string_match = [Hello, someone name is Ben. do you hear me?]
--------------------------------------------------------------------------------
match ok!
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
regex_filter = [sales.]
sz_string_match = [sales1.xls]
--------------------------------------------------------------------------------
match ok!
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
regex_filter = [sales.]
sz_string_match = [wsales1.xls]
--------------------------------------------------------------------------------
match ok!
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
regex_filter = [sales.]
sz_string_match = [wsales1xls]
--------------------------------------------------------------------------------
match ok!
--------------------------------------------------------------------------------

测试工具的工程预览

就按照si中的顺序贴了，不整理了。

// @file ls_regex.cpp

#include <algorithm>

#include "ls_regex.h"

void clear_string(std::string& str)
{
    std::string str_tmp = "";

    str.swap(str_tmp);
}

ls_regex::ls_regex()
{
    m_is_valid_filter = false;
    m_str_filter = "";
    m_str_error = "";
}

ls_regex::~ls_regex()
{
    if (m_is_valid_filter) {
        regfree(&m_reg);
    }
}

void ls_regex::setfilter(const char* psz_filter)
{
    int i_rc = 0;
    char buf[REGEX_BUFFER_SIZE] = {'\0'};

    clear_string(m_str_filter);
    m_str_filter = (NULL != psz_filter) ? psz_filter : "";

    // filter串必须以\0结尾
    std::replace(m_str_filter.begin(), m_str_filter.end(), '\r', '\0');
    std::replace(m_str_filter.begin(), m_str_filter.end(), '\n', '\0');

    if (m_is_valid_filter) {
        regfree(&m_reg);
    }

    m_str_error = "";
    i_rc = regcomp(&m_reg, m_str_filter.c_str(), REG_ICASE | REG_NOSUB | REG_EXTENDED);
    if (REG_NOERROR != i_rc) {
        regerror(i_rc, &m_reg, buf, sizeof(buf));
        m_str_error = buf;
    }

    m_is_valid_filter = (0 == i_rc);
}

std::string ls_regex::get_error_msg()
{
    return m_str_error;
}

bool ls_regex::is_valid_filter()
{
    return m_is_valid_filter;
}

bool ls_regex::is_match(const char* psz_regex)
{
    int i_rc = 0;

    if (NULL == psz_regex) {
        return false; // not match
    }

    if (!m_is_valid_filter) {
        return true; // if filter is invalid or not set, return as match
    }

    i_rc = regexec(&m_reg, psz_regex, 0, NULL, 0);
    return (REG_NOERROR == i_rc);
}


// @file ls_regex.h

#ifndef __LS_REGEX_H__
#define __LS_REGEX_H__

#include <stdlib.h>
#include <stdio.h>
#include <string>
#include <regex.h>

#define REGEX_BUFFER_SIZE   512

class ls_regex {
public:
    ls_regex();
    virtual ~ls_regex();

    void setfilter(const char* psz_filter);
    bool is_match(const char* psz_regex);
    bool is_valid_filter();
    std::string get_error_msg();

private:
    regex_t m_reg;
    std::string m_str_filter;
    bool m_is_valid_filter;
    std::string m_str_error;
};

#endif // #ifndef __LS_REGEX_H__

// @file main.cpp

// view date time
// date "+DATE: %m/%d/%y%nTIME: %H:%M:%S"

// set date time
// date -s "2018-3-13 14:25:00"

#include <stdlib.h>
#include <stdio.h>
// #include <string.h>
#include <string>

#include <syslog.h>
#include <unistd.h>
#include <sys/types.h>
#include <time.h>
#include <vector>

#include "my_syslog.h"
#include "ls_regex.h"

typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long ulong;
typedef unsigned long long ull;

#define LINE80 "--------------------------------------------------------------------------------"

#ifndef SAFE_DELETE
#define SAFE_DELETE(p) \
    if (NULL != (p)) { \
        delete (p); \
        (p) = NULL; \
    }
#endif // #ifndef SAFE_DELETE

typedef enum e_file_read_status {
    e_file_read_status_ready = 1, // 当前状态是准备就绪
    e_file_read_status_over_string_to_match = 2, // 当前状态是读取可以匹配的字符串
    e_file_read_status_over_string_to_filter = 3, // 当前状态是读取正则表达式
}E_FILE_READ_STATUS;

class TAG_REGEX_RULES_UNIT
{
public:
    char sz_string_match[1024];
    char sz_regex_filter[1024];
    ls_regex* p_regex_filter_pattern;

public:
    TAG_REGEX_RULES_UNIT()
    {
        memset(this->sz_string_match, 0, sizeof(this->sz_string_match));
        memset(this->sz_regex_filter, 0, sizeof(this->sz_regex_filter));
        this->p_regex_filter_pattern = new ls_regex();
    }

    virtual ~TAG_REGEX_RULES_UNIT()
    {
        if (NULL != this->p_regex_filter_pattern) {
            delete this->p_regex_filter_pattern;
            this->p_regex_filter_pattern = NULL;
        }
    }
};

bool load_regex_rules_file(const char* psz_file_path_name, std::vector<TAG_REGEX_RULES_UNIT* >& vec_regex_rules);

void init();
void uninit();

int fn_test(int argc, char** argv);

int main(int argc, char** argv)
{
    system("clear");
    init();

    if (2 != argc) {
        printf("usage : this.exe pathname_for_regex_rules_file\n");
    }

    fn_test(argc, argv);
    uninit();

    return EXIT_SUCCESS;
}

/** run result
*/

void init()
{
    ns_syslog::open_syslog("test_new");

    // 设置控制变量中的日志条件, 实际应用中, 是从配置文件读取的控制开关
    ns_syslog::g_log_condition.b_EMERG = false;
    ns_syslog::g_log_condition.b_CRIT = true;
    ns_syslog::g_log_condition.b_ALERT = true;
    ns_syslog::g_log_condition.b_ERR = true;
    ns_syslog::g_log_condition.b_WARNING = true;
    ns_syslog::g_log_condition.b_NOTICE = true;
    ns_syslog::g_log_condition.b_INFO = true;
    ns_syslog::g_log_condition.b_DEBUG = true;

    // 根据控制变量, 设置日志的mask
    // 在实际应用中, 这里可以是动态设置, e.g. 配置文件检测线程发现配置变了, 需要变更某些级别的日志记录结果
    ns_syslog::set_log_level(
        ns_syslog::g_log_condition.b_EMERG, 
        ns_syslog::g_log_condition.b_ALERT,
        ns_syslog::g_log_condition.b_CRIT,
        ns_syslog::g_log_condition.b_ERR,
        ns_syslog::g_log_condition.b_WARNING,
        ns_syslog::g_log_condition.b_NOTICE,
        ns_syslog::g_log_condition.b_INFO,
        ns_syslog::g_log_condition.b_DEBUG);
}

void uninit()
{
    ns_syslog::close_syslog();
}

int fn_test(int argc, char** argv)
{
    std::vector<TAG_REGEX_RULES_UNIT* > vec_regex_rules;
    std::vector<TAG_REGEX_RULES_UNIT* >::iterator it;
    TAG_REGEX_RULES_UNIT* p_tmp = NULL;

    if (2 != argc) {
        return EXIT_FAILURE;
    }

    if (load_regex_rules_file(argv[1], vec_regex_rules)) {
        for (it = vec_regex_rules.begin(); it != vec_regex_rules.end(); it++) {
            // test rules for match
            p_tmp = *it;
            if ((NULL != p_tmp) && (NULL != p_tmp->p_regex_filter_pattern)) {
                printf("%s\n", LINE80);
                printf("regex_filter = [%s]\n", p_tmp->sz_regex_filter);
                printf("sz_string_match = [%s]\n", p_tmp->sz_string_match);
                printf("%s\n", LINE80);
                if (p_tmp->p_regex_filter_pattern->is_match(p_tmp->sz_string_match)) {
                    printf("match ok!\n");
                } else {
                    printf("match error\n");
                    // https://baike.baidu.com/item/%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/1700215
                    // try to fix, if fixed ok, show user the filter after fix
                }
                printf("%s\n", LINE80);
            }
        }
    }

    // clear vec_regex_rules
    for (it = vec_regex_rules.begin(); it != vec_regex_rules.end(); it++) {
        p_tmp = *it;
        SAFE_DELETE(p_tmp);
        *it = NULL;
    }

    vec_regex_rules.clear();

    return EXIT_SUCCESS;
}

bool load_regex_rules_file(const char* psz_file_path_name, std::vector<TAG_REGEX_RULES_UNIT* >& vec_regex_rules)
{
    bool b_rc = false;
    bool error_happen = false;
    FILE* pf = NULL;
    char buf[1024] = {'\0'};
    char* line = NULL;
    int line_len = 0;
    TAG_REGEX_RULES_UNIT* p_regex_rules = NULL;
    // char* psz_tmp = NULL;

    // 文件格式 : 文件块(#可以匹配的字符串, 正则表达式，空行) * N
    // e.g.
    // #后面直接带可以匹配的字符串
    // #hello, word
    // [a-z]
    // 
    E_FILE_READ_STATUS cur_status = e_file_read_status_ready;

    do {
        if (NULL == psz_file_path_name) {
            break;
        }

        pf = fopen(psz_file_path_name, "r");
        if (NULL == pf) {
            error_happen = true;
            break;
        }

        while (1) {
            memset(buf, 0, sizeof(buf));
            line = fgets(buf, sizeof(buf) - 1, pf);
            if (NULL == line) {
                break;
            }

            line_len = strlen(line);

            // 去掉读回行的回车
            if (line_len > 0) {
                switch (line[line_len - 1]) {
                    case '\r':
                    case '\n':
                        line[line_len - 1] = '\0';
                        line_len--;
                        break;

                    default:
                        break;
                }
            }

            switch (cur_status) {
                case e_file_read_status_ready: {
                    if (NULL == p_regex_rules) {
                        p_regex_rules = new TAG_REGEX_RULES_UNIT();
                    }

                    // read_status_string_to_match
                    if (NULL != p_regex_rules) {
                        if (line_len < 2) {
                            break;
                        }

                        if (buf[0] == '#') {
                            if (buf[1] == '#') {
                                // ## xxx 是注释
                                break;
                            }

                            // #xxx 是要匹配的串
                            strcpy(p_regex_rules->sz_string_match, buf + 1);
                            cur_status = e_file_read_status_over_string_to_match;
                        }
                    }
                }
                break;

                case e_file_read_status_over_string_to_match: {
                    if (NULL != p_regex_rules) {
                        if ((buf[0] != '#') && (line_len > 0)) {
                            strcpy(p_regex_rules->sz_regex_filter, buf);

                            if (NULL != p_regex_rules->p_regex_filter_pattern) {
                                p_regex_rules->p_regex_filter_pattern->setfilter(p_regex_rules->sz_regex_filter);
                                if (!p_regex_rules->p_regex_filter_pattern->is_valid_filter()) 
                                {
                                    MYLOG_E("p_regex_rules->sz_string_match = [%s], regcomp error %s",
                                        p_regex_rules->sz_string_match,
                                        p_regex_rules->p_regex_filter_pattern->get_error_msg().c_str());

                                    SAFE_DELETE(p_regex_rules);
                                } else {
                                    vec_regex_rules.push_back(p_regex_rules);
                                    p_regex_rules = NULL;
                                }

                                cur_status = e_file_read_status_over_string_to_filter;
                            }
                        }
                    }
                }
                break;

                case e_file_read_status_over_string_to_filter: {
                    if (line_len <= 0) {
                        cur_status = e_file_read_status_ready;
                    }
                }
                break;

                default:
                    break;
            }
        }

        fclose(pf);
        pf = NULL;

        b_rc = (false == error_happen);
    } while (0);

    SAFE_DELETE(p_regex_rules);

    return b_rc;
}



# ==============================================================================
# @file makefile
# ==============================================================================

BIN = test_regex
LINE80 = --------------------------------------------------------------------------------
CC = g++ -std=c++98
CFLAGS = -Wall -g
INC = -I. 

LIBS = -lstdc++ -pthread -lpthread -lm -fPIC
LIBPATH = -L/usr/lib/ -L/usr/local/lib/ -L./lib/

SHLIBS = 

DEPEND_CODE_DIR = ./empty_dir \

DEPEND_CODE_SRC = $(shell find $(DEPEND_CODE_DIR) -name '*.cpp')
DEPEND_CODE_OBJ = $(DEPEND_CODE_SRC:.cpp=.o)

ROOT_CODE_SRC = $(shell find ./ -name '*.cpp')
ROOT_CODE_OBJ = $(ROOT_CODE_SRC:.cpp=.o)

SUB_CODE_DIR = ./socket_easy
SUB_CODE_SRC = $(shell find $(SUB_CODE_DIR) -name '*.cpp')
SUB_CODE_OBJ = $(SUB_CODE_SRC:.cpp=.o)

clean:
    clear
    @echo $(LINE80)
    @echo make clean
    rm -f $(BIN) $(ROOT_CODE_OBJ) $(DEPEND_CODE_OBJ) $(SUB_CODE_OBJ)
    rm -rf /usr/lib/$(BIN)
    rm -rf ./$(BIN)

all:$(BIN)
    @echo $(LINE80)
    @echo make all
    chmod 777 $(BIN)
    find . -name $(BIN)

$(BIN) : $(ROOT_CODE_OBJ) $(DEPEND_CODE_OBJ) $(SUB_CODE_OBJ)
    $(CC) $(CFLAGS) -o $@ $^ $(SHLIBS) $(INC) $(LIBPATH) $(LIBS)

.cpp.o:
    $(CC) -c $(CFLAGS) $^ -o $@ $(INC) $(LIBPATH) $(LIBS)

rebuild:
    make clean
    @echo $(LINE80)
    make all
    chmod 775 ./$(BIN)


// @file my_syslog.cpp
// @brief syslog日志宏的实现

#include "my_syslog.h"

namespace ns_syslog {

TAG_LOG_CONDITION g_log_condition;

void open_syslog(const char* pszLogOwner)
{
    openlog(((NULL != pszLogOwner) ? pszLogOwner : "my_syslog"), LOG_NOWAIT | LOG_PID, LOG_LOCAL1);
}

void set_log_level(
    bool b_EMERG,
    bool b_CRIT,
    bool b_ALERT,
    bool b_ERR,
    bool b_WARNING,
    bool b_NOTICE,
    bool b_INFO,
    bool b_DEBUG)
{
    int i_mask = 0;

    if (b_EMERG) {
        // LOG_EMERG 日志会阻塞控制台程序, 必须要使这个条件为false, 不能执行这里
        // LOG_EMERG 不仅是记录到日志, 还打印到正在运行的程序上, 阻塞了程序的执行. 不能用这种日志
        i_mask |= LOG_MASK(LOG_EMERG);    
    }

    if (b_ALERT) {
        i_mask |= LOG_MASK(LOG_ALERT);
    }

    if (b_CRIT) {
        i_mask |= LOG_MASK(LOG_CRIT);
    }

    if (b_ERR) {
        i_mask |= LOG_MASK(LOG_ERR);
    }

    if (b_WARNING) {
        i_mask |= LOG_MASK(LOG_WARNING);
    }

    if (b_NOTICE) {
        i_mask |= LOG_MASK(LOG_NOTICE);
    }

    if (b_INFO) {
        i_mask |= LOG_MASK(LOG_INFO);
    }

    if (b_DEBUG) {
        i_mask |= LOG_MASK(LOG_DEBUG);
    }

    setlogmask(i_mask);
}

void close_syslog()
{
    closelog();
}

} // namespace ns_syslog {


// @file my_syslog.h
// @brief syslog日志宏的定义

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <syslog.h>
#include <unistd.h>
#include <sys/types.h>

namespace ns_syslog {

typedef struct _tag_log_condition {
    bool b_EMERG;
    bool b_ALERT;
    bool b_CRIT;
    bool b_ERR;

    bool b_WARNING;
    bool b_NOTICE;
    bool b_INFO;
    bool b_DEBUG;

    _tag_log_condition() {
        b_EMERG = false;
        b_ALERT = false;
        b_CRIT = false;
        b_ERR = false;

        b_WARNING = false;
        b_NOTICE = false;
        b_INFO = false;
        b_DEBUG = false;
    }
} TAG_LOG_CONDITION;

extern TAG_LOG_CONDITION g_log_condition;

// ----------------------------------------------------------------------------
// syslog macro
// ----------------------------------------------------------------------------

#define MYLOG_EMERG(fmt, ...) \
if (ns_syslog::g_log_condition.b_EMERG) { \
syslog(LOG_EMERG, "[%s : %s.%d : %s()] : " fmt, "EMERG", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
}

#define MYLOG_EM(fmt, ...) \
if (ns_syslog::g_log_condition.b_EMERG) { \
syslog(LOG_INFO, "[%s : %s.%d : %s()] : " fmt, "EMERG", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
}

// ----------------------------------------------------------------------------

#define MYLOG_ALERT(fmt, ...) \
if (ns_syslog::g_log_condition.b_ALERT) { \
syslog(LOG_ALERT, "[%s : %s.%d : %s()] : " fmt, "ALERT", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
}

#define MYLOG_A(fmt, ...) \
if (ns_syslog::g_log_condition.b_ALERT) { \
syslog(LOG_INFO, "[%s : %s.%d : %s()] : " fmt, "ALERT", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
}

// ----------------------------------------------------------------------------

#define MYLOG_CRIT(fmt, ...) \
if (ns_syslog::g_log_condition.b_CRIT) { \
syslog(LOG_CRIT, "[%s : %s.%d : %s()] : " fmt, "CRIT", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
}

#define MYLOG_C(fmt, ...) \
if (ns_syslog::g_log_condition.b_CRIT) { \
syslog(LOG_INFO, "[%s : %s.%d : %s()] : " fmt, "CRIT", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
}

// ----------------------------------------------------------------------------

#define MYLOG_ERR(fmt, ...) \
if (ns_syslog::g_log_condition.b_ERR) { \
syslog(LOG_ERR, "[%s : %s.%d : %s()] : " fmt, "ERR", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
}

#define MYLOG_E(fmt, ...) \
if (ns_syslog::g_log_condition.b_ERR) { \
syslog(LOG_INFO, "[%s : %s.%d : %s()] : " fmt, "ERR", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
}

// ----------------------------------------------------------------------------

#define MYLOG_WARNING(fmt, ...) \
if (ns_syslog::g_log_condition.b_WARNING) { \
syslog(LOG_WARNING, "[%s : %s.%d : %s()] : " fmt, "WARNING", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
}

#define MYLOG_W(fmt, ...) \
if (ns_syslog::g_log_condition.b_WARNING) { \
syslog(LOG_INFO, "[%s : %s.%d : %s()] : " fmt, "WARNING", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
}

// ----------------------------------------------------------------------------

#define MYLOG_NOTICE(fmt, ...) \
if (ns_syslog::g_log_condition.b_NOTICE) { \
syslog(LOG_NOTICE, "[%s : %s.%d : %s()] : " fmt, "NOTICE", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
}

#define MYLOG_N(fmt, ...) \
if (ns_syslog::g_log_condition.b_NOTICE) { \
syslog(LOG_INFO, "[%s : %s.%d : %s()] : " fmt, "NOTICE", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
}

// ----------------------------------------------------------------------------

#define MYLOG_INFO(fmt, ...) \
if (ns_syslog::g_log_condition.b_INFO) { \
syslog(LOG_INFO, "[%s : %s.%d : %s()] : " fmt, "INFO", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
}

#define MYLOG_I(fmt, ...) \
if (ns_syslog::g_log_condition.b_INFO) { \
syslog(LOG_INFO, "[%s : %s.%d : %s()] : " fmt, "INFO", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
}

// ----------------------------------------------------------------------------

#define MYLOG_DEBUG(fmt, ...) \
if (ns_syslog::g_log_condition.b_DEBUG) { \
syslog(LOG_DEBUG, "[%s : %s.%d : %s()] : " fmt, "DEBUG", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
}

#define MYLOG_D(fmt, ...) \
if (ns_syslog::g_log_condition.b_DEBUG) { \
syslog(LOG_INFO, "[%s : %s.%d : %s()] : " fmt, "DEBUG", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
}

// ----------------------------------------------------------------------------

void open_syslog(const char* pszLogOwner);
void set_log_level(
    bool b_EMERG = false,
    bool b_CRIT = false,
    bool b_ALERT = false,
    bool b_ERR = false,
    bool b_WARNING = false,
    bool b_NOTICE = false,
    bool b_INFO = false,
    bool b_DEBUG = false);
void close_syslog();

} // namespace ns_syslog {


// readme.txt 正则表达式从文件中读出来时, 带\n结尾, 如果直接regcomp，regcomp不报错, 但是regexec时, 本来匹配的正则表达式和目标字符串, 变成不匹配了
所以，如果正则表达式是从文件中读出时，要过滤一下\r\n 
## @file test_regex_rule.dat

## match
#select * from abc where 1=1
.*\s+[0-9]\s*=\s*[0-9]

## not match
#carry
\b[Cc][Aa][Rr]\b

## match
#carry
\b[Cc][Aa][Rr]

## match
#rycar
[Cc][Aa][Rr]\b

## match
#Hello, someone name is Ben. do you hear me?
Ben

## match
#sales1.xls
sales.

## match
#wsales1.xls
sales.

## match
## regex中 '.'代表一个字符
#wsales1xls
sales.
LostSpeed
关注
Python中的正则表达式(Regex匹配,贪婪匹配Greedy Matching)
kirsten111111的博客
11-05 3895
•正则表达式（regex）是描述一组字符串的模式匹配过程测试给定字符串是否与模式匹配,也可以修改字符串.例如,通过替换子串或将其拆分为子串•正则表达式是一种功能强大的编程工具，广泛用于计算/文本处理（例如）在Perl、Tcl/Tk、Java、grep、sed、awk、vi、emacs、lex中找到但请注意，regex语法各不相同•许多应用-一些随机示例：从一组网页中删除html;从程序中提取注释块（例如构建文档）;检查文档中的双字（“the”、“here here”）
JS 正则表达式（正则匹配RegExp）
XSL_HR的博客
04-17 4969
一篇文章带你学会JS正则匹配
java正则表达式(.*):不能匹配回车…
业余码农
03-13 1896
1: public static void main(String[] args) { 2: String regex1="a((.||(\r\n))*)b"; 3: //如果是regex1="a(.*)b";不能匹配str，因为API文档中说"."匹配 4: //Any character (may or may not match line terminators
正则表达式匹配 带有特殊字符的字符串失败（特殊字符指： . ? + $ ^ [ ] ( ) { } | \ / ）
weixin_46611729的博客
12-18 3492
特殊字符有： . ? + $ ^ [ ] ( ) { } | \ / 匹配不成功的示例： const str = '(hehe)43' const reg = new RegExp(str,'gi') // reg : /(hehe)43/ 括号未做转义处理 console.log(reg.test(str)) // 结果是 false 匹配不成功的原因：str 中的字符串中的特殊字符没有做转义处理 如果想匹配成功，就要先对str中的特殊字符做转义处理 匹配成功的示例： const str = '(
正则表达式的一个坑--[.\n]无效引起的血案
weixin_30755393的博客
10-10 225
网上很多教程和一些手册都是这么描述： . 匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。 可是在[]里面的.会单纯的变成匹配.这个符号本身 而不是除\n之外的任何单个字符 因此[.\n]无效（可能有的解释器有效？） 匹配包括'\n'在内任意单个字符更保险的方式是用 [\s\S][\d\D][\w\W]等方式（感谢然然无...
Python采集网页时正则表达式匹配换行符的问题
热门推荐
在路上。。。的专栏
10-11 2万+
p1 = r'(?)(.*?)(?=)' 这样采集html时出错，采集不到数据，正则中 . 是不能匹配换行符， 改成如下： p1 = r'(?)([\s\S]*?)(?=)' # 这是我们写的正则表达式规则，你现在可以不理解啥意思 [\s\S] \s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。
记录一个python的正则匹配不到的事情
街道口扛把子的博客
04-25 1270
昨天在改一个图片爬虫（python）的时候，遇到了一个正则表达式匹配不到的链接，这里我要去匹配“Collection”这个单词。 刚开始以为是正则表达式不对，但是改了好几次还是同样的结果，去匹配其他单词，可以匹配到其他相应的链接。 后来用其他网址进行尝试，“Collection”是可以匹配到的，所以判断正则没有问题。 然后把html存了下来再进行反复测试。 最后发现，，，是因为正则里的“.”（点...
动态路由的实现—正则表达式
weixin_44545838的博客
08-17 1487
动态路由有很多种实现方式，支持的规则、性能等有很大的差异。例如开源的路由实现gorouter支持在路由规则中嵌入正则表达式，例如/p/[0-9A-Za-z]+，即路径中的参数仅匹配数字和字母。最近在看cpp-httplib源码的时候，发现这个开源库是也是利用正则化来实现动态路由的。本文就来总结httplib是如何利用正则表达式来进行动态路由的，正则表达式是一种用于描述字符串模式的工具。它由一系列字符和特殊字符组成，可以用来匹配、搜索、替换和提取字符串中的特定模式。
正则表达式详解
langmanboy的博客
04-10 1686
正则表达式 在 JavaScript 中，正则表达式通过内建的 RegExp 类的对象来实现，并与字符串集成 正则表达式是用于匹配字符串中字符组合的模式，在 JavaScript 中，正则表达式也是对象 这些模式被用于 RegExp的 exec 和 test 方法, 以及 String 的 match、matchAll 、replace、search 和 split 方法 1. 正则创建与属性 创建一个正则表达式对象有两种语法 字面量创建 对象创建 1-1 字面量创建 使用一个正则表达式字面量，其由包含
暂时解决正则表达式中正向否定预查无法匹配\n换行符的问题
qq_39003179的博客
09-27 647
System.out.println("找到了");System.out.println("未找到");预查中不能匹配到\n，如果想匹配\n可以使用如下方法。
Java @Partten 正则表达式匹配错误
weixin_44155462的博客
05-07 691
显示成功反射出firstLetter数值，依旧被Valid拦截抛出错误
正则表达式下\n问题
qq_41638126的博客
08-04 4508
正则表达式下\n问题 学习中用到Tesseract识别一串字符后得到： 然后用这样一个正则去匹配： 一直匹配不到，后面想想可能是\n问题，将\n删掉后就成功了； 后面理解可能是：点号“.”遇到了换行是不是直接就去识别下一行了，所以 “.” 遇到 \r\n 就匹配失败 尝试使用多行模式，但是失败了 ...
正则表达式中跨行匹配问题
Great haste makes great waste
06-15 1万+
在学习Python写爬虫时用到正则表达式是必然的，因此有效掌握正则表达式这门神器会使我们爬虫工作如鱼得水，不过在成长为大神之前还是有很多弯路要走，希望自己一路打怪升级早日成为大神。 闲话少叙，今天写爬虫的时候发现要匹配一个跨很多很多行的内容，之前是(.+?)在手，爬虫我有，不过这次这个神匹配也不好使了，查了点资料，发现是（.）不能匹配跨行内容，ok，上利器，[\s\S]* or [\w\W]*
VS2010中使用正则表达式替换时无法使用回车符的解决方法
weixin_30414245的博客
02-28 193
在VS2010使用正则表达式替换时： 查找框使用\n有效，使用\r\n无效。 替换框使用\n有效，使用\r\n无效。 现象为：只出现“t+换行符”，多了一个字符t，保存后在打开IDE提示“行尾不一致，需要行尾标准化” 办法：查找框使用“\n”，替换框使用“\x000D\n”，问题解决。 转载于:https://www.cnblogs.com/benleilei/arc...
js正则匹配遇到换行符的问题
qq_17285877的博客
03-17 4815
js正则匹配遇到换行符的问题问题描述问题解决 问题描述 在项目中读取了一个导出json的js文件（由于一些原因这里没有使用import），在用正则匹配出里面的json时出现问题，没有获得预期的效果，匹配的结果是个null。 message = new Function('return ' + /(?<=const).*(?=export)/.exec(message.toString())[...
正则表达式匹配中文，匹配不到？
JOB66的博客
08-17 1116
第一种，较为常用但是，有些双字节有时匹配不到 [\u4e00-\u9fa5] 第二种，好记，字符包含常用的7k个中文字符，大多数情况都没啥问题 [一-龟]
正则匹配换行符的坑
未来的路
12-01 511
今天写了个脚本，但发现始终有问题，最后锁定到了if中的正则匹配。 []不支持正则，[[]]才可 匹配符是=~，而不是~= 网上搜资料，说的是=~后面不能用引号，但直接写模式也有问题，所以就只能用变量保存模式，在调用变量。 eg : patter="^[ \t\n]*" if [[ $user =~ $patter ]] ...
正则表达式re.sub()常见问题及解决(换行匹配+标签清洗)
python小辣鸡的逆袭
05-07 1万+
首先大家都知道re.sub()简单用法: #re.sub()会替换满足条件的所有式子，返回被替换后的文本 text = "阅读量 9999, 点赞量 7788" ret_sub = re.sub(r'\d+', '8800', text) 结果： 阅读量 8800, 点赞量 8800 但是有陷阱:这个例子之所以匹配全部成功是因为它所检查的是'\d',也就是数字格式，遇到不是数...
正则表达式中回车换行
最新发布
11-22
正则表达式中回车换行可以用特殊字符来表示。其中，回车用\r表示，换行用\n表示。如果需要同时匹配回车和换行，可以使用\r\n表示。在正则表达式中，可以使用这些特殊字符来匹配文本中的回车和换行符。 例如，如果需要匹配一个以回车换行结尾的字符串，可以使用以下正则表达式： ``` pattern = r'.*\r\n' ``` 这个正则表达式中，.*表示匹配任意字符（除了换行符）0次或多次，\r\n表示匹配回车换行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值