dotgnu-pnet-commits
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Dotgnu-pnet-commits] CVS: pnetlib/runtime/System String.cs, 1.36, 1.37


From: Rhys Weatherley <address@hidden>
Subject: [Dotgnu-pnet-commits] CVS: pnetlib/runtime/System String.cs, 1.36, 1.37
Date: Fri, 29 Aug 2003 00:25:00 -0400

Update of /cvsroot/dotgnu-pnet/pnetlib/runtime/System
In directory subversions:/tmp/cvs-serv24176/runtime/System

Modified Files:
        String.cs 
Log Message:


Pass all string comparisons through the culture routines; remove the
"InternalCompare" internalcall and replace with a new one for the
invariant culture.


Index: String.cs
===================================================================
RCS file: /cvsroot/dotgnu-pnet/pnetlib/runtime/System/String.cs,v
retrieving revision 1.36
retrieving revision 1.37
diff -C2 -r1.36 -r1.37
*** String.cs   17 Jul 2003 08:13:27 -0000      1.36
--- String.cs   29 Aug 2003 04:24:56 -0000      1.37
***************
*** 108,123 ****
        // Internal version of "Compare", with all parameters.
        [MethodImpl(MethodImplOptions.InternalCall)]
!       extern internal static int InternalCompare
                                (String strA, int indexA, int lengthA,
                                 String strB, int indexB, int lengthB,
!                                bool ignoreCase, CultureInfo culture);
  
        // Compare two strings while optionally ignoring case.
        public static int Compare(String strA, String strB, bool ignoreCase)
                        {
!                               return InternalCompare
!                                               (strA, 0, ((strA != null) ? 
strA.Length : 0),
!                                            strB, 0, ((strB != null) ? 
strB.Length : 0),
!                                            ignoreCase, null);
                        }
  
--- 108,123 ----
        // Internal version of "Compare", with all parameters.
        [MethodImpl(MethodImplOptions.InternalCall)]
!       extern internal static int CompareInternal
                                (String strA, int indexA, int lengthA,
                                 String strB, int indexB, int lengthB,
!                                bool ignoreCase);
  
        // Compare two strings while optionally ignoring case.
        public static int Compare(String strA, String strB, bool ignoreCase)
                        {
!                               return CultureInfo.CurrentCulture.CompareInfo
!                                                       .Compare(strA, strB,
!                                                                        
(ignoreCase ? CompareOptions.IgnoreCase
!                                                                               
                 : CompareOptions.None));
                        }
  
***************
*** 131,138 ****
                                        throw new 
ArgumentNullException("culture");
                                }
!                               return InternalCompare
!                                               (strA, 0, ((strA != null) ? 
strA.Length : 0),
!                                                strB, 0, ((strB != null) ? 
strB.Length : 0),
!                                                ignoreCase, culture);
                        }
  #endif
--- 131,138 ----
                                        throw new 
ArgumentNullException("culture");
                                }
!                               return culture.CompareInfo
!                                                       .Compare(strA, strB,
!                                                                        
(ignoreCase ? CompareOptions.IgnoreCase
!                                                                               
                 : CompareOptions.None));
                        }
  #endif
***************
*** 217,224 ****
                                                          int length)
                        {
!                               ValidateCompare(strA, indexA, strB, indexB, 
length);
!                               return InternalCompare(strA, indexA, length,
!                                                                          
strB, indexB, length,
!                                                                          
false, null);
                        }
  
--- 217,224 ----
                                                          int length)
                        {
!                               return CultureInfo.CurrentCulture.CompareInfo
!                                                       .Compare(strA, indexA, 
length,
!                                                                        strB, 
indexB, length,
!                                                                        
CompareOptions.None);
                        }
  
***************
*** 228,235 ****
                                                          int length, bool 
ignoreCase)
                        {
!                               ValidateCompare(strA, indexA, strB, indexB, 
length);
!                               return InternalCompare(strA, indexA, length,
!                                                                          
strB, indexB, length,
!                                                                          
ignoreCase, null);
                        }
  
--- 228,236 ----
                                                          int length, bool 
ignoreCase)
                        {
!                               return CultureInfo.CurrentCulture.CompareInfo
!                                                       .Compare(strA, indexA, 
length,
!                                                                        strB, 
indexB, length,
!                                                                        
(ignoreCase ? CompareOptions.IgnoreCase
!                                                                               
                 : CompareOptions.None));
                        }
  
***************
*** 249,256 ****
                                        throw new 
ArgumentNullException("culture");
                                }
!                               ValidateCompare(strA, indexA, strB, indexB, 
length);
!                               return InternalCompare(strA, indexA, length,
!                                                                          
strB, indexB, length,
!                                                                          
ignoreCase, culture);
                        }
  
--- 250,258 ----
                                        throw new 
ArgumentNullException("culture");
                                }
!                               return culture.CompareInfo
!                                                       .Compare(strA, indexA, 
length,
!                                                                        strB, 
indexB, length,
!                                                                        
(ignoreCase ? CompareOptions.IgnoreCase
!                                                                               
                 : CompareOptions.None));
                        }
  





reply via email to

[Prev in Thread] Current Thread [Next in Thread]