#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>

//regex
#include <regex.h>


//cns_reg函式的返回型別
typedef struct _reg_rtn_struct
{
   int rtn;       //成功與否標誌0 成功， 1失敗
   int pstart;    //匹配到的子串開始位移
   int pend;      //匹配到的子串尾部位移
} reg_rtn_struct;


/**
*
* 正則表示式查詢函式
*/
reg_rtn_struct cns_reg(const char *str,  const char *pattern)
{
    reg_rtn_struct reg_rtn_struct_var;

    int          z;            //status
    int          pos;          //配置處的位置
    int          cflags = REG_EXTENDED;   //compile flags
    regex_t      reg;          //compiled regular expression
    char         ebuf[128];    //error buffer
    bzero(ebuf, sizeof(ebuf));
    regmatch_t   pm[10];       //pattern matches 0-9
    bzero(pm, sizeof(pm));
    const size_t nmatch = 10;  //The size of array pm[]

    //編譯正則表示式
    /**
     *
     * @param const char*  pattern         將要被編譯的正則表示式
     * @param regex_t*     reg             用來儲存編譯結果
     * @param int          cflags          決定正則表示式將如何被處理的細節
     *
     * @return  success    int        0    並把編譯結果填充到reg結構中
     *          fail       int        非0
     *
     */


    z = regcomp(&reg, (const char*)pattern, cflags);

    if(z)   //此處為 if(z != 0), 因為C語言裡0永遠為非(False), 任何非0值都為真(True)
    {
       regerror(z, &reg, ebuf, sizeof(ebuf));
       perror("reg1");
       fprintf(stderr, "%s: pattern '%s'\n", ebuf, pattern);
       reg_rtn_struct_var.rtn    = 1;
       reg_rtn_struct_var.pstart = -1;
       reg_rtn_struct_var.pend   = -1;

       regfree(&reg);
       return reg_rtn_struct_var;
    }

    /**
     *
     * reg     指向編譯後的正則表示式
     * str     指向將要進行匹配的字串
     * pm      str字串中可能有多處和正則表示式相匹配， pm陣列用來儲存這些位置
     * nmacth  指定pm陣列最多可以存放的匹配位置數
     *
     * @return 函式匹配成功後，str+pm[0].rm_so到str+pm[0].rm_eo是第一個匹配的子串
     *                           str+pm[1].rm_so到str+pm[1].rm_eo是第二個匹配的子串
     *                           ....
     */
    z = regexec(&reg, str, nmatch, pm, 0);

    //沒有找到匹配資料
    if(z == REG_NOMATCH)
    {
       reg_rtn_struct_var.rtn    = 1;
       reg_rtn_struct_var.pstart = -1;
       reg_rtn_struct_var.pend   = -1;

       regfree(&reg);
       return reg_rtn_struct_var;
    }
    else if(z)  //if(z !=0)
    {
       perror("reg3");
       regerror(z, &reg, ebuf, sizeof(ebuf));
       fprintf(stderr, "%s: regcomp('%s')\n", ebuf, str);

       reg_rtn_struct_var.rtn    = 1;
       reg_rtn_struct_var.pstart = -1;
       reg_rtn_struct_var.pend   = -1;
       regfree(&reg);

       return reg_rtn_struct_var;
    }

    /*列出匹配的位置*/
    if(pm[0].rm_so != -1)
    {
       reg_rtn_struct_var.rtn    = 0;
       reg_rtn_struct_var.pstart = pm[0].rm_so;
       reg_rtn_struct_var.pend   = pm[0].rm_eo;
    }

    regfree(&reg);
    return reg_rtn_struct_var;
}


/*
* 正則表示式替換函式
*/
char *cns_str_ereplace(char *src, const char *pattern, const char *newsubstr)
{
    //如果pattern和newsubstr串相等，則直接返回
    if(!strcmp(pattern, newsubstr))   //if(strcmp(pattern, newsubstr)==0)
       return src;

    //定義cns_reg的返回型別結構變數
    reg_rtn_struct  reg_rtn_struct_var;
    int rtn    = 0;   //reg_rtn_struct_var.rtn
    int pstart = 0;   //reg_rtn_struct_var.pstart
    int pend   = 0;   //reg_rtn_struct_var.pend


    //把源串預dest
    char *dest=src;  //替換後生成的串指標
    char *pstr=src;  //當找到串時，pstr就指向子串後面的地址從而標識下一個要查詢的源串

    //用於malloc的臨時記憶體區
    char *tmp;
    char *new_tmp_str=dest;

    int new_tmp_str_len=0;  //new_tmp_str相對於dest地址開始處的長度


    //開始迴圈替換src串中符合pattern的子串為newstr
    while(!rtn)
    {
        reg_rtn_struct_var=cns_reg(new_tmp_str, pattern);

        rtn    = reg_rtn_struct_var.rtn;
        pstart = reg_rtn_struct_var.pstart;
        pend   = reg_rtn_struct_var.pend;

        if(!rtn)
        {
            //分配新的空間: strlen(newstr):新串長  pend-pstart:舊串長
            tmp=(char*)calloc(sizeof(char), strlen(dest)+strlen(newsubstr)-(pend-pstart)+1 );

            //把src內的前new_tmp_str_len+pstart個記憶體空間的資料，拷貝到arr
            strncpy(tmp, dest, new_tmp_str_len+pstart);

            //標識串結束
            tmp[new_tmp_str_len+pstart]='\0';

            //連線arr和newstr, 即把newstr附在arr尾部, 從而組成新串(或說字元陣列)arr
            strcat(tmp, newsubstr);

            //把src中 從oldstr子串位置後的部分和arr連線在一起，組成新串arr
            strcat(tmp, new_tmp_str+pend);

            //把用malloc分配的記憶體，複製給指標dest
            dest = strdup(tmp);

            //釋放malloc分配的記憶體空間
            free(tmp);

            new_tmp_str_len = new_tmp_str_len + pstart + strlen(newsubstr);
            new_tmp_str=dest+new_tmp_str_len;
        }
    }

    return dest;
}


int main()
{
  //測試正則表示式
  char str[]="1love2love3love4love5love6love!";

  reg_rtn_struct reg_rtn_struct_var;

  char *newstr=cns_str_ereplace(str,"love","daiwenhai");
  puts(newstr);

  return 0;
}