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
329U329U 
330U330U// End SString functions
331U331U 
  332Abool PropSet::caseSensitiveFilenames = false;
  333A 
332U334UPropSet::PropSet() {
333U335U    superPS = 0;
334U336U    for (int root = 0; root < hashRoots; root++)
124 skipped lines
459U461U    VarChain(const char*var_=NULL, const VarChain *link_=NULL): var(var_), link(link_) {}
460U462U 
461U463U    bool contains(const char *testVar) const {
462C        return (var && (0 == strcmp(var, testVar)))  464C        return (var && (0 == strcmp(var, testVar)))
463U465U        || (link && link->contains(testVar));
464U466U    }
465U467U 
70 skipped lines
536U538U        return true;
537U539U}
538U540U 
539Cstatic bool IsSuffixCaseInsensitive(const char *target, const char *suffix) { 541Cstatic bool IsSuffix(const char *target, const char *suffix, bool caseSensitive) {
540U542U    size_t lentarget = strlen(target);
541U543U    size_t lensuffix = strlen(suffix);
542U544U    if (lensuffix > lentarget)
543U545U        return false;
  546A    if (caseSensitive) {
  547A        for (int i = static_cast<int>(lensuffix) - 1; i >= 0; i--) {
  548A        if (target[i + lentarget - lensuffix] != suffix[i])
  549A        return false;
  550A        }
  551A    } else {
544U552U    for (int i = static_cast<int>(lensuffix) - 1; i >= 0; i--) {
545U553U        if (MakeUpperCase(target[i + lentarget - lensuffix]) !=
546U554U                MakeUpperCase(suffix[i]))
547U555U        return false;
548U556U    }
  557A    }
549U558U    return true;
550U559U}
551U560U 
25 skipped lines
577U586U        char delchr = *del;
578U587U        *del = '\0';
579U588U        if (*keyfile == '*') {
580C        if (IsSuffixCaseInsensitive(filename, keyfile + 1)) { 589C        if (IsSuffix(filename, keyfile + 1, caseSensitiveFilenames)) {
581U590U        *del = delchr;
582U591U        delete []keyptr;
583U592U        return p->val;
206 skipped lines
790U799U    list = 0;
791U800U    len = 0;
792U801U    sorted = false;
  802A    sortedNoCase = false;
793U803U}
794U804U 
795U805Uvoid WordList::Set(const char *s) {
796U806U    list = StringDup(s);
797U807U    sorted = false;
  808A    sortedNoCase = false;
798U809U    words = ArrayFromWordList(list, &len, onlyLineEnds);
799U810U    wordsNoCase = new char * [len + 1];
800U811U    memcpy(wordsNoCase, words, (len + 1) * sizeof (*words));
7 skipped lines
808U819U 
809U820Uvoid WordList::SetFromAllocated() {
810U821U    sorted = false;
  822A    sortedNoCase = false;
811U823U    words = ArrayFromWordList(list, &len, onlyLineEnds);
812U824U    wordsNoCase = new char * [len + 1];
813U825U    memcpy(wordsNoCase, words, (len + 1) * sizeof (*words));
9 skipped lines
823U835U    return CompareCaseInsensitive(*(char**)(a1), *(char**)(a2));
824U836U}
825U837U 
826Cstatic void SortWordList(char **words, char **wordsNoCase, unsigned int len) { 838Cstatic void SortWordList(char **words, unsigned int len) {
827U839U    qsort(reinterpret_cast<void*>(words), len, sizeof(*words),
828U840U          cmpString);
  841A}
  842A 
  843Astatic void SortWordListNoCase(char **wordsNoCase, unsigned int len) {
829U844U    qsort(reinterpret_cast<void*>(wordsNoCase), len, sizeof(*wordsNoCase),
830U845U          cmpStringNoCase);
831U846U}
3 skipped lines
835U850U        return false;
836U851U    if (!sorted) {
837U852U        sorted = true;
838C        SortWordList(words, wordsNoCase, len); 853C        SortWordList(words, len);
839U854U        for (unsigned int k = 0; k < (sizeof(starts) / sizeof(starts[0])); k++)
840U855U        starts[k] = -1;
841U856U        for (int l = len - 1; l >= 0; l--) {
35 skipped lines
877U892U    return false;
878U893U}
879U894U 
  895A/** similar to InList, but word s can be a substring of keyword.
  896A * eg. the keyword define is defined as def~ine. This means the word must start
  897A * with def to be a keyword, but also defi, defin and define are valid.
  898A * The marker is ~ in this case.
  899A */
52 skipped lines
  952A        }
  953A    }
  954A    return false;
  955A}
  956A 
880U957U/**
881U958U * Returns an element (complete) of the wordlist array which has
882U959U * the same beginning as the passed string.
9 skipped lines
892U969U 
893U970U    if (0 == words)
894U971U        return NULL;
895R    if (!sorted) {  
896R        sorted = true;  
897R        SortWordList(words, wordsNoCase, len);  
898R    }  
899U972U    if (ignoreCase) {
  973A        if (!sortedNoCase) {
  974A        sortedNoCase = true;
  975A        SortWordListNoCase(wordsNoCase, len);
  976A        }
900U977U        while (start <= end) { // binary searching loop
901U978U        pivot = (start + end) >> 1;
902U979U        word = wordsNoCase[pivot];
9 skipped lines
912U989U        while (end < len-1 && !CompareNCaseInsensitive(wordStart, wordsNoCase[end+1], searchLen)) {
913U990U        end++;
914U991U        }
915C          992C 
916U993U        // Finds first word in a series of equal words
917U994U        for (pivot = start; pivot <= end; pivot++) {
918U995U        word = wordsNoCase[pivot];
11 skipped lines
930U1007U        end = pivot - 1;
931U1008U        }
932U1009U    } else { // preserve the letter case
  1010A        if (!sorted) {
  1011A        sorted = true;
  1012A        SortWordList(words, len);
  1013A        }
933U1014U        while (start <= end) { // binary searching loop
934U1015U        pivot = (start + end) >> 1;
935U1016U        word = words[pivot];
9 skipped lines
945U1026U        while (end < len-1 && !strncmp(wordStart, words[end+1], searchLen)) {
946U1027U        end++;
947U1028U        }
948C          1029C 
949U1030U        // Finds first word in a series of equal words
950U1031U        pivot = start;
951U1032U        while (pivot <= end) {
68 skipped lines
1020U1101U 
1021U1102U    if (0 == words)
1022U1103U        return NULL;
1023R    if (!sorted) {  
1024R        sorted = true;  
1025R        SortWordList(words, wordsNoCase, len);  
1026R    }  
1027U1104U    if (ignoreCase) {
  1105A        if (!sortedNoCase) {
  1106A        sortedNoCase = true;
  1107A        SortWordListNoCase(wordsNoCase, len);
  1108A        }
1028U1109U        while (start <= end) { // Binary searching loop
1029U1110U        pivot = (start + end) / 2;
1030U1111U        cond = CompareNCaseInsensitive(wordStart, wordsNoCase[pivot], searchLen);
22 skipped lines
1053U1134U        }
1054U1135U        }
1055U1136U    } else {// Preserve the letter case
  1137A        if (!sorted) {
  1138A        sorted = true;
  1139A        SortWordList(words, len);
  1140A        }
1056U1141U        while (start <= end) { // Binary searching loop
1057U1142U        pivot = (start + end) / 2;
1058U1143U        cond = strncmp(wordStart, words[pivot], searchLen);
28 skipped lines

   Text comparison Options  

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  

UExample of unchanged line
CExample of modified line
AExample of added line
RExample of removed line
IExample of ignored line
Modified text
Added text
Removed text

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