Compared files  

Left
C:\SDK\wxWidgets-2.6.2\contrib\src\stc\scintilla\src\PropSet.cxx
Last modified2005-03-21 12:17:54.000 +0100
Size27 Kb (1086 Lines)
EncodingLatin 1 - ANSI (CP1252) default
Right
C:\SDK\wxWidgets-2.6.3\contrib\src\stc\scintilla\src\PropSet.cxx
Last modified2006-03-16 13:07:08.000 +0100
Size28.8 Kb (1171 Lines)
EncodingLatin 1 - ANSI (CP1252) default


   Comparison Statistics  

Detailed Statistics

All Changes
 BlocksLines
Unchanged221071
Inserted1293
Deleted28
Ignored00
Changed714



   Comparison Details  

328 skipped lines
329 329  
330 330 // End SString functions
331 331  
  332 bool PropSet::caseSensitiveFilenames = false;
  333  
332 334 PropSet::PropSet() {
333 335     superPS = 0;
334 336     for (int root = 0; root < hashRoots; root++)
124 skipped lines
459 461     VarChain(const char*var_=NULL, const VarChain *link_=NULL): var(var_), link(link_) {}
460 462  
461 463     bool contains(const char *testVar) const {
462         return (var && (0 == strcmp(var, testVar)))  464         return (var && (0 == strcmp(var, testVar)))
463 465         || (link && link->contains(testVar));
464 466     }
465 467  
70 skipped lines
536 538         return true;
537 539 }
538 540  
539 static bool IsSuffixCaseInsensitive(const char *target, const char *suffix) { 541 static bool IsSuffix(const char *target, const char *suffix, bool caseSensitive) {
540 542     size_t lentarget = strlen(target);
541 543     size_t lensuffix = strlen(suffix);
542 544     if (lensuffix > lentarget)
543 545         return false;
  546     if (caseSensitive) {
  547         for (int i = static_cast<int>(lensuffix) - 1; i >= 0; i--) {
  548         if (target[i + lentarget - lensuffix] != suffix[i])
  549         return false;
  550         }
  551     } else {
544 552     for (int i = static_cast<int>(lensuffix) - 1; i >= 0; i--) {
545 553         if (MakeUpperCase(target[i + lentarget - lensuffix]) !=
546 554                 MakeUpperCase(suffix[i]))
547 555         return false;
548 556     }
  557     }
549 558     return true;
550 559 }
551 560  
25 skipped lines
577 586         char delchr = *del;
578 587         *del = '\0';
579 588         if (*keyfile == '*') {
580         if (IsSuffixCaseInsensitive(filename, keyfile + 1)) { 589         if (IsSuffix(filename, keyfile + 1, caseSensitiveFilenames)) {
581 590         *del = delchr;
582 591         delete []keyptr;
583 592         return p->val;
206 skipped lines
790 799     list = 0;
791 800     len = 0;
792 801     sorted = false;
  802     sortedNoCase = false;
793 803 }
794 804  
795 805 void WordList::Set(const char *s) {
796 806     list = StringDup(s);
797 807     sorted = false;
  808     sortedNoCase = false;
798 809     words = ArrayFromWordList(list, &len, onlyLineEnds);
799 810     wordsNoCase = new char * [len + 1];
800 811     memcpy(wordsNoCase, words, (len + 1) * sizeof (*words));
7 skipped lines
808 819  
809 820 void WordList::SetFromAllocated() {
810 821     sorted = false;
  822     sortedNoCase = false;
811 823     words = ArrayFromWordList(list, &len, onlyLineEnds);
812 824     wordsNoCase = new char * [len + 1];
813 825     memcpy(wordsNoCase, words, (len + 1) * sizeof (*words));
9 skipped lines
823 835     return CompareCaseInsensitive(*(char**)(a1), *(char**)(a2));
824 836 }
825 837  
826 static void SortWordList(char **words, char **wordsNoCase, unsigned int len) { 838 static void SortWordList(char **words, unsigned int len) {
827 839     qsort(reinterpret_cast<void*>(words), len, sizeof(*words),
828 840           cmpString);
  841 }
  842  
  843 static void SortWordListNoCase(char **wordsNoCase, unsigned int len) {
829 844     qsort(reinterpret_cast<void*>(wordsNoCase), len, sizeof(*wordsNoCase),
830 845           cmpStringNoCase);
831 846 }
3 skipped lines
835 850         return false;
836 851     if (!sorted) {
837 852         sorted = true;
838         SortWordList(words, wordsNoCase, len); 853         SortWordList(words, len);
839 854         for (unsigned int k = 0; k < (sizeof(starts) / sizeof(starts[0])); k++)
840 855         starts[k] = -1;
841 856         for (int l = len - 1; l >= 0; l--) {
35 skipped lines
877 892     return false;
878 893 }
879 894  
  895 /** similar to InList, but word s can be a substring of keyword.
  896  * eg. the keyword define is defined as def~ine. This means the word must start
  897  * with def to be a keyword, but also defi, defin and define are valid.
  898  * The marker is ~ in this case.
  899  */
52 skipped lines
  952         }
  953     }
  954     return false;
  955 }
  956  
880 957 /**
881 958  * Returns an element (complete) of the wordlist array which has
882 959  * the same beginning as the passed string.
9 skipped lines
892 969  
893 970     if (0 == words)
894 971         return NULL;
895     if (!sorted) {  
896         sorted = true;  
897         SortWordList(words, wordsNoCase, len);  
898     }  
899 972     if (ignoreCase) {
  973         if (!sortedNoCase) {
  974         sortedNoCase = true;
  975         SortWordListNoCase(wordsNoCase, len);
  976         }
900 977         while (start <= end) { // binary searching loop
901 978         pivot = (start + end) >> 1;
902 979         word = wordsNoCase[pivot];
9 skipped lines
912 989         while (end < len-1 && !CompareNCaseInsensitive(wordStart, wordsNoCase[end+1], searchLen)) {
913 990         end++;
914 991         }
915           992  
916 993         // Finds first word in a series of equal words
917 994         for (pivot = start; pivot <= end; pivot++) {
918 995         word = wordsNoCase[pivot];
11 skipped lines
930 1007         end = pivot - 1;
931 1008         }
932 1009     } else { // preserve the letter case
  1010         if (!sorted) {
  1011         sorted = true;
  1012         SortWordList(words, len);
  1013         }
933 1014         while (start <= end) { // binary searching loop
934 1015         pivot = (start + end) >> 1;
935 1016         word = words[pivot];
9 skipped lines
945 1026         while (end < len-1 && !strncmp(wordStart, words[end+1], searchLen)) {
946 1027         end++;
947 1028         }
948           1029  
949 1030         // Finds first word in a series of equal words
950 1031         pivot = start;
951 1032         while (pivot <= end) {
68 skipped lines
1020 1101  
1021 1102     if (0 == words)
1022 1103         return NULL;
1023     if (!sorted) {  
1024         sorted = true;  
1025         SortWordList(words, wordsNoCase, len);  
1026     }  
1027 1104     if (ignoreCase) {
  1105         if (!sortedNoCase) {
  1106         sortedNoCase = true;
  1107         SortWordListNoCase(wordsNoCase, len);
  1108         }
1028 1109         while (start <= end) { // Binary searching loop
1029 1110         pivot = (start + end) / 2;
1030 1111         cond = CompareNCaseInsensitive(wordStart, wordsNoCase[pivot], searchLen);
22 skipped lines
1053 1134         }
1054 1135         }
1055 1136     } else {// Preserve the letter case
  1137         if (!sorted) {
  1138         sorted = true;
  1139         SortWordList(words, len);
  1140         }
1056 1141         while (start <= end) { // Binary searching loop
1057 1142         pivot = (start + end) / 2;
1058 1143         cond = strncmp(wordStart, words[pivot], searchLen);
28 skipped lines

   Text comparison Options  

Syntax colouring language used: C / C++
Match character case: yes.
Match line endings: no.
Match spaces

At start of lines: yes,
In middle of lines: yes,
At end of lines: yes.
Blank lines as empty lines: no.
Activate comparison algorithm
At word level: yes,
At character level: no.


   Legend  

Unchanged lineExample of unchanged line
Modified lineExample of modified line
Added lineExample of added line
Removed lineExample of removed line
Ignored lineExample of ignored line

This report has been generated by Ellié Computing Merge on 2006-09-07 15:48:33.001 +0200.
© 2005-2006 Ellié Computing http://www.elliecomputing.com. All rights reserved.