Fix recursion problems when loading pages from a virtual file system using the WebKit...

[wxWidgets.git] / src / common / strvararg.cpp

diff --git a/src/common/strvararg.cpp b/src/common/strvararg.cpp
index e89bdf35b593a78c80ec5a95ccf6a3776a20c961..a4c2256dfb474ac44d40fa4c977ecc5288a4d1e3 100644 (file)
--- a/src/common/strvararg.cpp
+++ b/src/common/strvararg.cpp
@@ -152,30 +152,30 @@ public:
         m_nCopied = 0;
     }
 
         m_nCopied = 0;
     }
 

-    wxCharTypeBuffer<CharType> Convert(const CharType *format)
+    wxScopedCharTypeBuffer<CharType> Convert(const CharType *format)

     {
         // this is reset to NULL if we modify the format string
         m_fmtOrig = format;
 
         while ( *format )
         {
     {
         // this is reset to NULL if we modify the format string
         m_fmtOrig = format;
 
         while ( *format )
         {

-            if ( CopyFmtChar(*format++) == _T('%') )
+            if ( CopyFmtChar(*format++) == wxT('%') )

             {
                 // skip any flags
                 while ( IsFlagChar(*format) )
                     CopyFmtChar(*format++);
 
                 // and possible width
             {
                 // skip any flags
                 while ( IsFlagChar(*format) )
                     CopyFmtChar(*format++);
 
                 // and possible width

-                if ( *format == _T('*') )
+                if ( *format == wxT('*') )

                     CopyFmtChar(*format++);
                 else
                     SkipDigits(&format);
 
                 // precision?
                     CopyFmtChar(*format++);
                 else
                     SkipDigits(&format);
 
                 // precision?

-                if ( *format == _T('.') )
+                if ( *format == wxT('.') )

                 {
                     CopyFmtChar(*format++);
                 {
                     CopyFmtChar(*format++);

-                    if ( *format == _T('*') )
+                    if ( *format == wxT('*') )

                         CopyFmtChar(*format++);
                     else
                         SkipDigits(&format);
                         CopyFmtChar(*format++);
                     else
                         SkipDigits(&format);


@@ -211,16 +211,16 @@ public:
                 // and finally we should have the type
                 switch ( *format )
                 {
                 // and finally we should have the type
                 switch ( *format )
                 {

-                    case _T('S'):
-                    case _T('s'):
+                    case wxT('S'):
+                    case wxT('s'):

                         // all strings were converted into the same form by
                         // wxArgNormalizer<T>, this form depends on the context
                         // in which the value is used (scanf/printf/wprintf):
                         HandleString(*format, size, outConv, outSize);
                         break;
 
                         // all strings were converted into the same form by
                         // wxArgNormalizer<T>, this form depends on the context
                         // in which the value is used (scanf/printf/wprintf):
                         HandleString(*format, size, outConv, outSize);
                         break;
 

-                    case _T('C'):
-                    case _T('c'):
+                    case wxT('C'):
+                    case wxT('c'):

                         HandleChar(*format, size, outConv, outSize);
                         break;
 
                         HandleChar(*format, size, outConv, outSize);
                         break;
 


@@ -240,11 +240,11 @@ public:
                     switch ( outSize )
                     {
                         case Size_Long:
                     switch ( outSize )
                     {
                         case Size_Long:

-                            InsertFmtChar(_T('l'));
+                            InsertFmtChar(wxT('l'));

                             break;
 
                         case Size_Short:
                             break;
 
                         case Size_Short:

-                            InsertFmtChar(_T('h'));
+                            InsertFmtChar(wxT('h'));

                             break;
 
                         case Size_Default:
                             break;
 
                         case Size_Default:


@@ -263,12 +263,14 @@ public:
         // format
         if ( m_fmtOrig )
         {
         // format
         if ( m_fmtOrig )
         {

-            return wxCharTypeBuffer<CharType>::CreateNonOwned(m_fmtOrig);
+            return wxScopedCharTypeBuffer<CharType>::CreateNonOwned(m_fmtOrig);

         }
         else
         {
         }
         else
         {

-            // NULL-terminate converted format string:
-            *m_fmtLast = 0;
+            // shrink converted format string to actual size (instead of
+            // over-sized allocation from CopyAllBefore()) and NUL-terminate
+            // it:
+            m_fmt.shrink(m_fmtLast - m_fmt.data());

             return m_fmt;
         }
     }
             return m_fmt;
         }
     }


@@ -351,13 +353,13 @@ private:
 
     static bool IsFlagChar(CharType ch)
     {
 
     static bool IsFlagChar(CharType ch)
     {

-        return ch == _T('-') || ch == _T('+') ||
-               ch == _T('0') || ch == _T(' ') || ch == _T('#');
+        return ch == wxT('-') || ch == wxT('+') ||
+               ch == wxT('0') || ch == wxT(' ') || ch == wxT('#');

     }
 
     void SkipDigits(const CharType **ptpc)
     {
     }
 
     void SkipDigits(const CharType **ptpc)
     {

-        while ( **ptpc >= _T('0') && **ptpc <= _T('9') )
+        while ( **ptpc >= wxT('0') && **ptpc <= wxT('9') )

             CopyFmtChar(*(*ptpc)++);
     }
 
             CopyFmtChar(*(*ptpc)++);
     }
 


@@ -373,7 +375,7 @@ private:
     size_t m_nCopied;
 };
 
     size_t m_nCopied;
 };
 

-#ifdef __WINDOWS__
+#if defined(__WINDOWS__) && !defined(__CYGWIN__)

 
 // on Windows, we should use %s and %c regardless of the build:
 class wxPrintfFormatConverterWchar : public wxFormatConverterBase<wchar_t>
 
 // on Windows, we should use %s and %c regardless of the build:
 class wxPrintfFormatConverterWchar : public wxFormatConverterBase<wchar_t>


@@ -635,12 +637,15 @@ template<typename CharType>
 wxFormatString::ArgumentType DoGetArgumentType(const CharType *format,
                                                unsigned n)
 {
 wxFormatString::ArgumentType DoGetArgumentType(const CharType *format,
                                                unsigned n)
 {

-    wxCHECK_MSG( format, wxFormatString::Arg_Other,
+    wxCHECK_MSG( format, wxFormatString::Arg_Unknown,

                  "empty format string not allowed here" );
 
     wxPrintfConvSpecParser<CharType> parser(format);
 
                  "empty format string not allowed here" );
 
     wxPrintfConvSpecParser<CharType> parser(format);
 

-    wxCHECK_MSG( parser.pspec[n-1] != NULL, wxFormatString::Arg_Other,
+    wxCHECK_MSG( n <= parser.nargs, wxFormatString::Arg_Unknown,
+                 "more arguments than format string specifiers?" );
+
+    wxCHECK_MSG( parser.pspec[n-1] != NULL, wxFormatString::Arg_Unknown,

                  "requested argument not found - invalid format string?" );
 
     switch ( parser.pspec[n-1]->m_type )
                  "requested argument not found - invalid format string?" );
 
     switch ( parser.pspec[n-1]->m_type )


@@ -649,9 +654,48 @@ wxFormatString::ArgumentType DoGetArgumentType(const CharType *format,
         case wxPAT_WCHAR:
             return wxFormatString::Arg_Char;
 
         case wxPAT_WCHAR:
             return wxFormatString::Arg_Char;
 

-        default:
-            return wxFormatString::Arg_Other;
+        case wxPAT_PCHAR:
+        case wxPAT_PWCHAR:
+            return wxFormatString::Arg_String;
+
+        case wxPAT_INT:
+            return wxFormatString::Arg_Int;
+        case wxPAT_LONGINT:
+            return wxFormatString::Arg_LongInt;
+#ifdef wxLongLong_t
+        case wxPAT_LONGLONGINT:
+            return wxFormatString::Arg_LongLongInt;
+#endif
+        case wxPAT_SIZET:
+            return wxFormatString::Arg_Size_t;
+
+        case wxPAT_DOUBLE:
+            return wxFormatString::Arg_Double;
+        case wxPAT_LONGDOUBLE:
+            return wxFormatString::Arg_LongDouble;
+
+        case wxPAT_POINTER:
+            return wxFormatString::Arg_Pointer;
+
+        case wxPAT_NINT:
+            return wxFormatString::Arg_IntPtr;
+        case wxPAT_NSHORTINT:
+            return wxFormatString::Arg_ShortIntPtr;
+        case wxPAT_NLONGINT:
+            return wxFormatString::Arg_LongIntPtr;
+
+        case wxPAT_STAR:
+            // "*" requires argument of type int
+            return wxFormatString::Arg_Int;
+
+        case wxPAT_INVALID:
+            // (handled after the switch statement)
+            break;

     }
     }

+
+    // silence warning
+    wxFAIL_MSG( "unexpected argument type" );
+    return wxFormatString::Arg_Unknown;

 }
 
 } // anonymous namespace
 }
 
 } // anonymous namespace


@@ -668,5 +712,5 @@ wxFormatString::ArgumentType wxFormatString::GetArgumentType(unsigned n) const
         return DoGetArgumentType(m_cstr->AsInternal(), n);
 
     wxFAIL_MSG( "unreachable code" );
         return DoGetArgumentType(m_cstr->AsInternal(), n);
 
     wxFAIL_MSG( "unreachable code" );

-    return Arg_Other;
+    return Arg_Unknown;

 }
 }