Changeset 659 for trunk

Timestamp:

02/26/08 06:43:49 (9 months ago)

Author:

artem

Message:

use range based 'parse' method
transcode strings in filter expressions (default to utf8 input)

-- we can use map definition *.xml to define encoding
-- and in case of Python from

# -*- coding: utf-8 -*-

utf8 encoded filters are working now.

Location:

trunk

Files:

• bindings/python/mapnik_filter.cpp (modified) (2 diffs)
• include/mapnik/filter_factory.hpp (modified) (2 diffs)
• include/mapnik/filter_parser.hpp (modified) (3 diffs)
• src/filter_factory.cpp (modified) (1 diff)
• src/load_map.cpp (modified) (1 diff)

trunk/bindings/python/mapnik_filter.cpp

@@ -37 +37 @@
 using mapnik::create_filter;
 
+filter_ptr create_filter_(std::string const& wkt)
+{
+   return create_filter(wkt,"utf8");
+}
+
 void export_filter()
 {
@@ -43 +48 @@
                                                "An expression which allows "
                                                "to select features.",no_init)
-        .def("__str__",&filter<Feature>::to_string);
-        ;
+       .def("__str__",&filter<Feature>::to_string);
+    ;
     
-    def("Filter",&create_filter);
+    def("Filter",&create_filter_);
 }

trunk/include/mapnik/filter_factory.hpp

@@ -28 +28 @@
 #include <mapnik/config_error.hpp>
 #include <mapnik/filter_parser.hpp>
+#include <mapnik/unicode.hpp>
 
 namespace mapnik
@@ -37 +38 @@
     {
     public:
-        static filter_ptr compile(string const& str)
-        {
-            stack<shared_ptr<filter<FeatureT> > > filters;
-            stack<shared_ptr<expression<FeatureT> > > exps;
-            filter_grammar<FeatureT> grammar(filters,exps);
-            char const *text = str.c_str();
-            parse_info<> info = parse(text, grammar, space_p);
-            if ( ! info.full) {
-                std::ostringstream os;
-                os << "Failed to parse filter expression:" << std::endl
-                   << str << std::endl
-                   << "Parsing aborted at '" << info.stop << "'";
-
-                throw config_error( os.str() );
-            }
-
-            if ( ! filters.empty())
-            {
-                return filters.top();   
-            }
-            else 
-            {
-                // XXX: do we ever get here? [DS]
-                return filter_ptr(new none_filter<FeatureT>());
-            }  
-        }
+       static filter_ptr compile(string const& str,transcoder const& tr)
+       {
+          stack<shared_ptr<filter<FeatureT> > > filters;
+          stack<shared_ptr<expression<FeatureT> > > exps;
+          filter_grammar<FeatureT> grammar(filters,exps,tr);
+          parse_info<std::string::const_iterator> info = parse(str.begin(), str.end(), grammar, space_p);
+          if ( !info.full) 
+          {
+             std::ostringstream os;
+             os << "Failed to parse filter expression:\n"
+                << str <<  "\nParsing aborted at '" << *info.stop << "'";
+             
+             throw config_error( os.str() );
+          }
+          
+          if ( ! filters.empty())
+          {
+             return filters.top();      
+          }
+          else 
+          {
+             // XXX: do we ever get here? [DS]
+             return filter_ptr(new none_filter<FeatureT>());
+          }  
+       }
     };
-    
-    MAPNIK_DECL filter_ptr create_filter (std::string const& wkt);
+   
+   MAPNIK_DECL filter_ptr create_filter (std::string const& wkt, std::string const& encoding);
+   MAPNIK_DECL filter_ptr create_filter (std::string const& wkt);
+   
 }
 

trunk/include/mapnik/filter_parser.hpp

@@ -28 +28 @@
 // mapnik
 #include <mapnik/value.hpp>
+#include <mapnik/unicode.hpp>
 #include <mapnik/comparison.hpp>
 #include <mapnik/math_expr.hpp>
@@ -36 +37 @@
 
 // boost
-//#define BOOST_SPIRIT_DEBUG
+#ifdef MAPNIK_DEBUG
+#define BOOST_SPIRIT_DEBUG
+#endif
+
 #include <boost/shared_ptr.hpp>
 #include <boost/spirit/core.hpp>
@@ -53 +57 @@
 namespace mapnik
 {    
-    using std::string;
-    using std::clog;
-    using std::stack;
-
-    template <typename FeatureT>
-    struct push_integer
-    {
-        push_integer(stack<shared_ptr<expression<FeatureT> > >& exprs)
+   using std::string;
+   using std::clog;
+   using std::stack;
+
+   template <typename FeatureT>
+   struct push_integer
+   {
+         push_integer(stack<shared_ptr<expression<FeatureT> > >& exprs)
             : exprs_(exprs) {}
         
-        void operator() (int val) const
-        {
+         void operator() (int val) const
+         {
             exprs_.push(shared_ptr<expression<FeatureT> >
                         ( new literal<FeatureT>(val)));
-        }
-        stack<shared_ptr<expression<FeatureT> > >& exprs_;
-    };
+         }
+         stack<shared_ptr<expression<FeatureT> > >& exprs_;
+   };
    
-    template <typename FeatureT>
-    struct push_real
-    {
-        push_real(stack<shared_ptr<expression<FeatureT> > >& exprs)
+   template <typename FeatureT>
+   struct push_real
+   {
+         push_real(stack<shared_ptr<expression<FeatureT> > >& exprs)
             : exprs_(exprs) {}
-        void operator() (double val) const
-        {
+         void operator() (double val) const
+         {
             exprs_.push(shared_ptr<expression<FeatureT> >(new literal<FeatureT>(val)));
-        }
-        stack<shared_ptr<expression<FeatureT> > >& exprs_;
-    };
-    
-    template <typename FeatureT>
-    struct push_string
-    {
-        push_string(stack<shared_ptr<expression<FeatureT> > >& exprs)
+         }
+         stack<shared_ptr<expression<FeatureT> > >& exprs_;
+   };
+    
+   template <typename FeatureT>
+   struct push_string
+   {
+         push_string(stack<shared_ptr<expression<FeatureT> > >& exprs, transcoder const& tr)
+            : exprs_(exprs),
+              tr_(tr) {}
+         
+         template <typename Iter>
+         void operator() (Iter start,Iter end) const
+         {
+            UnicodeString unicode = tr_.transcode(std::string(start,end).c_str());
+            exprs_.push(shared_ptr<expression<FeatureT> >(new literal<FeatureT>(unicode)));
+         }
+         stack<shared_ptr<expression<FeatureT> > >& exprs_;
+         transcoder const& tr_;
+   };
+    
+   template <typename FeatureT>
+   struct push_property
+   {
+         push_property(stack<shared_ptr<expression<FeatureT> > >& exprs)
             : exprs_(exprs) {}
         
-        template <typename Iter>
-        void operator() (Iter start,Iter end) const
-        {
-           //std::wstring str(start,end);
-           //std::wstring quote = L"\\";
-           //std::wstring::size_type idx;
-           //idx = str.find(quote);
-           //while (idx != string::npos)
-           ///{                 
-           //   str.erase(idx,1);
-           //    idx = str.find(quote);
-           //}
-           UnicodeString str(start,end-start);
-           exprs_.push(shared_ptr<expression<FeatureT> >(new literal<FeatureT>(str)));
-        }
-        stack<shared_ptr<expression<FeatureT> > >& exprs_;
-    };
-    
-    template <typename FeatureT>
-    struct push_property
-    {
-        push_property(stack<shared_ptr<expression<FeatureT> > >& exprs)
-            : exprs_(exprs) {}
-        
-        template <typename Iter>
-        void operator() (Iter start,Iter end) const
-        {
+         template <typename Iter>
+         void operator() (Iter start,Iter end) const
+         {
             string str(start,end);
             exprs_.push(shared_ptr<expression<FeatureT> >(new property<FeatureT>(str)));
-        }
-        stack<shared_ptr<expression<FeatureT> > >& exprs_;
-    };
-
-    template <typename FeatureT,typename Op>
-    struct compose_expression
-    {
-        compose_expression(stack<shared_ptr<expression<FeatureT> > >& exprs)
+         }
+         stack<shared_ptr<expression<FeatureT> > >& exprs_;
+   };
+
+   template <typename FeatureT,typename Op>
+   struct compose_expression
+   {
+         compose_expression(stack<shared_ptr<expression<FeatureT> > >& exprs)
             : exprs_(exprs) {}
 
-        template <typename Iter>
-        void operator() (Iter,Iter) const
-        {
+         template <typename Iter>
+         void operator() (Iter,Iter) const
+         {
             if (exprs_.size()>=2)
             {
-                shared_ptr<expression<FeatureT> > right = exprs_.top();
-                exprs_.pop();
-                shared_ptr<expression<FeatureT> > left = exprs_.top();
-                exprs_.pop();
-                if (left && right)
-                {
-                    exprs_.push(shared_ptr<expression<FeatureT> >
-                                (new mapnik::math_expr_b<FeatureT,Op>(*left,*right)));
-                }
-            }
-        }
-        stack<shared_ptr<expression<FeatureT> > >& exprs_;
-    };
-    
-    template <typename FeatureT>
-    struct compose_regex
-    {
-        compose_regex(stack<shared_ptr<filter<FeatureT> > >& filters,
-                      stack<shared_ptr<expression<FeatureT> > >& exprs)
-            : filters_(filters),exprs_(exprs) {}
-
-        template <typename Iter>
-        void operator() (Iter start,Iter end) const
-        {
-            if (exprs_.size()>=1)
-            {
-                shared_ptr<expression<FeatureT> > exp = exprs_.top();
-                exprs_.pop();
-                if (exp)
-                {                   
-                    std::string pattern(start,end);
-                    try 
-                    {
-                        filters_.push(shared_ptr<filter<FeatureT> >
-                                      (new regex_filter<FeatureT>(*exp,pattern)));
-                    }
-                    catch (...)//boost::regex_error& ex)
-                    {
-                        clog<<"error\n";//ex.what()<<"\n";
-                    }
-                    
-                }
-            }
-        }
-        stack<shared_ptr<filter<FeatureT> > >& filters_;
-        stack<shared_ptr<expression<FeatureT> > >& exprs_;
-    };
-
-  
-    template <typename FeatureT,typename Op>
-    struct compose_filter
-    {
-        compose_filter(stack<shared_ptr<filter<FeatureT> > >& filters,
+               shared_ptr<expression<FeatureT> > right = exprs_.top();
+               exprs_.pop();
+               shared_ptr<expression<FeatureT> > left = exprs_.top();
+               exprs_.pop();
+               if (left && right)
+               {
+                  exprs_.push(shared_ptr<expression<FeatureT> >
+                              (new mapnik::math_expr_b<FeatureT,Op>(*left,*right)));
+               }
+            }
+         }
+         stack<shared_ptr<expression<FeatureT> > >& exprs_;
+   };
+    
+   template <typename FeatureT>
+   struct compose_regex
+   {
+         compose_regex(stack<shared_ptr<filter<FeatureT> > >& filters,
                        stack<shared_ptr<expression<FeatureT> > >& exprs)
             : filters_(filters),exprs_(exprs) {}
 
-        template <typename Iter>
-        void operator() (Iter,Iter) const
-        {
+         template <typename Iter>
+         void operator() (Iter start,Iter end) const
+         {
+            if (exprs_.size()>=1)
+            {
+               shared_ptr<expression<FeatureT> > exp = exprs_.top();
+               exprs_.pop();
+               if (exp)
+               {                    
+                  std::string pattern(start,end);
+                  try 
+                  {
+                     filters_.push(shared_ptr<filter<FeatureT> >
+                                   (new regex_filter<FeatureT>(*exp,pattern)));
+                  }
+                  catch (...)//boost::regex_error& ex)
+                  {
+                     clog<<"error\n";//ex.what()<<"\n";
+                  }
+                    
+               }
+            }
+         }
+         stack<shared_ptr<filter<FeatureT> > >& filters_;
+         stack<shared_ptr<expression<FeatureT> > >& exprs_;
+   };
+
+  
+   template <typename FeatureT,typename Op>
+   struct compose_filter
+   {
+         compose_filter(stack<shared_ptr<filter<FeatureT> > >& filters,
+                        stack<shared_ptr<expression<FeatureT> > >& exprs)
+            : filters_(filters),exprs_(exprs) {}
+
+         template <typename Iter>
+         void operator() (Iter,Iter) const
+         {
             if (exprs_.size()>=2)
             {
-                shared_ptr<expression<FeatureT> > right = exprs_.top();
-                exprs_.pop();
-                shared_ptr<expression<FeatureT> > left = exprs_.top();
-                exprs_.pop();
-                if (left && right)
-                {
-                    filters_.push(shared_ptr<filter<FeatureT> >(new compare_filter<FeatureT,Op>(*left,*right)));
-                }
-            }
-        }
-        stack<shared_ptr<filter<FeatureT> > >& filters_;
-        stack<shared_ptr<expression<FeatureT> > >& exprs_;
-    };
-    
-    template <typename FeatureT>
-    struct compose_and_filter
-    {
-        compose_and_filter(stack<shared_ptr<filter<FeatureT> > >& filters)
+               shared_ptr<expression<FeatureT> > right = exprs_.top();
+               exprs_.pop();
+               shared_ptr<expression<FeatureT> > left = exprs_.top();
+               exprs_.pop();
+               if (left && right)
+               {
+                  filters_.push(shared_ptr<filter<FeatureT> >(new compare_filter<FeatureT,Op>(*left,*right)));
+               }
+            }
+         }
+         stack<shared_ptr<filter<FeatureT> > >& filters_;
+         stack<shared_ptr<expression<FeatureT> > >& exprs_;
+   };
+    
+   template <typename FeatureT>
+   struct compose_and_filter
+   {
+         compose_and_filter(stack<shared_ptr<filter<FeatureT> > >& filters)
             : filters_(filters) {}
 
-        template <typename Iter>
-        void operator() (Iter,Iter) const
-        {
+         template <typename Iter>
+         void operator() (Iter,Iter) const
+         {
             if (filters_.size()>=2)
             {
-                shared_ptr<filter<FeatureT> > right = filters_.top();
-                filters_.pop();
-                shared_ptr<filter<FeatureT> > left = filters_.top();
-                filters_.pop();
-                if (left && right)
-                {
-                    filters_.push(shared_ptr<filter<FeatureT> >
-                                  (new logical_and<FeatureT>(*left,*right)));
-                }
-            }
-        }
-        stack<shared_ptr<filter<FeatureT> > >& filters_;
-    };
-    
-    template <typename FeatureT>
-    struct compose_or_filter
-    {
-        compose_or_filter(stack<shared_ptr<filter<FeatureT> > >& filters)
+               shared_ptr<filter<FeatureT> > right = filters_.top();
+               filters_.pop();
+               shared_ptr<filter<FeatureT> > left = filters_.top();
+               filters_.pop();
+               if (left && right)
+               {
+                  filters_.push(shared_ptr<filter<FeatureT> >
+                                (new logical_and<FeatureT>(*left,*right)));
+               }
+            }
+         }
+         stack<shared_ptr<filter<FeatureT> > >& filters_;
+   };
+    
+   template <typename FeatureT>
+   struct compose_or_filter
+   {
+         compose_or_filter(stack<shared_ptr<filter<FeatureT> > >& filters)
             : filters_(filters) {}
 
-        template <typename Iter>
-        void operator() (Iter,Iter) const
-        {
+         template <typename Iter>
+         void operator() (Iter,Iter) const
+         {
             if (filters_.size()>=2)
             {
-                shared_ptr<filter<FeatureT> > right = filters_.top();
-                filters_.pop();
-                shared_ptr<filter<FeatureT> > left = filters_.top();
-                filters_.pop();
-                if (left && right)
-                {
-                    filters_.push(shared_ptr<filter<FeatureT> >
-                                  (new logical_or<FeatureT>(*left,*right)));
-                }
-            }
-        }
-        stack<shared_ptr<filter<FeatureT> > >& filters_;
-    };
-    
-    template <typename FeatureT>
-    struct compose_not_filter
-    {
-        compose_not_filter(stack<shared_ptr<filter<FeatureT> > >& filters)
+               shared_ptr<filter<FeatureT> > right = filters_.top();
+               filters_.pop();
+               shared_ptr<filter<FeatureT> > left = filters_.top();
+               filters_.pop();
+               if (left && right)
+               {
+                  filters_.push(shared_ptr<filter<FeatureT> >
+                                (new logical_or<FeatureT>(*left,*right)));
+               }
+            }
+         }
+         stack<shared_ptr<filter<FeatureT> > >& filters_;
+   };
+    
+   template <typename FeatureT>
+   struct compose_not_filter
+   {
+         compose_not_filter(stack<shared_ptr<filter<FeatureT> > >& filters)
             : filters_(filters) {}
 
-        template <typename Iter>
-        void operator() (Iter,Iter) const
-        {
+         template <typename Iter>
+         void operator() (Iter,Iter) const
+         {
             if (filters_.size()>=1)
             {
-                shared_ptr<filter<FeatureT> > filter_ = filters_.top();
-                filters_.pop();
-                if (filter_)
-                {
-                    filters_.push(shared_ptr<filter<FeatureT> >(new logical_not<FeatureT>(*filter_)));
-                }
-            }
-        }
-        stack<shared_ptr<filter<FeatureT> > >& filters_;
-    };
-    
-    template <typename FeatureT>
-    struct filter_grammar : public grammar<filter_grammar<FeatureT> >
-    {
-        filter_grammar(stack<shared_ptr<filter<FeatureT> > >& filters_,
-                       stack<shared_ptr<expression<FeatureT> > >& exprs_)
-            : filters(filters_),exprs(exprs_) {}
-        
-        template <typename ScannerT>
-        struct definition
-        {
-            definition(filter_grammar const& self)
-            {   
-                typedef boost::spirit::chset<wchar_t> chset_t;
-
-                func1_op = "sqrt","sin","cos";
-                func2_op = "min","max";
-                spatial_op = "Equals","Disjoint","Touches","Within","Overlaps",
-                    "Crosses","Intersects","Contains","DWithin","Beyond","BBOX";
-                
-                chset_t BaseChar (L"\x41-\x5A\x61-\x7A\xC0-\xD6\xD8-\xF6\xF8-\xFF\x100-\x131\x134-\x13E"
-                                  L"\x141-\x148\x14A-\x17E\x180-\x1C3\x1CD-\x1F0\x1F4-\x1F5\x1FA-\x217"
-                                  L"\x250-\x2A8\x2BB-\x2C1\x386\x388-\x38A\x38C\x38E-\x3A1\x3A3-\x3CE"
-                                  L"\x3D0-\x3D6\x3DA\x3DC\x3DE\x3E0\x3E2-\x3F3\x401-\x40C\x40E-\x44F"
-                                  L"\x451-\x45C\x45E-\x481\x490-\x4C4\x4C7-\x4C8\x4CB-\x4CC\x4D0-\x4EB"
-                                  L"\x4EE-\x4F5\x4F8-\x4F9\x531-\x556\x559\x561-\x586\x5D0-\x5EA"
-                                  L"\x5F0-\x5F2\x621-\x63A\x641-\x64A\x671-\x6B7\x6BA-\x6BE\x6C0-\x6CE"
-                                  L"\x6D0-\x6D3\x6D5\x6E5-\x6E6\x905-\x939\x93D\x958-\x961\x985-\x98C"
-                                  L"\x98F-\x990\x993-\x9A8\x9AA-\x9B0\x9B2\x9B6-\x9B9\x9DC-\x9DD"
-                                  L"\x9DF-\x9E1\x9F0-\x9F1\xA05-\xA0A\xA0F-\xA10\xA13-\xA28\xA2A-\xA30"
-                                  L"\xA32-\xA33\xA35-\xA36\xA38-\xA39\xA59-\xA5C\xA5E\xA72-\xA74"
-                                  L"\xA85-\xA8B\xA8D\xA8F-\xA91\xA93-\xAA8\xAAA-\xAB0\xAB2-\xAB3"
-                                  L"\xAB5-\xAB9\xABD\xAE0\xB05-\xB0C\xB0F-\xB10\xB13-\xB28\xB2A-\xB30"
-                                  L"\xB32-\xB33\xB36-\xB39\xB3D\xB5C-\xB5D\xB5F-\xB61\xB85-\xB8A"
-                                  L"\xB8E-\xB90\xB92-\xB95\xB99-\xB9A\xB9C\xB9E-\xB9F\xBA3-\xBA4"
-                                  L"\xBA8-\xBAA\xBAE-\xBB5\xBB7-\xBB9\xC05-\xC0C\xC0E-\xC10\xC12-\xC28"
-                                  L"\xC2A-\xC33\xC35-\xC39\xC60-\xC61\xC85-\xC8C\xC8E-\xC90\xC92-\xCA8"
-                                  L"\xCAA-\xCB3\xCB5-\xCB9\xCDE\xCE0-\xCE1\xD05-\xD0C\xD0E-\xD10"
-                                  L"\xD12-\xD28\xD2A-\xD39\xD60-\xD61\xE01-\xE2E\xE30\xE32-\xE33"
-                                  L"\xE40-\xE45\xE81-\xE82\xE84\xE87-\xE88\xE8A\xE8D\xE94-\xE97"
-                                  L"\xE99-\xE9F\xEA1-\xEA3\xEA5\xEA7\xEAA-\xEAB\xEAD-\xEAE\xEB0"
-                                  L"\xEB2-\xEB3\xEBD\xEC0-\xEC4\xF40-\xF47\xF49-\xF69\x10A0-\x10C5"
-                                  L"\x10D0-\x10F6\x1100\x1102-\x1103\x1105-\x1107\x1109\x110B-\x110C"
-                                  L"\x110E-\x1112\x113C\x113E\x1140\x114C\x114E\x1150\x1154-\x1155"
-                                  L"\x1159\x115F-\x1161\x1163\x1165\x1167\x1169\x116D-\x116E"
-                                  L"\x1172-\x1173\x1175\x119E\x11A8\x11AB\x11AE-\x11AF\x11B7-\x11B8"
-                                  L"\x11BA\x11BC-\x11C2\x11EB\x11F0\x11F9\x1E00-\x1E9B\x1EA0-\x1EF9"
-                                  L"\x1F00-\x1F15\x1F18-\x1F1D\x1F20-\x1F45\x1F48-\x1F4D\x1F50-\x1F57"
-                                  L"\x1F59\x1F5B\x1F5D\x1F5F-\x1F7D\x1F80-\x1FB4\x1FB6-\x1FBC\x1FBE"
-                                  L"\x1FC2-\x1FC4\x1FC6-\x1FCC\x1FD0-\x1FD3\x1FD6-\x1FDB\x1FE0-\x1FEC"
-                                  L"\x1FF2-\x1FF4\x1FF6-\x1FFC\x2126\x212A-\x212B\x212E\x2180-\x2182"
-                                  L"\x3041-\x3094\x30A1-\x30FA\x3105-\x312C\xAC00-\xD7A3");
+               shared_ptr<filter<FeatureT> > filter_ = filters_.top();
+               filters_.pop();
+               if (filter_)
+               {
+                  filters_.push(shared_ptr<filter<FeatureT> >(new logical_not<FeatureT>(*filter_)));
+               }
+            }
+         }
+         stack<shared_ptr<filter<FeatureT> > >& filters_;
+   };
+    
+   template <typename FeatureT>
+   struct filter_grammar : public grammar<filter_grammar<FeatureT> >
+   {
+         filter_grammar(stack<shared_ptr<filter<FeatureT> > >& filters_,
+                        stack<shared_ptr<expression<FeatureT> > >& exprs_,
+                        transcoder const& tr_)
+            : filters(filters_),
+              exprs(exprs_),
+              tr(tr_) {}
+         
+         template <typename ScannerT>
+         struct definition
+         {
+               definition(filter_grammar const& self)
+               {        
+                  typedef boost::spirit::chset<wchar_t> chset_t;
+
+                  func1_op = "sqrt","sin","cos";
+                  func2_op = "min","max";
+                  spatial_op = "Equals","Disjoint","Touches","Within","Overlaps",
+                     "Crosses","Intersects","Contains","DWithin","Beyond","BBOX";
+                  
+                  chset_t BaseChar (L"\x41-\x5A\x61-\x7A\xC0-\xD6\xD8-\xF6\xF8-\xFF\x100-\x131\x134-\x13E"
+                                    L"\x141-\x148\x14A-\x17E\x180-\x1C3\x1CD-\x1F0\x1F4-\x1F5\x1FA-\x217"
+                                    L"\x250-\x2A8\x2BB-\x2C1\x386\x388-\x38A\x38C\x38E-\x3A1\x3A3-\x3CE"
+                                    L"\x3D0-\x3D6\x3DA\x3DC\x3DE\x3E0\x3E2-\x3F3\x401-\x40C\x40E-\x44F"
+                                    L"\x451-\x45C\x45E-\x481\x490-\x4C4\x4C7-\x4C8\x4CB-\x4CC\x4D0-\x4EB"
+                                    L"\x4EE-\x4F5\x4F8-\x4F9\x531-\x556\x559\x561-\x586\x5D0-\x5EA"
+                                    L"\x5F0-\x5F2\x621-\x63A\x641-\x64A\x671-\x6B7\x6BA-\x6BE\x6C0-\x6CE"
+                                    L"\x6D0-\x6D3\x6D5\x6E5-\x6E6\x905-\x939\x93D\x958-\x961\x985-\x98C"
+                                    L"\x98F-\x990\x993-\x9A8\x9AA-\x9B0\x9B2\x9B6-\x9B9\x9DC-\x9DD"
+                            &n