ceph/src/boost/libs/regex/tools/generate/tables.cpp

   1 /*
   2  *
   3  * Copyright (c) 2004
   4  * John Maddock
   5  *
   6  * Use, modification and distribution are subject to the
   7  * Boost Software License, Version 1.0. (See accompanying file
   8  * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9  *
  10  */
  11
  12  /*
  13   *   LOCATION:    see http://www.boost.org for most recent version.
  14   *   FILE         tables.cpp
  15   *   VERSION      see <boost/version.hpp>
  16   *   DESCRIPTION: Generates code snippets programatically, for cut-and
  17   *                paste into regex source.
  18   */
  19
  20 #include <boost/config.hpp>
  21 #include <map>
  22 #include <vector>
  23 #include <string>
  24 #include <iostream>
  25 #include <algorithm>
  26 #include <cctype>
  27
  28 std::string g_char_type;
  29 std::string g_data_type;
  30 std::map<std::string, std::string> g_table;
  31 std::map<std::string, std::pair<std::string, std::string> > g_help_table;
  32
  33 void add(std::string key, std::string data)
  34 {
  35    g_table[key] = data;
  36    if(key.size() <= 2)
  37       g_help_table[data].first = key;
  38    else
  39       g_help_table[data].second = key;
  40
  41    std::string::size_type i = 0;
  42    while(i < key.size())
  43    {
  44       if(std::isspace(key[i]) || (key[i] == '-') || (key[i] == '_'))
  45          key.erase(i, 1);
  46       else
  47       {
  48          key[i] = std::tolower(key[i]);
  49          ++i;
  50       }
  51    }
  52 }
  53
  54 #define ADD(x, y) add(BOOST_STRINGIZE(x), BOOST_STRINGIZE(y))
  55
  56 void generate_code()
  57 {
  58    std::map<std::string, std::string>::const_iterator i, j;
  59
  60    // begin with the character tables:
  61    std::cout << "static const " << g_char_type << " prop_name_table[] = {\n";
  62    for(i = g_table.begin(), j = g_table.end(); i != j; ++i)
  63    {
  64       std::cout << "   /* " << i->first << " */  ";
  65       for(std::string::size_type n = 0; n < i->first.size(); ++n)
  66       {
  67          std::cout.put('\'');
  68          std::cout.put((i->first)[n]);
  69          std::cout.put('\'');
  70          std::cout.put(',');
  71          std::cout.put(' ');
  72       }
  73       std::cout << std::endl;;
  74    }
  75    std::cout << "};\n\n";
  76
  77    // now the iterator table:
  78    std::cout << "static const BOOST_REGEX_DETAIL_NS::character_pointer_range<" << g_char_type << "> range_data[] = {\n";
  79    std::size_t index = 0;
  80    for(i = g_table.begin(), j = g_table.end(); i != j; ++i)
  81    {
  82       std::cout << "   { prop_name_table+" << index << ", prop_name_table+";
  83       index += i->first.size();
  84       std::cout << index << ", }, // " << i->first << std::endl;
  85    }
  86    std::cout << "};\n\n";
  87
  88    // now the value table:
  89    std::cout << "static const " << g_data_type << " icu_class_map[] = {\n";
  90    for(i = g_table.begin(), j = g_table.end(); i != j; ++i)
  91    {
  92       std::cout << "   " << i->second << ", // " << i->first << std::endl;
  93    }
  94    std::cout << "};\n\n" << std::flush;
  95    g_table.clear();
  96 }
  97
  98 void generate_html()
  99 {
 100    // start by producing a sorted list:
 101    std::vector<std::pair<std::string, std::string> > v;
 102    std::map<std::string, std::pair<std::string, std::string> >::const_iterator i, j;
 103    i = g_help_table.begin();
 104    j = g_help_table.end();
 105    while(i != j)
 106    {
 107       v.push_back(i->second);
 108       ++i;
 109    }
 110    std::sort(v.begin(), v.end());
 111
 112    std::vector<std::pair<std::string, std::string> >::const_iterator h, k;
 113    h = v.begin();
 114    k = v.end();
 115
 116    std::cout << "<table width=\"100%\"><tr><td><b>Short Name</b></td><td><b>Long Name</b></td></tr>\n";
 117    while(h != k)
 118    {
 119       std::cout << "<tr><td>" << (h->first.size() ? h->first : std::string(" ")) << "</td><td>" << h->second << "</td></tr>\n";
 120       ++h;
 121    }
 122    std::cout << "</table>\n\n";
 123 }
 124
 125 int main()
 126 {
 127    g_char_type = "::UChar32";
 128    g_data_type = "icu_regex_traits::char_class_type";
 129    ADD(L*, U_GC_L_MASK);
 130    ADD(Letter, U_GC_L_MASK);
 131    ADD(Lu, U_GC_LU_MASK);
 132    ADD(Ll, U_GC_LL_MASK);
 133    ADD(Lt, U_GC_LT_MASK);
 134    ADD(Lm, U_GC_LM_MASK);
 135    ADD(Lo, U_GC_LO_MASK);
 136    ADD(Uppercase Letter, U_GC_LU_MASK);
 137    ADD(Lowercase Letter, U_GC_LL_MASK);
 138    ADD(Titlecase Letter, U_GC_LT_MASK);
 139    ADD(Modifier Letter, U_GC_LM_MASK);
 140    ADD(Other Letter, U_GC_LO_MASK);
 141
 142    ADD(M*, U_GC_M_MASK);
 143    ADD(Mn, U_GC_MN_MASK);
 144    ADD(Mc, U_GC_MC_MASK);
 145    ADD(Me, U_GC_ME_MASK);
 146    ADD(Mark, U_GC_M_MASK);
 147    ADD(Non-Spacing Mark, U_GC_MN_MASK);
 148    ADD(Spacing Combining Mark, U_GC_MC_MASK);
 149    ADD(Enclosing Mark, U_GC_ME_MASK);
 150
 151    ADD(N*, U_GC_N_MASK);
 152    ADD(Nd, U_GC_ND_MASK);
 153    ADD(Nl, U_GC_NL_MASK);
 154    ADD(No, U_GC_NO_MASK);
 155    ADD(Number, U_GC_N_MASK);
 156    ADD(Decimal Digit Number, U_GC_ND_MASK);
 157    ADD(Letter Number, U_GC_NL_MASK);
 158    ADD(Other Number, U_GC_NO_MASK);
 159
 160    ADD(S*, U_GC_S_MASK);
 161    ADD(Sm, U_GC_SM_MASK);
 162    ADD(Sc, U_GC_SC_MASK);
 163    ADD(Sk, U_GC_SK_MASK);
 164    ADD(So, U_GC_SO_MASK);
 165    ADD(Symbol, U_GC_S_MASK);
 166    ADD(Math Symbol, U_GC_SM_MASK);
 167    ADD(Currency Symbol, U_GC_SC_MASK);
 168    ADD(Modifier Symbol, U_GC_SK_MASK);
 169    ADD(Other Symbol, U_GC_SO_MASK);
 170
 171    ADD(P*, U_GC_P_MASK);
 172    ADD(Pc, U_GC_PC_MASK);
 173    ADD(Pd, U_GC_PD_MASK);
 174    ADD(Ps, U_GC_PS_MASK);
 175    ADD(Pe, U_GC_PE_MASK);
 176    ADD(Pi, U_GC_PI_MASK);
 177    ADD(Pf, U_GC_PF_MASK);
 178    ADD(Po, U_GC_PO_MASK);
 179    ADD(Punctuation, U_GC_P_MASK);
 180    ADD(Connector Punctuation, U_GC_PC_MASK);
 181    ADD(Dash Punctuation, U_GC_PD_MASK);
 182    ADD(Open Punctuation, U_GC_PS_MASK);
 183    ADD(Close Punctuation, U_GC_PE_MASK);
 184    ADD(Initial Punctuation, U_GC_PI_MASK);
 185    ADD(Final Punctuation, U_GC_PF_MASK);
 186    ADD(Other Punctuation, U_GC_PO_MASK);
 187
 188    ADD(Z*, U_GC_Z_MASK);
 189    ADD(Zs, U_GC_ZS_MASK);
 190    ADD(Zl, U_GC_ZL_MASK);
 191    ADD(Zp, U_GC_ZP_MASK);
 192    ADD(Separator, U_GC_Z_MASK);
 193    ADD(Space Separator, U_GC_ZS_MASK);
 194    ADD(Line Separator, U_GC_ZL_MASK);
 195    ADD(Paragraph Separator, U_GC_ZP_MASK);
 196
 197    ADD(C*, U_GC_C_MASK);
 198    ADD(Cc, U_GC_CC_MASK);
 199    ADD(Cf, U_GC_CF_MASK);
 200    ADD(Cs, U_GC_CS_MASK);
 201    ADD(Co, U_GC_CO_MASK);
 202    ADD(Cn, U_GC_CN_MASK);
 203    ADD(Other, U_GC_C_MASK);
 204    ADD(Control, U_GC_CC_MASK);
 205    ADD(Format, U_GC_CF_MASK);
 206    ADD(Surrogate, U_GC_CS_MASK);
 207    ADD(Private Use, U_GC_CO_MASK);
 208    ADD(Not Assigned, U_GC_CN_MASK);
 209    ADD(Any, icu_regex_traits::mask_any);
 210    ADD(Assigned, (0x3FFFFFFFu) & ~(U_GC_CN_MASK));
 211    ADD(ASCII, icu_regex_traits::mask_ascii);
 212    ADD(Titlecase, U_GC_LT_MASK);
 213
 214    generate_code();
 215    generate_html();
 216    return 0;
 217 }