Example #1
0
   bool run(String string,int pos,int len)
   {
      #ifdef HX_SMART_STRINGS
      if (string.isUTF16Encoded())
      {
         if (!rUtf16)
         {
            const char *error = 0;
            int err_offset = 0;
            hx::strbuf buf;
            rUtf16 = pcre16_compile((PCRE_SPTR16)expr.wc_str(&buf),flags|PCRE_UTF16,&error,&err_offset,NULL);
            if (!rUtf16)
            {
               return false;
            }
         }

         int n =  pcre16_exec(rUtf16,NULL,(const unsigned short *)string.raw_wptr(),pos+len,pos,0,matchs,nmatchs * 3);
         return n>=0;
      }

      if (!rUtf8)
      {
         rUtf8 =  pcre_compile(expr.utf8_str(),flags|PCRE_UTF8,0,0,0);
         if (!rUtf8)
            return false;
      }

      #endif
      return pcre_exec(rUtf8,NULL,string.utf8_str(),pos+len,pos,0,matchs,nmatchs * 3) >= 0;
   }
Example #2
0
Dynamic _hx_regexp_new_options(String s, String opt)
{
   hx::strbuf buf;
   const char *o = opt.utf8_str(&buf);
   int options = PCRE_UCP;
   while( *o )
   {
      switch( *o++ )
      {
      case 'i':
         options |= PCRE_CASELESS;
         break;
      case 's':
         options |= PCRE_DOTALL;
         break;
      case 'm':
         options |= PCRE_MULTILINE;
         break;
      case 'g':
         options |= PCRE_UNGREEDY;
         break;
      case 'u':
         break;
      default:
         hx::Throw( HX_CSTRING("Regexp unknown modifier : ") + String::fromCharCode(o[-1]) );
         break;
      }
   }

   #ifdef HX_SMART_STRINGS
   if (s.isUTF16Encoded())
   {
      const char *error = 0;
      int err_offset = 0;
      pcre16 *p =  pcre16_compile((PCRE_SPTR16)s.raw_wptr(),options|PCRE_UTF16,&error,&err_offset,NULL);
      if( !p )
         hx::Throw( HX_CSTRING("Regexp compilation error : ")+String(error)+HX_CSTRING(" in ")+s);

      pcredata *pdata = new pcredata;
      pdata->create16(p,s,options);
      return pdata;
   }
   else
   #endif
   {
      const char *error = 0;
      int err_offset = 0;

      pcre *p =  pcre_compile(s.utf8_str(),options|PCRE_UTF8,&error,&err_offset,NULL);
      if( !p )
         hx::Throw( HX_CSTRING("Regexp compilation error : ")+String(error)+HX_CSTRING(" in ")+s);

      pcredata *pdata = new pcredata;
      pdata->create8(p,s,options);
      return pdata;
   }
}
Example #3
0
double __hxcpp_parse_float(const String &inString)
{
   if (!inString.raw_ptr())
      return Math_obj::NaN;

   hx::strbuf buf;
   const char *str = inString.utf8_str(&buf);
   char *end = (char *)str;
   double result = str ? strtod(str,&end) : 0;

   if (end==str)
      return Math_obj::NaN;

   return result;
}
Example #4
0
Dynamic __hxcpp_parse_int(const String &inString)
{
   if (!inString.raw_ptr())
      return null();
   long result;
   hx::strbuf buf;
   const char *str = inString.utf8_str(&buf);
   bool hex =  (str[0]=='0' && (str[1]=='x' || str[1]=='X'));
   char *end = 0;

   if (hex)
      result = (long)strtoul(str+2,&end,16);
   else
      result = strtol(str,&end,10);
   if (str==end)
      return null();
   return (int)result;
}
Example #5
0
// encode the given text unconditionally, i.e. without checking if it must be
// encoded (this is supposed to be done in the caller) and using the specified
// encodings and charset (which are supposed to be detected by the caller too)
static String
EncodeText(const String& in,
           wxFontEncoding enc,
           MIME::Encoding enc2047,
           const String& csName)
{
   // encode the word splitting it in the chunks such that they will be no
   // longer than 75 characters each
   wxCharBuffer buf(in.mb_str(wxCSConv(enc)));
   if ( !buf )
   {
      // if the header can't be encoded using the given encoding, use UTF-8
      // which always works
      buf = in.utf8_str();
   }

   String out;
   out.reserve(csName.length() + strlen(buf) + 7 /* for =?...?X?...?= */);

   const char *s = buf;
   while ( *s )
   {
      // if we wrapped, insert a line break
      if ( !out.empty() )
         out += "\r\n  ";

      static const size_t RFC2047_MAXWORD_LEN = 75;

      // how many characters may we put in this encoded word?
      size_t len = 0;

      // take into account the length of "=?charset?...?="
      int lenRemaining = RFC2047_MAXWORD_LEN - (5 + csName.length());

      // for QP we need to examine all characters
      if ( enc2047 == MIME::Encoding_QuotedPrintable )
      {
         for ( ; s[len]; len++ )
         {
            const char c = s[len];

            // normal characters stand for themselves in QP, the encoded ones
            // take 3 positions (=XX)
            lenRemaining -= (NeedsEncodingInHeader(c) || strchr(" \t=?", c))
                              ? 3 : 1;

            if ( lenRemaining <= 0 )
            {
               // can't put any more chars into this word
               break;
            }
         }
      }
      else // Base64
      {
         // rfc822_binary() splits lines after 60 characters so don't make
         // chunks longer than this as the base64-encoded headers can't have
         // EOLs in them
         static const int CCLIENT_MAX_BASE64_LEN = 60;

         if ( lenRemaining > CCLIENT_MAX_BASE64_LEN )
            lenRemaining = CCLIENT_MAX_BASE64_LEN;

         // we can calculate how many characters we may put into lenRemaining
         // directly
         len = (lenRemaining / 4) * 3 - 2;

         // but not more than what we have
         size_t lenMax = wxStrlen(s);
         if ( len > lenMax )
         {
            len = lenMax;
         }
      }

      // do encode this word
      unsigned char *text = (unsigned char *)s; // cast for cclient

      // length of the encoded text and the text itself
      unsigned long lenEnc;
      unsigned char *textEnc;

      if ( enc2047 == MIME::Encoding_QuotedPrintable )
      {
            textEnc = rfc822_8bit(text, len, &lenEnc);
      }
      else // Encoding_Base64
      {
            textEnc = rfc822_binary(text, len, &lenEnc);
            while ( textEnc[lenEnc - 2] == '\r' && textEnc[lenEnc - 1] == '\n' )
            {
               // discard eol which we don't need in the header
               lenEnc -= 2;
            }
      }

      // put into string as we might want to do some more replacements...
      String encword(wxString::FromAscii(CHAR_CAST(textEnc), lenEnc));

      // hack: rfc822_8bit() doesn't encode spaces normally but we must
      // do it inside the headers
      //
      // we also have to encode '?'s in the headers which are not encoded by it
      if ( enc2047 == MIME::Encoding_QuotedPrintable )
      {
         String encword2;
         encword2.reserve(encword.length());

         bool replaced = false;
         for ( const wxChar *p = encword.c_str(); *p; p++ )
         {
            switch ( *p )
            {
               case ' ':
                  encword2 += _T("=20");
                  break;

               case '\t':
                  encword2 += _T("=09");
                  break;

               case '?':
                  encword2 += _T("=3F");
                  break;

               default:
                  encword2 += *p;

                  // skip assignment to replaced below
                  continue;
            }

            replaced = true;
         }

         if ( replaced )
         {
            encword = encword2;
         }
      }

      // append this word to the header
      out << _T("=?") << csName << _T('?') << (char)enc2047 << _T('?')
          << encword
          << _T("?=");

      fs_give((void **)&textEnc);

      // skip the already encoded part
      s += len;
   }

   return out;
}