�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fextra%2F'>extra</a>/</p><hr><h3>✏️ Editing: replace.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
   Copyright (c) 2000, 2014, Oracle and/or its affiliates

   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; version 2 of
   the License.

   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, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
   02110-1335  USA */

/*
  Replace strings in textfile

  This program replaces strings in files or from stdin to stdout.
  It accepts a list of from-string/to-string pairs and replaces
  each occurrence of a from-string with the corresponding to-string.
  The first occurrence of a found string is matched. If there is more
  than one possibility for the string to replace, longer matches
  are preferred before shorter matches.

  Special characters in from string:
  \^    Match start of line.
  \$	Match end of line.
  \b	Match space-character, start of line or end of line.
        For end \b the next replace starts locking at the end space-character.
        An \b alone or in a string matches only a space-character.
  \r, \t, \v as in C.
  The programs make a DFA-state-machine of the strings and the speed isn&#039;t
  dependent on the count of replace-strings (only of the number of replaces).
  A line is assumed ending with \n or \0.
  There are no limit except memory on length of strings.

  Written by Monty.
  fill_buffer_retaining() is taken from gnu-grep and modified.
*/
#define VER &quot;1.4&quot;
#include &lt;my_global.h&gt;
#include &lt;m_ctype.h&gt;
#include &lt;my_sys.h&gt;
#include &lt;m_string.h&gt;
#include &lt;errno.h&gt;
#include &lt;welcome_copyright_notice.h&gt;

#define PC_MALLOC		256	/* Bytes for pointers */
#define PS_MALLOC		512	/* Bytes for data */

typedef struct st_pointer_array {		/* when using array-strings */
  TYPELIB typelib;				/* Pointer to strings */
  uchar *str;					/* Strings is here */
  uint8	*flag;					/* Flag about each var. */
  uint  array_allocs,max_count,length,max_length;
} POINTER_ARRAY;

#define SPACE_CHAR	256
#define START_OF_LINE	257
#define END_OF_LINE	258
#define LAST_CHAR_CODE	259

typedef struct st_replace {
  uint8 found;
  struct st_replace *next[256];
} REPLACE;

typedef struct st_replace_found {
  my_bool found;
  char *replace_string;
  uint to_offset;
  int from_offset;
} REPLACE_STRING;

#ifndef WORD_BIT
#define WORD_BIT (8*sizeof(uint))
#endif

	/* functions defined in this file */

static int static_get_options(int *argc,char * * *argv);
static int get_replace_strings(int *argc,char * * *argv,
				   POINTER_ARRAY *from_array,
				   POINTER_ARRAY *to_array);
static int insert_pointer_name(POINTER_ARRAY *pa, char * name);
static void free_pointer_array(POINTER_ARRAY *pa);
static int convert_pipe(REPLACE *,FILE *,FILE *);
static int convert_file(REPLACE *, char *);
static REPLACE *init_replace(char * *from, char * *to,uint count,
                             char * word_end_chars);
static uint replace_strings(REPLACE *rep, char * *start,uint *max_length,
                            char * from);
static int initialize_buffer(void);
static void reset_buffer(void);
static void free_buffer(void);

static int silent=0,verbose=0,updated=0;

	/* The main program */

int main(int argc, char *argv[])
{
  int i,error;
  char word_end_chars[256],*pos;
  POINTER_ARRAY from,to;
  REPLACE *replace;
  MY_INIT(argv[0]);

  if (static_get_options(&amp;argc,&amp;argv))
    exit(1);
  if (get_replace_strings(&amp;argc,&amp;argv,&amp;from,&amp;to))
    exit(1);

  for (i=1,pos=word_end_chars ; i &lt; 256 ; i++)
    if (my_isspace(&amp;my_charset_latin1,i))
      *pos++= (char) i;
  *pos=0;
  if (!(replace=init_replace((char**) from.typelib.type_names,
			     (char**) to.typelib.type_names,
			     (uint) from.typelib.count,word_end_chars)))
    exit(1);
  free_pointer_array(&amp;from);
  free_pointer_array(&amp;to);
  if (initialize_buffer())
    return 1;

  error=0;
  if (argc == 0)
    error=convert_pipe(replace,stdin,stdout);
  else
  {
    while (argc--)
    {
      error=convert_file(replace,*(argv++));
    }
  }
  free_buffer();
  my_free(replace);
  my_end(verbose ? MY_CHECK_ERROR | MY_GIVE_INFO : MY_CHECK_ERROR);
  exit(error ? 2 : 0);
  return 0;					/* No compiler warning */
} /* main */


	/* reads options */
	/* Initiates DEBUG - but no debugging here ! */

static int static_get_options(int *argc, char***argv)
{
  int help,version;
  char *pos;

  silent=verbose=help=0;

  while (--*argc &gt; 0 &amp;&amp; *(pos = *(++*argv)) == &#039;-&#039; &amp;&amp; pos[1] != &#039;-&#039;) {
    while (*++pos)
    {
      version=0;
      switch((*pos)) {
      case &#039;s&#039;:
	silent=1;
	break;
      case &#039;v&#039;:
	verbose=1;
	break;
      case &#039;#&#039;:
	DBUG_PUSH (++pos);
	pos= (char*) &quot; &quot;;			/* Skip rest of arguments */
	break;
      case &#039;V&#039;:
	version=1;
        /* fall through */
      case &#039;I&#039;:
      case &#039;?&#039;:
	help=1;					/* Help text written */
        print_version();
	if (version)
	  break;
	puts(&quot;This software comes with ABSOLUTELY NO WARRANTY. This is free software,\nand you are welcome to modify and redistribute it under the GPL license\n&quot;);
	puts(&quot;This program replaces strings in files or from stdin to stdout.\n&quot;
	     &quot;It accepts a list of from-string/to-string pairs and replaces\n&quot;
	     &quot;each occurrence of a from-string with the corresponding to-string.\n&quot;
         &quot;The first occurrence of a found string is matched. If there is\n&quot;
         &quot;more than one possibility for the string to replace, longer\n&quot;
         &quot;matches are preferred before shorter matches.\n\n&quot;
	     &quot;A from-string can contain these special characters:\n&quot;
	     &quot;  \\^      Match start of line.\n&quot;
	     &quot;  \\$      Match end of line.\n&quot;
	     &quot;  \\b      Match space-character, start of line or end of line.\n&quot;
	     &quot;          For a end \\b the next replace starts locking at the end\n&quot;
	     &quot;          space-character. A \\b alone in a string matches only a\n&quot;
	     &quot;          space-character.\n&quot;);
	  printf(&quot;Usage: %s [-?svIV] from to from to ... -- [files]\n&quot;, my_progname);
	puts(&quot;or&quot;);
	  printf(&quot;Usage: %s [-?svIV] from to from to ... &lt; fromfile &gt; tofile\n&quot;, my_progname);
	puts(&quot;&quot;);
	puts(&quot;Options: -? or -I \&quot;Info\&quot;  -s \&quot;silent\&quot;      -v \&quot;verbose\&quot;&quot;);
	break;
      default:
	fprintf(stderr,&quot;illegal option: -%c\n&quot;,*pos);
	break;
      }
    }
  }
  if (*argc == 0)
  {
    if (!help)
      my_message(0,&quot;No replace options given&quot;,MYF(ME_BELL));
    exit(0);					/* Don&#039;t use as pipe */
  }
  return(0);
} /* static_get_options */


static int get_replace_strings(int *argc, char ***argv,
                               POINTER_ARRAY *from_array,
                               POINTER_ARRAY *to_array)
{
  char *pos;

  bzero((char*) from_array,sizeof(from_array[0]));
  bzero((char*) to_array,sizeof(to_array[0]));
  while (*argc &gt; 0 &amp;&amp; (*(pos = *(*argv)) != &#039;-&#039; || pos[1] != &#039;-&#039; || pos[2]))
  {
    insert_pointer_name(from_array,pos);
    (*argc)--;
    (*argv)++;
    if (!*argc || !strcmp(**argv,&quot;--&quot;))
    {
      my_message(0,&quot;No to-string for last from-string&quot;,MYF(ME_BELL));
      return 1;
    }
    insert_pointer_name(to_array,**argv);
    (*argc)--;
    (*argv)++;
  }
  if (*argc)
  {					/* Skip &quot;--&quot; argument */
    (*argc)--;
    (*argv)++;
  }
  return 0;
}

static int insert_pointer_name(reg1 POINTER_ARRAY *pa,char * name)
{
  uint i,length,old_count;
  uchar *new_pos;
  const char **new_array;
  DBUG_ENTER(&quot;insert_pointer_name&quot;);

  if (! pa-&gt;typelib.count)
  {
    if (!(pa-&gt;typelib.type_names=(const char **)
	  my_malloc(PSI_NOT_INSTRUMENTED, ((PC_MALLOC-MALLOC_OVERHEAD)/
		     (sizeof(char *)+sizeof(*pa-&gt;flag))*
		     (sizeof(char *)+sizeof(*pa-&gt;flag))),MYF(MY_WME))))
      DBUG_RETURN(-1);
    if (!(pa-&gt;str= (uchar*) my_malloc(PSI_NOT_INSTRUMENTED,
                                      PS_MALLOC-MALLOC_OVERHEAD, MYF(MY_WME))))
    {
      my_free((void*) pa-&gt;typelib.type_names);
      DBUG_RETURN (-1);
    }
    pa-&gt;max_count=(PC_MALLOC-MALLOC_OVERHEAD)/(sizeof(uchar*)+
					       sizeof(*pa-&gt;flag));
    pa-&gt;flag= (uint8*) (pa-&gt;typelib.type_names+pa-&gt;max_count);
    pa-&gt;length=0;
    pa-&gt;max_length=PS_MALLOC-MALLOC_OVERHEAD;
    pa-&gt;array_allocs=1;
  }
  length=(uint) strlen(name)+1;
  if (pa-&gt;length+length &gt;= pa-&gt;max_length)
  {
    pa-&gt;max_length=(pa-&gt;length+length+MALLOC_OVERHEAD+PS_MALLOC-1)/PS_MALLOC;
    pa-&gt;max_length=pa-&gt;max_length*PS_MALLOC-MALLOC_OVERHEAD;
    if (!(new_pos= (uchar*) my_realloc(PSI_NOT_INSTRUMENTED, (uchar*) pa-&gt;str,
                                      (uint) pa-&gt;max_length, MYF(MY_WME))))
      DBUG_RETURN(1);
    if (new_pos != pa-&gt;str)
    {
      my_ptrdiff_t diff=PTR_BYTE_DIFF(new_pos,pa-&gt;str);
      for (i=0 ; i &lt; pa-&gt;typelib.count ; i++)
	pa-&gt;typelib.type_names[i]= ADD_TO_PTR(pa-&gt;typelib.type_names[i],diff,
					      char*);
      pa-&gt;str=new_pos;
    }
  }
  if (pa-&gt;typelib.count &gt;= pa-&gt;max_count-1)
  {
    int len;
    pa-&gt;array_allocs++;
    len=(PC_MALLOC*pa-&gt;array_allocs - MALLOC_OVERHEAD);
    if (!(new_array=(const char **) my_realloc(PSI_NOT_INSTRUMENTED, (void*)(pa-&gt;typelib.type_names),
					       (uint) len/
					 (sizeof(uchar*)+sizeof(*pa-&gt;flag))*
					 (sizeof(uchar*)+sizeof(*pa-&gt;flag)),
					 MYF(MY_WME))))
      DBUG_RETURN(1);
    pa-&gt;typelib.type_names=new_array;
    old_count=pa-&gt;max_count;
    pa-&gt;max_count=len/(sizeof(uchar*) + sizeof(*pa-&gt;flag));
    pa-&gt;flag= (uint8*) (pa-&gt;typelib.type_names+pa-&gt;max_count);
    memcpy((uchar*) pa-&gt;flag,(char *) (pa-&gt;typelib.type_names+old_count),
	   old_count*sizeof(*pa-&gt;flag));
  }
  pa-&gt;flag[pa-&gt;typelib.count]=0;			/* Reset flag */
  pa-&gt;typelib.type_names[pa-&gt;typelib.count++]= (char*) (pa-&gt;str+pa-&gt;length);
  pa-&gt;typelib.type_names[pa-&gt;typelib.count]= NullS;	/* Put end-mark */
  (void) strmov((char*) pa-&gt;str + pa-&gt;length, name);
  pa-&gt;length+=length;
  DBUG_RETURN(0);
} /* insert_pointer_name */


	/* free pointer array */

static void free_pointer_array(reg1 POINTER_ARRAY *pa)
{
  if (pa-&gt;typelib.count)
  {
    pa-&gt;typelib.count=0;
    my_free((void*) pa-&gt;typelib.type_names);
    pa-&gt;typelib.type_names=0;
    my_free(pa-&gt;str);
  }
  return;
} /* free_pointer_array */


	/* Code for replace rutines */

#define SET_MALLOC_HUNC 64

typedef struct st_rep_set {
  uint  *bits;				/* Pointer to used sets */
  short	next[LAST_CHAR_CODE];		/* Pointer to next sets */
  uint	found_len;			/* Best match to date */
  int	found_offset;
  uint  table_offset;
  uint  size_of_bits;			/* For convinience */
} REP_SET;

typedef struct st_rep_sets {
  uint		count;			/* Number of sets */
  uint		extra;			/* Extra sets in buffer */
  uint		invisible;		/* Sets not chown */
  uint		size_of_bits;
  REP_SET	*set,*set_buffer;
  uint		*bit_buffer;
} REP_SETS;

typedef struct st_found_set {
  uint table_offset;
  int found_offset;
} FOUND_SET;

typedef struct st_follow {
  int chr;
  uint table_offset;
  uint len;
} FOLLOWS;


static int init_sets(REP_SETS *sets,uint states);
static REP_SET *make_new_set(REP_SETS *sets);
static void make_sets_invisible(REP_SETS *sets);
static void free_last_set(REP_SETS *sets);
static void free_sets(REP_SETS *sets);
static void internal_set_bit(REP_SET *set, uint bit);
static void internal_clear_bit(REP_SET *set, uint bit);
static void or_bits(REP_SET *to,REP_SET *from);
static void copy_bits(REP_SET *to,REP_SET *from);
static int cmp_bits(REP_SET *set1,REP_SET *set2);
static int get_next_bit(REP_SET *set,uint lastpos);
static short find_set(REP_SETS *sets,REP_SET *find);
static short find_found(FOUND_SET *found_set,uint table_offset,
                        int found_offset);
static uint start_at_word(char * pos);
static uint end_of_word(char * pos);
static uint replace_len(char * pos);

static uint found_sets=0;


	/* Init a replace structure for further calls */

static REPLACE *init_replace(char * *from, char * *to,uint count,
                             char * word_end_chars)
{
  uint i,j,states,set_nr,len,result_len,max_length,found_end,bits_set,bit_nr;
  int used_sets,chr;
  short default_state;
  char used_chars[LAST_CHAR_CODE],is_word_end[256];
  char * pos, *to_pos, **to_array;
  REP_SETS sets;
  REP_SET *set,*start_states,*word_states,*new_set;
  FOLLOWS *follow,*follow_ptr;
  REPLACE *replace;
  FOUND_SET *found_set;
  REPLACE_STRING *rep_str;
  DBUG_ENTER(&quot;init_replace&quot;);

  /* Count number of states */
  for (i=result_len=max_length=0 , states=2 ; i &lt; count ; i++)
  {
    len=replace_len(from[i]);
    if (!len)
    {
      errno=EINVAL;
      my_message(0,&quot;No to-string for last from-string&quot;,MYF(ME_BELL));
      DBUG_RETURN(0);
    }
    states+=len+1;
    result_len+=(uint) strlen(to[i])+1;
    if (len &gt; max_length)
      max_length=len;
  }
  bzero((char*) is_word_end,sizeof(is_word_end));
  for (i=0 ; word_end_chars[i] ; i++)
    is_word_end[(uchar) word_end_chars[i]]=1;

  if (init_sets(&amp;sets,states))
    DBUG_RETURN(0);
  found_sets=0;
  if (!(found_set= (FOUND_SET*) my_malloc(PSI_NOT_INSTRUMENTED,
                                          sizeof(FOUND_SET)*max_length*count,
					  MYF(MY_WME))))
  {
    free_sets(&amp;sets);
    DBUG_RETURN(0);
  }
  (void) make_new_set(&amp;sets);			/* Set starting set */
  make_sets_invisible(&amp;sets);			/* Hide previus sets */
  used_sets=-1;
  word_states=make_new_set(&amp;sets);		/* Start of new word */
  start_states=make_new_set(&amp;sets);		/* This is first state */
  if (!(follow=(FOLLOWS*) my_malloc(PSI_NOT_INSTRUMENTED,
                                    (states+2)*sizeof(FOLLOWS), MYF(MY_WME))))
  {
    free_sets(&amp;sets);
    my_free(found_set);
    DBUG_RETURN(0);
  }

	/* Init follow_ptr[] */
  for (i=0, states=1, follow_ptr=follow+1 ; i &lt; count ; i++)
  {
    if (from[i][0] == &#039;\\&#039; &amp;&amp; from[i][1] == &#039;^&#039;)
    {
      internal_set_bit(start_states,states+1);
      if (!from[i][2])
      {
	start_states-&gt;table_offset=i;
	start_states-&gt;found_offset=1;
      }
    }
    else if (from[i][0] == &#039;\\&#039; &amp;&amp; from[i][1] == &#039;$&#039;)
    {
      internal_set_bit(start_states,states);
      internal_set_bit(word_states,states);
      if (!from[i][2] &amp;&amp; start_states-&gt;table_offset == (uint) ~0)
      {
	start_states-&gt;table_offset=i;
	start_states-&gt;found_offset=0;
      }
    }
    else
    {
      internal_set_bit(word_states,states);
      if (from[i][0] == &#039;\\&#039; &amp;&amp; (from[i][1] == &#039;b&#039; &amp;&amp; from[i][2]))
	internal_set_bit(start_states,states+1);
      else
	internal_set_bit(start_states,states);
    }
    for (pos=from[i], len=0; *pos ; pos++)
    {
      if (*pos == &#039;\\&#039; &amp;&amp; *(pos+1))
      {
	pos++;
	switch (*pos) {
	case &#039;b&#039;:
	  follow_ptr-&gt;chr = SPACE_CHAR;
	  break;
	case &#039;^&#039;:
	  follow_ptr-&gt;chr = START_OF_LINE;
	  break;
	case &#039;$&#039;:
	  follow_ptr-&gt;chr = END_OF_LINE;
	  break;
	case &#039;r&#039;:
	  follow_ptr-&gt;chr = &#039;\r&#039;;
	  break;
	case &#039;t&#039;:
	  follow_ptr-&gt;chr = &#039;\t&#039;;
	  break;
	case &#039;v&#039;:
	  follow_ptr-&gt;chr = &#039;\v&#039;;
	  break;
	default:
	  follow_ptr-&gt;chr = (uchar) *pos;
	  break;
	}
      }
      else
	follow_ptr-&gt;chr= (uchar) *pos;
      follow_ptr-&gt;table_offset=i;
      follow_ptr-&gt;len= ++len;
      follow_ptr++;
    }
    follow_ptr-&gt;chr=0;
    follow_ptr-&gt;table_offset=i;
    follow_ptr-&gt;len=len;
    follow_ptr++;
    states+=(uint) len+1;
  }


  for (set_nr=0,pos=0 ; set_nr &lt; sets.count ; set_nr++)
  {
    set=sets.set+set_nr;
    default_state= 0;				/* Start from beginning */

    /* If end of found-string not found or start-set with current set */

    for (i= (uint) ~0; (i=get_next_bit(set,i)) ;)
    {
      if (!follow[i].chr)
      {
	if (! default_state)
	  default_state= find_found(found_set,set-&gt;table_offset,
				    set-&gt;found_offset+1);
      }
    }
    copy_bits(sets.set+used_sets,set);		/* Save set for changes */
    if (!default_state)
      or_bits(sets.set+used_sets,sets.set);	/* Can restart from start */

    /* Find all chars that follows current sets */
    bzero((char*) used_chars,sizeof(used_chars));
    for (i= (uint) ~0; (i=get_next_bit(sets.set+used_sets,i)) ;)
    {
      used_chars[follow[i].chr]=1;
      if ((follow[i].chr == SPACE_CHAR &amp;&amp; !follow[i+1].chr &amp;&amp;
	   follow[i].len &gt; 1) || follow[i].chr == END_OF_LINE)
	used_chars[0]=1;
    }

    /* Mark word_chars used if \b is in state */
    if (used_chars[SPACE_CHAR])
      for (pos= word_end_chars ; *pos ; pos++)
	used_chars[(int) (uchar) *pos] = 1;

    /* Handle other used characters */
    for (chr= 0 ; chr &lt; 256 ; chr++)
    {
      if (! used_chars[chr])
	set-&gt;next[chr]= (short) (chr ? default_state : -1);
      else
      {
	new_set=make_new_set(&amp;sets);
	set=sets.set+set_nr;			/* if realloc */
	new_set-&gt;table_offset=set-&gt;table_offset;
	new_set-&gt;found_len=set-&gt;found_len;
	new_set-&gt;found_offset=set-&gt;found_offset+1;
	found_end=0;

	for (i= (uint) ~0 ; (i=get_next_bit(sets.set+used_sets,i)) ; )
	{
	  if (!follow[i].chr || follow[i].chr == chr ||
	      (follow[i].chr == SPACE_CHAR &amp;&amp;
	       (is_word_end[chr] ||
		(!chr &amp;&amp; follow[i].len &gt; 1 &amp;&amp; ! follow[i+1].chr))) ||
	      (follow[i].chr == END_OF_LINE &amp;&amp; ! chr))
	  {
	    if ((! chr || (follow[i].chr &amp;&amp; !follow[i+1].chr)) &amp;&amp;
		follow[i].len &gt; found_end)
	      found_end=follow[i].len;
	    if (chr &amp;&amp; follow[i].chr)
	      internal_set_bit(new_set,i+1);		/* To next set */
	    else
	      internal_set_bit(new_set,i);
	  }
	}
	if (found_end)
	{
	  new_set-&gt;found_len=0;			/* Set for testing if first */
	  bits_set=0;
	  for (i= (uint) ~0; (i=get_next_bit(new_set,i)) ;)
	  {
	    if ((follow[i].chr == SPACE_CHAR ||
		 follow[i].chr == END_OF_LINE) &amp;&amp; ! chr)
	      bit_nr=i+1;
	    else
	      bit_nr=i;
	    if (follow[bit_nr-1].len &lt; found_end ||
		(new_set-&gt;found_len &amp;&amp;
		 (chr == 0 || !follow[bit_nr].chr)))
	      internal_clear_bit(new_set,i);
	    else
	    {
	      if (chr == 0 || !follow[bit_nr].chr)
	      {					/* best match  */
		new_set-&gt;table_offset=follow[bit_nr].table_offset;
		if (chr || (follow[i].chr == SPACE_CHAR ||
			    follow[i].chr == END_OF_LINE))
		  new_set-&gt;found_offset=found_end;	/* New match */
		new_set-&gt;found_len=found_end;
	      }
	      bits_set++;
	    }
	  }
	  if (bits_set == 1)
	  {
	    set-&gt;next[chr] = find_found(found_set,
					new_set-&gt;table_offset,
					new_set-&gt;found_offset);
	    free_last_set(&amp;sets);
	  }
	  else
	    set-&gt;next[chr] = find_set(&amp;sets,new_set);
	}
	else
	  set-&gt;next[chr] = find_set(&amp;sets,new_set);
      }
    }
  }

	/* Alloc replace structure for the replace-state-machine */

  if ((replace=(REPLACE*) my_malloc(PSI_NOT_INSTRUMENTED,
                                    sizeof(REPLACE)*(sets.count)+
				    sizeof(REPLACE_STRING)*(found_sets+1)+
				    sizeof(char *)*count+result_len,
				    MYF(MY_WME | MY_ZEROFILL))))
  {
    rep_str=(REPLACE_STRING*) (replace+sets.count);
    to_array=(char **) (rep_str+found_sets+1);
    to_pos=(char *) (to_array+count);
    for (i=0 ; i &lt; count ; i++)
    {
      to_array[i]=to_pos;
      to_pos=strmov(to_pos,to[i])+1;
    }
    rep_str[0].found=1;
    rep_str[0].replace_string=0;
    for (i=1 ; i &lt;= found_sets ; i++)
    {
      pos=from[found_set[i-1].table_offset];
      /*
        Test if we are matching start of string (\^)
        We can&#039;t use bcmp() here as pos may be only 1 character and
        that would confuse MSAN.
      */
      rep_str[i].found= (uint8) ((pos[0] == &#039;\\&#039; &amp;&amp; pos[1] == &#039;^&#039; &amp;&amp;
                                  pos[2] == 0) ? 2 : 1);
      rep_str[i].replace_string=to_array[found_set[i-1].table_offset];
      rep_str[i].to_offset=found_set[i-1].found_offset-start_at_word(pos);
      rep_str[i].from_offset=found_set[i-1].found_offset-replace_len(pos)+
	end_of_word(pos);
    }
    for (i=0 ; i &lt; sets.count ; i++)
    {
      for (j=0 ; j &lt; 256 ; j++)
	if (sets.set[i].next[j] &gt;= 0)
	  replace[i].next[j]=replace+sets.set[i].next[j];
	else
	  replace[i].next[j]=(REPLACE*) (rep_str+(-sets.set[i].next[j]-1));
    }
  }
  my_free(follow);
  free_sets(&amp;sets);
  my_free(found_set);
  DBUG_PRINT(&quot;exit&quot;,(&quot;Replace table has %d states&quot;,sets.count));
  DBUG_RETURN(replace);
}


static int init_sets(REP_SETS *sets,uint states)
{
  bzero((char*) sets,sizeof(*sets));
  sets-&gt;size_of_bits=((states+7)/8);
  if (!(sets-&gt;set_buffer=(REP_SET*) my_malloc(PSI_NOT_INSTRUMENTED,
                                              sizeof(REP_SET)*SET_MALLOC_HUNC,
					      MYF(MY_WME))))
    return 1;
  if (!(sets-&gt;bit_buffer=(uint*) my_malloc(PSI_NOT_INSTRUMENTED,
                                           sizeof(uint)*sets-&gt;size_of_bits*
					   SET_MALLOC_HUNC,MYF(MY_WME))))
  {
    my_free(sets-&gt;set);
    return 1;
  }
  return 0;
}

	/* Make help sets invisible for nicer codeing */

static void make_sets_invisible(REP_SETS *sets)
{
  sets-&gt;invisible=sets-&gt;count;
  sets-&gt;set+=sets-&gt;count;
  sets-&gt;count=0;
}

static REP_SET *make_new_set(REP_SETS *sets)
{
  uint i,count,*bit_buffer;
  REP_SET *set;
  if (sets-&gt;extra)
  {
    sets-&gt;extra--;
    set=sets-&gt;set+ sets-&gt;count++;
    bzero((char*) set-&gt;bits,sizeof(uint)*sets-&gt;size_of_bits);
    bzero((char*) &amp;set-&gt;next[0],sizeof(set-&gt;next[0])*LAST_CHAR_CODE);
    set-&gt;found_offset=0;
    set-&gt;found_len=0;
    set-&gt;table_offset= (uint) ~0;
    set-&gt;size_of_bits=sets-&gt;size_of_bits;
    return set;
  }
  count=sets-&gt;count+sets-&gt;invisible+SET_MALLOC_HUNC;
  if (!(set=(REP_SET*) my_realloc(PSI_NOT_INSTRUMENTED, sets-&gt;set_buffer,
                                  sizeof(REP_SET)*count, MYF(MY_WME))))
    return 0;
  sets-&gt;set_buffer=set;
  sets-&gt;set=set+sets-&gt;invisible;
  if (!(bit_buffer=(uint*) my_realloc(PSI_NOT_INSTRUMENTED, sets-&gt;bit_buffer,
                                      (sizeof(uint)*sets-&gt;size_of_bits)*count,
                                      MYF(MY_WME))))
    return 0;
  sets-&gt;bit_buffer=bit_buffer;
  for (i=0 ; i &lt; count ; i++)
  {
    sets-&gt;set_buffer[i].bits=bit_buffer;
    bit_buffer+=sets-&gt;size_of_bits;
  }
  sets-&gt;extra=SET_MALLOC_HUNC;
  return make_new_set(sets);
}

static void free_last_set(REP_SETS *sets)
{
  sets-&gt;count--;
  sets-&gt;extra++;
  return;
}

static void free_sets(REP_SETS *sets)
{
  my_free(sets-&gt;set_buffer);
  my_free(sets-&gt;bit_buffer);
  return;
}

static void internal_set_bit(REP_SET *set, uint bit)
{
  set-&gt;bits[bit / WORD_BIT] |= 1 &lt;&lt; (bit % WORD_BIT);
  return;
}

static void internal_clear_bit(REP_SET *set, uint bit)
{
  set-&gt;bits[bit / WORD_BIT] &amp;= ~ (1 &lt;&lt; (bit % WORD_BIT));
  return;
}


static void or_bits(REP_SET *to,REP_SET *from)
{
  reg1 uint i;
  for (i=0 ; i &lt; to-&gt;size_of_bits ; i++)
    to-&gt;bits[i]|=from-&gt;bits[i];
  return;
}

static void copy_bits(REP_SET *to,REP_SET *from)
{
  memcpy((uchar*) to-&gt;bits,(uchar*) from-&gt;bits,
	 (size_t) (sizeof(uint) * to-&gt;size_of_bits));
}

static int cmp_bits(REP_SET *set1,REP_SET *set2)
{
  return memcmp(set1-&gt;bits, set2-&gt;bits,
                sizeof(uint) * set1-&gt;size_of_bits);
}


	/* Get next set bit from set. */

static int get_next_bit(REP_SET *set,uint lastpos)
{
  uint pos,*start,*end,bits;

  start=set-&gt;bits+ ((lastpos+1) / WORD_BIT);
  end=set-&gt;bits + set-&gt;size_of_bits;
  bits=start[0] &amp; ~((1 &lt;&lt; ((lastpos+1) % WORD_BIT)) -1);

  while (! bits &amp;&amp; ++start &lt; end)
    bits=start[0];
  if (!bits)
    return 0;
  pos=(uint) (start-set-&gt;bits)*WORD_BIT;
  while (! (bits &amp; 1))
  {
    bits&gt;&gt;=1;
    pos++;
  }
  return pos;
}

	/* find if there is a same set in sets. If there is, use it and
	   free given set, else put in given set in sets and return it&#039;s
	   position */

static short find_set(REP_SETS *sets,REP_SET *find)
{
  uint i;
  for (i=0 ; i &lt; sets-&gt;count-1 ; i++)
  {
    if (!cmp_bits(sets-&gt;set+i,find))
    {
      free_last_set(sets);
      return (short) i;
    }
  }
  return (short) i;			/* return new position */
}


/*
  find if there is a found_set with same table_offset &amp; found_offset
  If there is return offset to it, else add new offset and return pos.
  Pos returned is -offset-2 in found_set_structure because it&#039;s is
  saved in set-&gt;next and set-&gt;next[] &gt;= 0 points to next set and
  set-&gt;next[] == -1 is reserved for end without replaces.
*/

static short find_found(FOUND_SET *found_set,uint table_offset,
                        int found_offset)
{
  int i;
  for (i=0 ; (uint) i &lt; found_sets ; i++)
    if (found_set[i].table_offset == table_offset &amp;&amp;
	found_set[i].found_offset == found_offset)
      return (short) (-i-2);
  found_set[i].table_offset=table_offset;
  found_set[i].found_offset=found_offset;
  found_sets++;
  return (short) (-i-2);			/* return new position */
}

	/* Return 1 if regexp starts with \b or ends with \b*/

static uint start_at_word(char * pos)
{
  return (((!memcmp(pos,&quot;\\b&quot;,2) &amp;&amp; pos[2]) || !memcmp(pos,&quot;\\^&quot;,2)) ? 1 : 0);
}

static uint end_of_word(char * pos)
{
  char * end=strend(pos);
  return ((end &gt; pos+2 &amp;&amp; !memcmp(end-2,&quot;\\b&quot;,2)) ||
	  (end &gt;= pos+2 &amp;&amp; !memcmp(end-2,&quot;\\$&quot;,2))) ?
	    1 : 0;
}


static uint replace_len(char * str)
{
  uint len=0;
  while (*str)
  {
    if (str[0] == &#039;\\&#039; &amp;&amp; str[1])
      str++;
    str++;
    len++;
  }
  return len;
}


	/* The actual loop */

static uint replace_strings(REPLACE *rep, char **start, uint *max_length,
                            char *from)
{
  reg1 REPLACE *rep_pos;
  reg2 REPLACE_STRING *rep_str;
  char *to, *end, *pos, *new;

  end=(to= *start) + *max_length-1;
  rep_pos=rep+1;
  for(;;)
  {
    while (!rep_pos-&gt;found)
    {
      rep_pos= rep_pos-&gt;next[(uchar) *from];
      if (to == end)
      {
	(*max_length)+=8192;
	if (!(new=my_realloc(PSI_NOT_INSTRUMENTED, *start,*max_length,MYF(MY_WME))))
	  return (uint) -1;
	to=new+(to - *start);
	end=(*start=new)+ *max_length-1;
      }
      *to++= *from++;
    }
    if (!(rep_str = ((REPLACE_STRING*) rep_pos))-&gt;replace_string)
      return (uint) (to - *start)-1;
    updated=1;			/* Some char * is replaced */
    to-=rep_str-&gt;to_offset;
    for (pos=rep_str-&gt;replace_string; *pos ; pos++)
    {
      if (to == end)
      {
	(*max_length)*=2;
	if (!(new=my_realloc(PSI_NOT_INSTRUMENTED, *start,*max_length,MYF(MY_WME))))
	  return (uint) -1;
	to=new+(to - *start);
	end=(*start=new)+ *max_length-1;
      }
      *to++= *pos;
    }
    if (!*(from-=rep_str-&gt;from_offset) &amp;&amp; rep_pos-&gt;found != 2)
      return (uint) (to - *start);
    rep_pos=rep;
  }
}

static char *buffer;		/* The buffer itself, grown as needed. */
static int bufbytes;		/* Number of bytes in the buffer. */
static int bufread,my_eof;		/* Number of bytes to get with each read(). */
static uint bufalloc;
static char *out_buff;
static uint out_length;

static int initialize_buffer()
{
  bufread = 8192;
  bufalloc = bufread + bufread / 2;
  if (!(buffer = my_malloc(PSI_NOT_INSTRUMENTED, bufalloc+1, MYF(MY_WME))))
    return 1;
  bufbytes=my_eof=0;
  out_length=bufread;
  if (!(out_buff=my_malloc(PSI_NOT_INSTRUMENTED, out_length, MYF(MY_WME))))
    return(1);
  return 0;
}

static void reset_buffer()
{
  bufbytes=my_eof=0;
}

static void free_buffer()
{
  my_free(buffer);
  my_free(out_buff);
}


/*
  Fill the buffer retaining the last n bytes at the beginning of the
  newly filled buffer (for backward context).  Returns the number of new
  bytes read from disk.
*/

static int fill_buffer_retaining(File fd, int n)
{
  int i;

  /* See if we need to grow the buffer. */
  if ((int) bufalloc - n &lt;= bufread)
  {
    while ((int) bufalloc - n &lt;= bufread)
    {
      bufalloc *= 2;
      bufread *= 2;
    }
    buffer = my_realloc(PSI_NOT_INSTRUMENTED, buffer, bufalloc+1, MYF(MY_WME));
    if (! buffer)
      return(-1);
  }

  /* Shift stuff down. */
  bmove(buffer,buffer+bufbytes-n,(uint) n);
  bufbytes = n;

  if (my_eof)
    return 0;

  /* Read in new stuff. */
  if ((i=(int) my_read(fd, (uchar*) buffer + bufbytes,
                       (size_t) bufread, MYF(MY_WME))) &lt; 0)
    return -1;

  /* Kludge to pretend every nonempty file ends with a newline. */
  if (i == 0 &amp;&amp; bufbytes &gt; 0 &amp;&amp; buffer[bufbytes - 1] != &#039;\n&#039;)
  {
    my_eof = i = 1;
    buffer[bufbytes] = &#039;\n&#039;;
  }

  bufbytes += i;
  return i;
}

	/* Return 0 if convert is ok */
	/* Global variable update is set if something was changed */

static int convert_pipe(REPLACE *rep, FILE *in, FILE *out)
{
  int retain,error;
  uint length;
  char save_char,*end_of_line,*start_of_line;
  DBUG_ENTER(&quot;convert_pipe&quot;);

  updated=retain=0;
  reset_buffer();

  while ((error=fill_buffer_retaining(my_fileno(in),retain)) &gt; 0)
  {
    end_of_line=buffer ;
    buffer[bufbytes]=0;			/* Sentinel  */
    for (;;)
    {
      start_of_line=end_of_line;
      while (end_of_line[0] != &#039;\n&#039; &amp;&amp; end_of_line[0])
	end_of_line++;
      if (end_of_line == buffer+bufbytes)
      {
	retain= (int) (end_of_line - start_of_line);
	break;				/* No end of line, read more */
      }
      save_char=end_of_line[0];
      end_of_line[0]=0;
      end_of_line++;
      if ((length=replace_strings(rep,&amp;out_buff,&amp;out_length,start_of_line)) ==
	  (uint) -1)
	return 1;
      if (!my_eof)
	out_buff[length++]=save_char;	/* Don&#039;t write added newline */
      if (my_fwrite(out, (uchar*) out_buff, length, MYF(MY_WME | MY_NABP)))
	DBUG_RETURN(1);
    }
  }
  DBUG_RETURN(error);
}


static int convert_file(REPLACE *rep, char * name)
{
  int error;
  FILE *in,*out;
  char dir_buff[FN_REFLEN], tempname[FN_REFLEN], *org_name = name;
#ifdef HAVE_READLINK
  char link_name[FN_REFLEN];
#endif
  File temp_file;
  size_t dir_buff_length;
  DBUG_ENTER(&quot;convert_file&quot;);

  /* check if name is a symlink */
#ifdef HAVE_READLINK  
  org_name= (!my_disable_symlinks &amp;&amp; 
             !my_readlink(link_name, name, MYF(0))) ? link_name : name;
#endif
  if (!(in= my_fopen(org_name,O_RDONLY,MYF(MY_WME))))
    DBUG_RETURN(1);
  dirname_part(dir_buff, org_name, &amp;dir_buff_length);
  if ((temp_file= create_temp_file(tempname, dir_buff, &quot;PR&quot;, 0,
                                   MYF(MY_WME))) &lt; 0)
  {
    my_fclose(in,MYF(0));
    DBUG_RETURN(1);
  }    
  if (!(out= my_fdopen(temp_file, tempname, O_WRONLY, MYF(MY_WME))))
  {
    my_fclose(in,MYF(0));
    DBUG_RETURN(1);
  }

  error=convert_pipe(rep,in,out);
  my_fclose(in,MYF(0)); my_fclose(out,MYF(0));

  if (updated &amp;&amp; ! error)
    my_redel(org_name, tempname, 0, MYF(MY_WME | MY_LINK_WARNING));
  else
    my_delete(tempname,MYF(MY_WME));
  if (!silent &amp;&amp; ! error)
  {
    if (updated)
      printf(&quot;%s converted\n&quot;,name);
    else if (verbose)
      printf(&quot;%s left unchanged\n&quot;,name);
  }
  DBUG_RETURN(error);
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fextra'>🔙 Back</a></p>