�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%2Fmysys%2F'>mysys</a>/</p><hr><h3>✏️ Editing: typelib.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
   Copyright (c) 2009, 2013, Monty Program Ab.

   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 Street, Fifth Floor, Boston, MA  02110-1335  USA */

/* Functions to handle typelib */

#include &quot;mysys_priv.h&quot;
#include &lt;m_string.h&gt;
#include &lt;m_ctype.h&gt;


#define is_field_separator(F, X) \
  ((F &amp; FIND_TYPE_COMMA_TERM) &amp;&amp; ((X) == &#039;,&#039; || (X) == &#039;=&#039;))

int find_type_with_warning(const char *x, TYPELIB *typelib, const char *option)
{
  int res;
  const char **ptr;

  if ((res= find_type((char *) x, typelib, FIND_TYPE_BASIC)) &lt;= 0)
  {
    ptr= typelib-&gt;type_names;
    if (!*x)
      fprintf(stderr, &quot;No option given to %s\n&quot;, option);
    else
      fprintf(stderr, &quot;Unknown option to %s: %s\n&quot;, option, x);
    fprintf(stderr, &quot;Alternatives are: &#039;%s&#039;&quot;, *ptr);
    while (*++ptr)
      fprintf(stderr, &quot;,&#039;%s&#039;&quot;, *ptr);
    fprintf(stderr, &quot;\n&quot;);
  }
  return res;
}


/**
  Search after a string in a list of strings. Endspace in x is not compared.

  @param x              pointer to string to find
                        (not necessarily zero-terminated).
                        by return it&#039;ll be advanced to point to the terminator.
  @param typelib        TYPELIB (struct of pointer to values + count)
  @param flags          flags to tune behaviour: a combination of
                        FIND_TYPE_NO_PREFIX
                        FIND_TYPE_COMMA_TERM.
  @param eol            a pointer to the end of the string.

  @retval
    -1  Too many matching values
  @retval
    0   No matching value
  @retval
    &gt;0  Offset+1 in typelib for matched string
*/


static int find_type_eol(const char **x, const TYPELIB *typelib, uint flags,
                         const char *eol)
{
  int find,pos;
  int UNINIT_VAR(findpos);                       /* guarded by find */
  const char *UNINIT_VAR(termptr);
  const char *i;
  const char *j;
  CHARSET_INFO *cs= &amp;my_charset_latin1;
  DBUG_ENTER(&quot;find_type_eol&quot;);
  DBUG_PRINT(&quot;enter&quot;,(&quot;x: &#039;%s&#039;  lib: %p&quot;, *x, typelib));

  DBUG_ASSERT(!(flags &amp; ~(FIND_TYPE_NO_PREFIX | FIND_TYPE_COMMA_TERM)));

  if (!typelib-&gt;count)
  {
    DBUG_PRINT(&quot;exit&quot;,(&quot;no count&quot;));
    DBUG_RETURN(0);
  }
  find=0;
  for (pos=0 ; (j=typelib-&gt;type_names[pos]) ; pos++)
  {
    for (i=*x ; 
         i &lt; eol &amp;&amp; !is_field_separator(flags, *i) &amp;&amp;
         my_toupper(cs, *i) == my_toupper(cs, *j) ; i++, j++) ;
    if (! *j)
    {
      while (i &lt; eol &amp;&amp; *i == &#039; &#039;)
	i++;					/* skip_end_space */
      if (i &gt;= eol || is_field_separator(flags, *i))
      {
        *x= i;
	DBUG_RETURN(pos+1);
      }
    }
    if ((i &gt;= eol &amp;&amp; !is_field_separator(flags, *i)) &amp;&amp;
        (!*j || !(flags &amp; FIND_TYPE_NO_PREFIX)))
    {
      find++;
      findpos=pos;
      termptr=i;
    }
  }
  if (find == 0 || *x == eol)
  {
    DBUG_PRINT(&quot;exit&quot;,(&quot;Couldn&#039;t find type&quot;));
    DBUG_RETURN(0);
  }
  else if (find != 1 || (flags &amp; FIND_TYPE_NO_PREFIX))
  {
    DBUG_PRINT(&quot;exit&quot;,(&quot;Too many possibilities&quot;));
    DBUG_RETURN(-1);
  }
  *x= termptr;
  DBUG_RETURN(findpos+1);
} /* find_type_eol */


/**
  Search after a string in a list of strings. Endspace in x is not compared.

  Same as find_type_eol, but for zero-terminated strings,
  and without advancing the pointer.
*/
int find_type(const char *x, const TYPELIB *typelib, uint flags)
{
  return find_type_eol(&amp;x, typelib, flags, x + strlen(x));
}

/**
  Get name of type nr
 
  @note
  first type is 1, 0 = empty field
*/

void make_type(register char * to, register uint nr,
	       register TYPELIB *typelib)
{
  DBUG_ENTER(&quot;make_type&quot;);
  if (!nr)
    to[0]=0;
  else
    (void) strmov(to,get_type(typelib,nr-1));
  DBUG_VOID_RETURN;
} /* make_type */


/**
  Get type

  @note
  first type is 0
*/

const char *get_type(TYPELIB *typelib, uint nr)
{
  if (nr &lt; (uint) typelib-&gt;count &amp;&amp; typelib-&gt;type_names)
    return(typelib-&gt;type_names[nr]);
  return &quot;?&quot;;
}


/**
  Create an integer value to represent the supplied comma-separated
  string where each string in the TYPELIB denotes a bit position.

  @param x      string to decompose
  @param lib    TYPELIB (struct of pointer to values + count)
  @param err    index (not char position) of string element which was not 
                found or 0 if there was no error

  @retval
    a integer representation of the supplied string
*/

my_ulonglong find_typeset(const char *x, TYPELIB *lib, int *err)
{
  my_ulonglong result;
  int find;
  const char *i;
  DBUG_ENTER(&quot;find_set&quot;);
  DBUG_PRINT(&quot;enter&quot;,(&quot;x: &#039;%s&#039;  lib: %p&quot;, x, lib));

  if (!lib-&gt;count)
  {
    DBUG_PRINT(&quot;exit&quot;,(&quot;no count&quot;));
    DBUG_RETURN(0);
  }
  result= 0;
  *err= 0;
  while (*x)
  {
    (*err)++;
    i= x;
    while (*x &amp;&amp; *x != &#039;,&#039;)
      x++;
    if (x[0] &amp;&amp; x[1])      /* skip separator if found */
      x++;
    if ((find= find_type(i, lib, FIND_TYPE_COMMA_TERM) - 1) &lt; 0)
      DBUG_RETURN(0);
    result|= (1ULL &lt;&lt; find);
  }
  *err= 0;
  DBUG_RETURN(result);
} /* find_set */


/**
  Create a copy of a specified TYPELIB structure.

  @param root   pointer to a MEM_ROOT object for allocations
  @param from   pointer to a source TYPELIB structure

  @retval
    pointer to the new TYPELIB structure on successful copy
  @retval
    NULL otherwise
*/

TYPELIB *copy_typelib(MEM_ROOT *root, const TYPELIB *from)
{
  TYPELIB *to;
  uint i;

  if (!from)
    return NULL;

  if (!(to= (TYPELIB*) alloc_root(root, sizeof(TYPELIB))))
    return NULL;

  if (!(to-&gt;type_names= (const char **)
        alloc_root(root, (sizeof(char *) + sizeof(int)) * (from-&gt;count + 1))))
    return NULL;
  to-&gt;type_lengths= (unsigned int *)(to-&gt;type_names + from-&gt;count + 1);
  to-&gt;count= from-&gt;count;
  if (from-&gt;name)
  {
    if (!(to-&gt;name= strdup_root(root, from-&gt;name)))
      return NULL;
  }
  else
    to-&gt;name= NULL;

  for (i= 0; i &lt; from-&gt;count; i++)
  {
    if (!(to-&gt;type_names[i]= strmake_root(root, from-&gt;type_names[i],
                                          from-&gt;type_lengths[i])))
      return NULL;
    to-&gt;type_lengths[i]= from-&gt;type_lengths[i];
  }
  to-&gt;type_names[to-&gt;count]= NULL;
  to-&gt;type_lengths[to-&gt;count]= 0;

  return to;
}


static const char *on_off_default_names[]= { &quot;off&quot;,&quot;on&quot;,&quot;default&quot;, 0};
static TYPELIB on_off_default_typelib= CREATE_TYPELIB_FOR(on_off_default_names);

/**
  Parse a TYPELIB name from the buffer

  @param lib          Set of names to scan for.
  @param strpos INOUT Start of the buffer (updated to point to the next
                      character after the name)
  @param end          End of the buffer

  @note
  The buffer is assumed to contain one of the names specified in the TYPELIB,
  followed by comma, &#039;=&#039;, or end of the buffer.

  @retval
    0   No matching name
  @retval
    &gt;0  Offset+1 in typelib for matched name
*/

static uint parse_name(const TYPELIB *lib, const char **pos, const char *end)
{
  uint find= find_type_eol(pos, lib,
                           FIND_TYPE_COMMA_TERM | FIND_TYPE_NO_PREFIX, end);
  return find;
}

/**
  Parse and apply a set of flag assingments

  @param lib               Flag names
  @param default_name      Number of &quot;default&quot; in the typelib
  @param cur_set           Current set of flags (start from this state)
  @param default_set       Default set of flags (use this for assign-default
                           keyword and flag=default assignments)
  @param str               String to be parsed
  @param length            Length of the string
  @param err_pos      OUT  If error, set to point to start of wrong set string
                           NULL on success
  @param err_len      OUT  If error, set to the length of wrong set string

  @details
  Parse a set of flag assignments, that is, parse a string in form:

    param_name1=value1,param_name2=value2,... 
  
  where the names are specified in the TYPELIB, and each value can be
  either &#039;on&#039;,&#039;off&#039;, or &#039;default&#039;. Setting the same name twice is not 
  allowed.
  
  Besides param=val assignments, we support the &quot;default&quot; keyword (keyword 
  #default_name in the typelib). It can be used one time, if specified it 
  causes us to build the new set over the default_set rather than cur_set
  value.

  @note
  it&#039;s not charset aware

  @retval
    Parsed set value if (*errpos == NULL), otherwise undefined
*/

my_ulonglong find_set_from_flags(const TYPELIB *lib, uint default_name,
                              my_ulonglong cur_set, my_ulonglong default_set,
                              const char *str, uint length,
                              char **err_pos, uint *err_len)
{
  const char *end= str + length;
  my_ulonglong flags_to_set= 0, flags_to_clear= 0, res;
  my_bool set_defaults= 0;

  *err_pos= 0;                  /* No error yet */
  if (str != end)
  {
    const char *start= str;    
    for (;;)
    {
      const char *pos= start;
      uint flag_no, value;

      if (!(flag_no= parse_name(lib, &amp;pos, end)))
        goto err;

      if (flag_no == default_name)
      {
        /* Using &#039;default&#039; twice isn&#039;t allowed. */
        if (set_defaults)
          goto err;
        set_defaults= TRUE;
      }
      else
      {
        my_ulonglong bit=  (1ULL &lt;&lt; (flag_no - 1));
        /* parse the &#039;=on|off|default&#039; */
        if ((flags_to_clear | flags_to_set) &amp; bit ||
            pos &gt;= end || *pos++ != &#039;=&#039; ||
            !(value= parse_name(&amp;on_off_default_typelib, &amp;pos, end)))
          goto err;
        
        if (value == 1) /* this is &#039;=off&#039; */
          flags_to_clear|= bit;
        else if (value == 2) /* this is &#039;=on&#039; */
          flags_to_set|= bit;
        else /* this is &#039;=default&#039;  */
        {
          if (default_set &amp; bit)
            flags_to_set|= bit;
          else
            flags_to_clear|= bit;
        }
      }
      if (pos &gt;= end)
        break;

      if (*pos++ != &#039;,&#039;)
        goto err;

      start=pos;
      continue;
   err:
      *err_pos= (char*)start;
      *err_len= (uint)(end - start);
      break;
    }
  }
  res= set_defaults? default_set : cur_set;
  res|= flags_to_set;
  res&amp;= ~flags_to_clear;
  return res;
}

</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fmysys'>🔙 Back</a></p>