�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%2Foniguruma%2F'>oniguruma</a>/<a href='?path=%2Fbig%2FSRC%2Foniguruma%2Fdoc%2F'>doc</a>/</p><hr><h3>✏️ Editing: onig_syn_md.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
 * onig_syn_md.c
 * Copyright (c) 2024  K.Kosako
 *
 * Oniguruma OWner: K.Kosako       https://github.com/kkos/oniguruma
 * SYNTAX.md      : seanofw        https://github.com/seanofw
 * onig_syn_md.c  : tonco-miyazawa https://github.com/tonco-miyazawa
 */

#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &quot;oniguruma.h&quot;

#define ONIG_SYN_MD_VERSION_INT           (00002)
#define TOTAL_NUM_OF_BITS                 (32)

#define PRINT_SEPARATOR                   (printf(&quot;===================================================\n&quot;))

#define INPUT_SYNTAX(syn, abb, set_in)    { (syn), (#syn), (abb), (set_in) }
#define INPUT_FLAG(arg)                   { (arg), (#arg) }



/************************************* Settings *********************************************/
/* NOW_MODE
1: (OP)
2: (OP2)
3: (BEHAVIOR) */
#define NOW_MODE                          (1)

/*  #define PRINT_UNDEFINED_FLAG  */

/*  #define PRINT_SYNTAX_FORWARD_ORDER  */

/*  #define USE_YOUR_OWN_SYNTAX  */

/*  #define PRINT_DEBUG_INFO  */

#define PRINT_VERSION_INFO
#define PRINT_SET_IN_INFO
#define PRINT_TABLE_INFO
#define WARN_UNDEFINED_FLAG_USED
/************************************* Settings *********************************************/


/************************ Switch between OP, OP2, BEHAVIOR **********************************/
#if   NOW_MODE == 1

#define SYNTAX_MEMBER_NAME                (&quot;op&quot;)
#define TITLE_STRING                      (&quot;Group One Flags (op)&quot;)
#define SYNTAX_MEMBER(syn)                ((syn)-&gt;op)
#define IS_SYNTAX_MEMBER(syn, opm)        (((syn)-&gt;op &amp; (opm)) != 0)

#elif NOW_MODE == 2

#define SYNTAX_MEMBER_NAME                (&quot;op2&quot;)
#define TITLE_STRING                      (&quot;Group Two Flags (op2)&quot;)
#define SYNTAX_MEMBER(syn)                ((syn)-&gt;op2)
#define IS_SYNTAX_MEMBER(syn, opm)        (((syn)-&gt;op2 &amp; (opm)) != 0)

#elif NOW_MODE == 3

#define SYNTAX_MEMBER_NAME                (&quot;behavior&quot;)
#define TITLE_STRING                      (&quot;Syntax Flags (syn)&quot;)
#define SYNTAX_MEMBER(syn)                ((syn)-&gt;behavior)
#define IS_SYNTAX_MEMBER(syn, opm)        (((syn)-&gt;behavior &amp; (opm)) != 0)

#else
#error &quot;Check &#039;NOW_MODE&#039; value.&quot;
#endif
/************************ Switch between OP, OP2, BEHAVIOR **********************************/


/*********************************** Your own syntax ****************************************/
#ifdef USE_YOUR_OWN_SYNTAX
static OnigSyntaxType OnigSyntaxYourOwn;
#define ONIG_SYNTAX_YOUROWN    (&amp;OnigSyntaxYourOwn)

static OnigSyntaxType OnigSyntaxYourOwn = {
    0xf0f0f0f0      /*  Group One Flags (op)   */
  , 0xffff0000      /*  Group Two Flags (op2)  */
  , 0x00ff00ff      /*  Syntax Flags    (syn)  */
  , ONIG_OPTION_NONE
  ,
  {
      (OnigCodePoint )&#039;\\&#039;                       /* esc */
    , (OnigCodePoint )ONIG_INEFFECTIVE_META_CHAR /* anychar &#039;.&#039;  */
    , (OnigCodePoint )ONIG_INEFFECTIVE_META_CHAR /* anytime &#039;*&#039;  */
    , (OnigCodePoint )ONIG_INEFFECTIVE_META_CHAR /* zero or one time &#039;?&#039; */
    , (OnigCodePoint )ONIG_INEFFECTIVE_META_CHAR /* one or more time &#039;+&#039; */
    , (OnigCodePoint )ONIG_INEFFECTIVE_META_CHAR /* anychar anytime */
  }
};
#endif
/*********************************** Your own syntax ****************************************/


/************************************** syntax data *****************************************/
typedef struct {
    OnigSyntaxType* syn;
    char *name;
    char *abb;
    char *set_in;
} syn_data;


static syn_data  syn_data_list[] =
{
   /*  INPUT_SYNTAX(syn, abb, set_in)  ===&gt;   { (syn), (#syn), (abb), (set_in) }  */

    INPUT_SYNTAX( ONIG_SYNTAX_ASIS           , &quot;ASIS&quot; , &quot;ASIS&quot; )
  , INPUT_SYNTAX( ONIG_SYNTAX_POSIX_BASIC    , &quot;PosB&quot; , &quot;PosixBasic&quot; )
  , INPUT_SYNTAX( ONIG_SYNTAX_POSIX_EXTENDED , &quot;PosEx&quot;, &quot;PosixExtended&quot;)
  , INPUT_SYNTAX( ONIG_SYNTAX_EMACS          , &quot;Emacs&quot;, &quot;Emacs&quot;)
  , INPUT_SYNTAX( ONIG_SYNTAX_GREP           , &quot;Grep&quot; , &quot;Grep&quot; )
  , INPUT_SYNTAX( ONIG_SYNTAX_GNU_REGEX      , &quot;Gnu&quot;  , &quot;GnuRegex&quot; )
  , INPUT_SYNTAX( ONIG_SYNTAX_JAVA           , &quot;Java&quot; , &quot;Java&quot; )
  , INPUT_SYNTAX( ONIG_SYNTAX_PERL           , &quot;Perl&quot; , &quot;Perl&quot; )
  , INPUT_SYNTAX( ONIG_SYNTAX_PERL_NG        , &quot;PeNG&quot; , &quot;Perl_NG&quot; )
  , INPUT_SYNTAX( ONIG_SYNTAX_RUBY           , &quot;Ruby&quot; , &quot;Ruby&quot; )
  , INPUT_SYNTAX( ONIG_SYNTAX_PYTHON         , &quot;Pythn&quot;, &quot;Python&quot;)
  , INPUT_SYNTAX( ONIG_SYNTAX_ONIGURUMA      , &quot;Onig&quot; , &quot;Oniguruma&quot; )

#ifdef USE_YOUR_OWN_SYNTAX
  , INPUT_SYNTAX( ONIG_SYNTAX_YOUROWN        , &quot;Your&quot; , &quot;YourOwn&quot; )
#endif
};

static const int num_of_syntax_types = (sizeof syn_data_list /sizeof syn_data_list[0]);


static void print_syn_data_list()
{
  int y;
  PRINT_SEPARATOR;
  for (y = 0; y &lt; num_of_syntax_types; y++)
  {
    printf( &quot;\nsyn_data_list[%d]\n&quot;, y);
    printf( &quot;name=&#039;%s&#039;\n&quot;   , syn_data_list[y].name);

    printf( &quot;syn-&gt;&quot;);
    printf( SYNTAX_MEMBER_NAME );
    printf( &quot;= 0x%08x\n&quot;, SYNTAX_MEMBER(syn_data_list[y].syn) );

    printf( &quot;abb=&#039;%s&#039;\n&quot;    , syn_data_list[y].abb);
    printf( &quot;set_in=&#039;%s&#039;\n&quot;    , syn_data_list[y].set_in);        
  };
  return ;
}
/************************************** syntax data *****************************************/


/************************************** flag data *******************************************/
typedef struct {
    unsigned int num;
    char *name;
} flag_data;


/*  OP  */
#if NOW_MODE == 1
static flag_data  flag_data_list[] =
{

/*  The following are no need to sort them in bit order.  */

/*  INPUT_FLAG(arg)  ===&gt;    { (arg), (#arg) }   */

    INPUT_FLAG( ONIG_SYN_OP_VARIABLE_META_CHARACTERS )
  , INPUT_FLAG( ONIG_SYN_OP_DOT_ANYCHAR )
  , INPUT_FLAG( ONIG_SYN_OP_ASTERISK_ZERO_INF )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_ASTERISK_ZERO_INF )
  , INPUT_FLAG( ONIG_SYN_OP_PLUS_ONE_INF )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_PLUS_ONE_INF )
  , INPUT_FLAG( ONIG_SYN_OP_QMARK_ZERO_ONE )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_QMARK_ZERO_ONE )
  , INPUT_FLAG( ONIG_SYN_OP_BRACE_INTERVAL )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_BRACE_INTERVAL )
  , INPUT_FLAG( ONIG_SYN_OP_VBAR_ALT )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_VBAR_ALT )
  , INPUT_FLAG( ONIG_SYN_OP_LPAREN_SUBEXP )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_LPAREN_SUBEXP )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_CAPITAL_G_BEGIN_ANCHOR )
  , INPUT_FLAG( ONIG_SYN_OP_DECIMAL_BACKREF )
  , INPUT_FLAG( ONIG_SYN_OP_BRACKET_CC )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_W_WORD )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_B_WORD_BOUND )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_S_WHITE_SPACE )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_D_DIGIT )
  , INPUT_FLAG( ONIG_SYN_OP_LINE_ANCHOR )
  , INPUT_FLAG( ONIG_SYN_OP_POSIX_BRACKET )
  , INPUT_FLAG( ONIG_SYN_OP_QMARK_NON_GREEDY )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_CONTROL_CHARS )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_C_CONTROL )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_OCTAL3 )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_X_HEX2 )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_X_BRACE_HEX8 )
  , INPUT_FLAG( ONIG_SYN_OP_ESC_O_BRACE_OCTAL )
};
#endif


/*  OP2 */
#if NOW_MODE == 2
static flag_data  flag_data_list[] =
{
    INPUT_FLAG( ONIG_SYN_OP2_ESC_CAPITAL_Q_QUOTE )
  , INPUT_FLAG( ONIG_SYN_OP2_QMARK_GROUP_EFFECT )
  , INPUT_FLAG( ONIG_SYN_OP2_OPTION_PERL )
  , INPUT_FLAG( ONIG_SYN_OP2_OPTION_RUBY )
  , INPUT_FLAG( ONIG_SYN_OP2_PLUS_POSSESSIVE_REPEAT )
  , INPUT_FLAG( ONIG_SYN_OP2_PLUS_POSSESSIVE_INTERVAL )
  , INPUT_FLAG( ONIG_SYN_OP2_CCLASS_SET_OP )
  , INPUT_FLAG( ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP )
  , INPUT_FLAG( ONIG_SYN_OP2_ESC_K_NAMED_BACKREF )
  , INPUT_FLAG( ONIG_SYN_OP2_ESC_G_SUBEXP_CALL )
  , INPUT_FLAG( ONIG_SYN_OP2_ATMARK_CAPTURE_HISTORY )
  , INPUT_FLAG( ONIG_SYN_OP2_ESC_CAPITAL_C_BAR_CONTROL )
  , INPUT_FLAG( ONIG_SYN_OP2_ESC_CAPITAL_M_BAR_META )
  , INPUT_FLAG( ONIG_SYN_OP2_ESC_V_VTAB )
  , INPUT_FLAG( ONIG_SYN_OP2_ESC_U_HEX4 )
  , INPUT_FLAG( ONIG_SYN_OP2_ESC_GNU_BUF_ANCHOR )
  , INPUT_FLAG( ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY )
  , INPUT_FLAG( ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT )
  /*  , INPUT_FLAG( ONIG_SYN_OP2_CHAR_PROPERTY_PREFIX_IS )  */
  , INPUT_FLAG( ONIG_SYN_OP2_ESC_H_XDIGIT )
  , INPUT_FLAG( ONIG_SYN_OP2_INEFFECTIVE_ESCAPE )
  , INPUT_FLAG( ONIG_SYN_OP2_QMARK_LPAREN_IF_ELSE )
  , INPUT_FLAG( ONIG_SYN_OP2_ESC_CAPITAL_K_KEEP )
  , INPUT_FLAG( ONIG_SYN_OP2_ESC_CAPITAL_R_GENERAL_NEWLINE )
  , INPUT_FLAG( ONIG_SYN_OP2_ESC_CAPITAL_N_O_SUPER_DOT )
  , INPUT_FLAG( ONIG_SYN_OP2_QMARK_TILDE_ABSENT_GROUP )
  /*  , INPUT_FLAG( ONIG_SYN_OP2_ESC_X_Y_GRAPHEME_CLUSTER ) */   /* obsoleted: use next */
  , INPUT_FLAG( ONIG_SYN_OP2_ESC_X_Y_TEXT_SEGMENT )
  , INPUT_FLAG( ONIG_SYN_OP2_QMARK_PERL_SUBEXP_CALL )
  , INPUT_FLAG( ONIG_SYN_OP2_QMARK_BRACE_CALLOUT_CONTENTS )
  , INPUT_FLAG( ONIG_SYN_OP2_ASTERISK_CALLOUT_NAME )
  , INPUT_FLAG( ONIG_SYN_OP2_OPTION_ONIGURUMA )
  , INPUT_FLAG( ONIG_SYN_OP2_QMARK_CAPITAL_P_NAME )
};
#endif


/*  BEHAVIOR  */
#if NOW_MODE == 3
static flag_data  flag_data_list[] =
{
    INPUT_FLAG( ONIG_SYN_CONTEXT_INDEP_ANCHORS )
  , INPUT_FLAG( ONIG_SYN_CONTEXT_INDEP_REPEAT_OPS )
  , INPUT_FLAG( ONIG_SYN_CONTEXT_INVALID_REPEAT_OPS )
  , INPUT_FLAG( ONIG_SYN_ALLOW_UNMATCHED_CLOSE_SUBEXP )
  , INPUT_FLAG( ONIG_SYN_ALLOW_INVALID_INTERVAL )
  , INPUT_FLAG( ONIG_SYN_ALLOW_INTERVAL_LOW_ABBREV )
  , INPUT_FLAG( ONIG_SYN_STRICT_CHECK_BACKREF )
  , INPUT_FLAG( ONIG_SYN_DIFFERENT_LEN_ALT_LOOK_BEHIND )
  , INPUT_FLAG( ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP )
  , INPUT_FLAG( ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME )
  , INPUT_FLAG( ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY )
  , INPUT_FLAG( ONIG_SYN_ISOLATED_OPTION_CONTINUE_BRANCH )
  , INPUT_FLAG( ONIG_SYN_VARIABLE_LEN_LOOK_BEHIND )
  , INPUT_FLAG( ONIG_SYN_PYTHON )
  , INPUT_FLAG( ONIG_SYN_WHOLE_OPTIONS )
  , INPUT_FLAG( ONIG_SYN_BRE_ANCHOR_AT_EDGE_OF_SUBEXP )

  /* syntax (behavior) in char class [...] */
  , INPUT_FLAG( ONIG_SYN_NOT_NEWLINE_IN_NEGATIVE_CC )
  , INPUT_FLAG( ONIG_SYN_BACKSLASH_ESCAPE_IN_CC )
  , INPUT_FLAG( ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC )
  , INPUT_FLAG( ONIG_SYN_ALLOW_DOUBLE_RANGE_OP_IN_CC )
  , INPUT_FLAG( ONIG_SYN_ALLOW_INVALID_CODE_END_OF_RANGE_IN_CC )
  , INPUT_FLAG( ONIG_SYN_ALLOW_CHAR_TYPE_FOLLOWED_BY_MINUS_IN_CC )

  /* syntax (behavior) warning */
  , INPUT_FLAG( ONIG_SYN_WARN_CC_OP_NOT_ESCAPED )
  , INPUT_FLAG( ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT )
};
#endif


static const int num_of_flags = (sizeof flag_data_list /sizeof flag_data_list[0]);

static int flag_name_max_len = 0;


static int flag_name_max_len_int()
{
  int i, n, max_len;
  max_len = 0;

  for (i = 0; i &lt; num_of_flags; i++)
  {
    n = strlen(flag_data_list[i].name);
    if ( max_len &lt; n )
    {
      max_len = n;
    }
  }

  /*  Debug: printf(&quot;max_len=%d\n&quot;, max_len);  */
  return max_len;
}


static int convert_bit_shift_num_to_flag_data_list_element( int bit_shift_num )
{
  int i;
  for (i = 0; i &lt; num_of_flags; i++)
  {
    if ( flag_data_list[i].num == (1U &lt;&lt; bit_shift_num) ){

#ifdef PRINT_DEBUG_INFO
      printf(&quot;(1U &lt;&lt; %d) ===&gt; flag_data_list[%d]\n&quot;, bit_shift_num, i );
#endif
      return i;
    }
  }

#ifdef PRINT_DEBUG_INFO
  printf(&quot;(1U &lt;&lt; %d) ===&gt;     ( none )\n&quot;, bit_shift_num );
#endif

  /*  If not found, returns &quot;-1&quot;. This is not Error. */
  return -1;
}


static int convert_num_to_bit_shift_num(unsigned int arg_num){
  int x;
  for (x = 0; x &lt; TOTAL_NUM_OF_BITS; x++)
  {
     if ( arg_num == (1U &lt;&lt; x) )
     {
       return x;
     }
  }

  /* Error */
  printf(&quot;&lt;Error:line%d&gt; &#039;0x%08x&#039; is not bit flag.\n&quot;, __LINE__, arg_num );
  exit(-1);
  return -1;
}


static int check_flag_data_duplication()
{
  int i, shift_num;
  unsigned int used_bits = 0;

  for (i = 0; i &lt; num_of_flags; i++)
  {
    if ( (used_bits &amp; flag_data_list[i].num) != 0 ){

       shift_num = convert_num_to_bit_shift_num(flag_data_list[i].num);

       PRINT_SEPARATOR;
       fprintf(stderr, &quot;\n&lt;Error:line%d&gt;  The following bit has already been used.\n&quot;, __LINE__ );
       fprintf(stderr, &quot;flag_data_list[%d] : &#039;%s&#039; &quot;, i, flag_data_list[i].name);
       fprintf(stderr, &quot;(1U &lt;&lt; %d)\n&quot;, shift_num);

#ifndef PRINT_DEBUG_INFO
       fprintf(stderr, &quot;\nPlease use &#039;#define PRINT_DEBUG_INFO&#039;.\n&quot;);
#endif
       exit(-1);
       return -1;
    }
    used_bits |= flag_data_list[i].num;
  }
  return 0;
}


static void print_flag_data_list()
{
  int i, shift_num;

  PRINT_SEPARATOR;
  for (i = 0; i &lt; num_of_flags; i++)
  {
    shift_num = convert_num_to_bit_shift_num( flag_data_list[i].num );

    printf( &quot;\nflag_data_list[%d]\n&quot;, i);
    printf( &quot;name=&#039;%s&#039; &quot;   , flag_data_list[i].name);
    printf( &quot;(1U &lt;&lt; %d)\n&quot; , shift_num);
    printf( &quot;num=0x%08x\n&quot;   , flag_data_list[i].num);
  }
  return ;
}
/************************************** flag data *******************************************/


/************************************** print table *****************************************/
static void print_table_head()
{
  int i, y;

  printf(&quot;\n### &quot;);
  printf( TITLE_STRING );
  printf(&quot;\n\n| ID    | Option&quot;);
  for (i = 0; i &lt; (flag_name_max_len - 1); i++)
  {
    printf(&quot; &quot;);
  }
  printf(&quot;|&quot;);

  /*  ex. print &quot;PeNG &quot;  */
#ifdef PRINT_SYNTAX_FORWARD_ORDER
  for (y = 0; y &lt; num_of_syntax_types; y++)
#else
  for (y = num_of_syntax_types -1; y &gt; -1; y--)
#endif
  {
    printf(&quot; %-5.5s |&quot;, syn_data_list[y].abb );
  }

  printf(&quot;\n| ----- | &quot;);
  for (i = 0; i &lt; (flag_name_max_len + 4); i++)
  {
    printf(&quot;-&quot;);
  }
  printf(&quot; |&quot;);

  for (y = 0; y &lt; num_of_syntax_types; y++)
  {
    printf(&quot; ----- |&quot;);
  }
  printf(&quot;\n&quot;);
  return ;
}


static void print_table_body_one_line( int shift_num )
{
  int i, y, elem, name_chars;

  elem = convert_bit_shift_num_to_flag_data_list_element(shift_num);

  printf(&quot;| %2d    | &quot;, shift_num);

  if (elem &lt; 0){
    name_chars = printf(&quot;     `( Undefined )`&quot;);    /*  elem == -1  */
  } else {
    name_chars = printf(&quot;`%s`&quot;, flag_data_list[elem].name);
  }

  for ( i=0; i &lt; (flag_name_max_len - name_chars + 5); i++){ printf(&quot; &quot;); }
  printf(&quot;|&quot;);

  /*  ex. print  &#039; Yes   |&#039;   */
#ifdef PRINT_SYNTAX_FORWARD_ORDER
  for (y = 0; y &lt; num_of_syntax_types; y++)
#else
  for (y = num_of_syntax_types -1; y &gt; -1; y--)
#endif
  {
    if ( IS_SYNTAX_MEMBER(syn_data_list[y].syn, (1U &lt;&lt; shift_num)) )
    {
      printf(&quot; Yes   |&quot;);
    } else {
      printf(&quot; -     |&quot;);
    }
  }
  printf(&quot;\n&quot;);
  return ;
}


static void print_table_body()
{
  int x, elem;
  for (x = 0; x &lt; TOTAL_NUM_OF_BITS; x++)
  {
    elem = convert_bit_shift_num_to_flag_data_list_element( x );

    if (elem &lt; 0)
    {
#if !(defined( PRINT_UNDEFINED_FLAG ))
      continue;
#endif
    }
    print_table_body_one_line(x);
  }
  return ;
}

/************************************** print table *****************************************/


/************************************* print Set_in *****************************************/
static void print_set_in_one_line(int shift_num)
{
  int y, elem, count;

  elem = convert_bit_shift_num_to_flag_data_list_element(shift_num);

  if (elem &lt; 0)
  {
    printf(&quot;### %d.       ( Undefined )\n&quot;, shift_num );    /*  elem == -1  */
  } else {
    printf(&quot;### %d. %s\n&quot;, shift_num, flag_data_list[elem].name );
  }

  count = 0;
  printf(&quot;_Set in: &quot;);
#ifdef PRINT_SYNTAX_FORWARD_ORDER
  for (y = 0; y &lt; num_of_syntax_types; y++)
#else
  for (y = num_of_syntax_types -1; y &gt; -1; y--)
#endif
  {
    if ( IS_SYNTAX_MEMBER(syn_data_list[y].syn, (1U &lt;&lt; shift_num)) )
    {
      if (count &gt; 0){ printf(&quot;, &quot;); };
      printf(&quot;%s&quot;, syn_data_list[y].set_in);
      count++;
    }
  }   /* for y */

  if (count==0){ printf(&quot;none&quot;); };

  printf(&quot;_\n\n&quot;);
  return ;
}


static void print_set_in()
{
  int x, elem;

  PRINT_SEPARATOR;
  printf(&quot;The following are &#039;Set in&#039; for oniguruma/doc/SYNTAX.md\n\n## &quot;);
  printf( TITLE_STRING );
  printf(&quot;\n\n&quot;);
  for (x = 0; x &lt; TOTAL_NUM_OF_BITS; x++)
  {
    elem = convert_bit_shift_num_to_flag_data_list_element( x );

    if (elem &lt; 0)
    {
#if !(defined( PRINT_UNDEFINED_FLAG ))
      continue;
#endif
    }

    print_set_in_one_line(x);
  }
  return ;
}

/************************************* print Set_in *****************************************/


/**************************************    main()   *****************************************/

static void print_version()
{
  printf( &quot;[ onig_syn_md.c ver.%05d ] &quot;, ONIG_SYN_MD_VERSION_INT );
  printf(&quot;The loaded oniguruma is &#039;%d.%d.%d&#039;.\n&quot;
    , ONIGURUMA_VERSION_MAJOR
    , ONIGURUMA_VERSION_MINOR
    , ONIGURUMA_VERSION_TEENY );
  return ;
}


static void print_debug()
{
  int x;

  print_version();
  print_syn_data_list();
  print_flag_data_list();
  check_flag_data_duplication();

  /*  print: (1U &lt;&lt; x) ===&gt; flag_data_list[elem] */
  PRINT_SEPARATOR;
  printf(&quot;\nThe following are the array elements that correspond to each bit.\n\n&quot;);
  for (x = 0; x &lt; TOTAL_NUM_OF_BITS; x++)
  {
    convert_bit_shift_num_to_flag_data_list_element(x);
  }
  return ;
}


static void warn_undefined_flag_used()
{
  int x, y, elem;

  for (x = 0; x &lt; TOTAL_NUM_OF_BITS; x++)
  {
    elem = convert_bit_shift_num_to_flag_data_list_element(x);

    if (elem &lt; 0){
      for (y = 0; y &lt; num_of_syntax_types; y++)
      {
        if ( IS_SYNTAX_MEMBER( syn_data_list[y].syn, (1U &lt;&lt; x) ) )
        {
          PRINT_SEPARATOR;
          printf(&quot;warning: An undefined bit flag is used.&quot;);
          printf(&quot;  (1U &lt;&lt; %d)\n\n&quot;, x);
          print_set_in_one_line( x );

#ifndef PRINT_UNDEFINED_FLAG
          printf(&quot;Please use &#039;#define PRINT_UNDEFINED_FLAG&#039;.\n&quot;);
#endif
          return ;
        }
      }   /*  for y  */
    }   /*  if elem */
  }   /*  for x  */
  return ;
}


extern int main(int argc, char* argv[])
{
#ifdef PRINT_DEBUG_INFO
  print_debug();
  return 0;
#endif

#ifdef PRINT_VERSION_INFO
  print_version();
#endif

  flag_name_max_len = flag_name_max_len_int();
  check_flag_data_duplication();

#ifdef PRINT_SET_IN_INFO
  print_set_in();
#endif

#ifdef PRINT_TABLE_INFO
  print_table_head();
  print_table_body();
#endif

#ifdef WARN_UNDEFINED_FLAG_USED
  warn_undefined_flag_used();
#endif

  /*  test  */
  /*
  printf(&quot;\n------  test -------\n&quot;);

  int test_x = 17;
  print_set_in_one_line( test_x );
  print_table_body_one_line( test_x );
  printf(&quot;--------------------\n&quot;);
  */

  /*  To avoid &#039;gcc -Wall&#039; warnings.  */
  if (0)
  {
    print_debug();
    print_version();
    print_set_in();
    print_table_head();
    print_table_body();
    warn_undefined_flag_used();
  }

  return 0;
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Foniguruma%2Fdoc'>🔙 Back</a></p>