Changeset 333

Timestamp:

Aug 31, 2008, 2:01:55 PM (17 years ago)

Author:

RBRi

Message:

search bug fix; more logging

Location:

branches/2.19_branch/NewView

Files:

• HelpTopic.pas (modified) (10 diffs)
• SearchUnit.pas (modified) (24 diffs)

branches/2.19_branch/NewView/HelpTopic.pas

@@ -1460 +1460 @@
                                 ): longint;
 var
-  WordSequence: TList;
-  SequenceStepIndex: longint;
+  tmpWordSequence: TList;
+  tmpSequenceStepIndex: longint;
   pSequenceStepWords: Uint32ArrayPointer;
 
@@ -1476 +1476 @@
   for SequenceIndex := 0 to WordSequences.Count - 1 do
   begin
-    WordSequence := WordSequences[ SequenceIndex ];
-    pSequenceStepWords := WordSequence[ 0 ];
+    tmpWordSequence := WordSequences[ SequenceIndex ];
+    pSequenceStepWords := tmpWordSequence[ 0 ];
 
     if pSequenceStepWords^[ GlobalDictIndex ] > 0 then
     begin
       // matched first step in this sequence. Look ahead...
-
-      SequenceStepIndex := 0;
+      tmpSequenceStepIndex := 1;
 
       pDataTemp := pData;
       SlotIndexTemp := SlotIndex;
       StateTemp := State;
+
       while true do
       begin
-        inc( SequenceStepIndex );
-        if SequenceStepIndex = WordSequence.Count then
-        begin
-          // have a match for the sequence, insert start highlight
-          Result := WordSequence.Count;
+        if tmpSequenceStepIndex = tmpWordSequence.Count then
+        begin
+          // have a match for the sequence; time to leave
+          Result := tmpWordSequence.Count;
           break;
         end;
 
         // get words for next step in sequence
-        pSequenceStepWords := WordSequence[ SequenceStepIndex ];
-
-        DictIndex := GetNextIPFTextItem( SlotIndexTemp,
-                                         pDataTemp,
-                                         StateTemp );
+        pSequenceStepWords := tmpWordSequence[ tmpSequenceStepIndex ];
+
+        DictIndex := GetNextIPFTextItem( SlotIndexTemp, pDataTemp, StateTemp );
         if DictIndex = -2 then
         begin
@@ -1518 +1515 @@
 
         // s := pstring( _GlobalDictionary[ DictIndex ] )^; // for debug only
+
+
+        // ignore whitespace
         if not StrIsEmptyOrSpaces( pstring( _GlobalDictionary[ DictIndex ] )^ ) then
         begin
@@ -1525 +1525 @@
             break;
           end;
+
+          // match; next one
+          inc(tmpSequenceStepIndex);
         end;
 
@@ -1533 +1536 @@
   end; // for sequenceindex ...
 end;
+
 
 // Main translation function. Turns the IPF data into
@@ -1637 +1641 @@
 
         if ShowWordSeparators then
+        begin
           Text.AddString( '{' + IntToStr( GlobalDictIndex )+ '}' );
+        end;
 
         // normal lookup
@@ -1656 +1662 @@
           // store string into "word"
           if State.TextBlock.Length = 0 then
+          begin
             // store start of block
             State.StartOfTextBlock := Text.Length;
+          end;
 
           State.TextBlock.AddString( StringToAdd );
@@ -1672 +1680 @@
               begin
                 // now finished, insert end highlight
-                StringToAdd := StringToAdd
-                               + State.BackgroundColorTag;
-
+                StringToAdd := StringToAdd + State.BackgroundColorTag;
               end;
             end
@@ -1699 +1705 @@
                 if SequenceStepIndex = 0 then
                   // and ends it.
-                  StringToAdd := StringToAdd
-                           + State.BackgroundColorTag;
+                  StringToAdd := StringToAdd + State.BackgroundColorTag;
               end;
 
@@ -1821 +1826 @@
   end;
   State.TextBlock.Destroy;
-
-end;
+end;
+
 
 function TTopic.SearchForWord( DictIndex: integer;

branches/2.19_branch/NewView/SearchUnit.pas

@@ -124 +124 @@
                             Results: UInt32ArrayPointer );
 var
-  DictIndex: integer;
+  tmpDictIndex: integer;
   pDictWord: pstring;
 begin
-  for DictIndex := 0 to HelpFile.DictionaryCount - 1 do
-  begin
-    pDictWord := HelpFile.DictionaryWordPtrs[ DictIndex ];
-    Results[ DictIndex ] := CompareWord( SearchWord,
-                                         pDictWord^ );
+  for tmpDictIndex := 0 to HelpFile.DictionaryCount - 1 do
+  begin
+    pDictWord := HelpFile.DictionaryWordPtrs[ tmpDictIndex ];
+    Results[ tmpDictIndex ] := CompareWord( SearchWord, pDictWord^ );
   end;
 end;
@@ -163 +162 @@
   DictWord: string;
 begin
+  if IsLogAspectsEnabled(LogSearch) then
+  begin
+    LogEvent(LogSearch, '  calling SearchDictionaryStarts "' + SearchWord + '"');
+  end;
+  
   FillUInt32Array( Results, HelpFile.DictionaryCount, 0 );
 
@@ -169 +173 @@
     DictWord := HelpFile.DictionaryWords[ DictIndex ];
     if StrStartsWithIgnoringCase(DictWord, SearchWord) then
-      Results[ DictIndex ] := MatchedWordRelevance( SearchWord, DictWord );
-  end;
-end;
+    begin
+      Results[ DictIndex ] := MatchedWordRelevance( SearchWord, DictWord )
+    end;
+  end;
+end;
+
 
 // Search the help file dictionary for words that
@@ -182 +189 @@
   DictWord: string;
 begin
+  if IsLogAspectsEnabled(LogSearch) then
+  begin
+    LogEvent(LogSearch, ' calling SearchDictionaryEnds for "' + SearchWord + '"');
+  end;
   FillUInt32Array( Results, HelpFile.DictionaryCount, 0 );
 
@@ -188 +199 @@
     DictWord := HelpFile.DictionaryWords[ DictIndex ];
     if StrEndsWithIgnoringCase(DictWord, SearchWord ) then
+    begin
       Results[ DictIndex ] := MatchedWordRelevance( SearchWord, DictWord );
+    end;
   end;
 end;
@@ -207 +220 @@
   i : integer;
 begin
+  if IsLogAspectsEnabled(LogSearch) then
+  begin
+    LogEvent(LogSearch, ' calling SearchTopicTitles for "' + SearchWord + '"');
+  end;
+
   tmpTitleWords := TStringList.Create;
 
@@ -223 +241 @@
       TitleWord := tmpTitleWords[i];
 
-      WordRelevance := CompareWord( SearchWord,
-                                    TitleWord );
+      WordRelevance := CompareWord( SearchWord, TitleWord );
       if WordRelevance > 0 then
       begin
@@ -233 +250 @@
           begin
             // in fact it's the only word
-            TitleWordRelevance := mwOnlyTitleWord
-                                  * WordRelevance
+            TitleWordRelevance := mwOnlyTitleWord * WordRelevance
           end
           else
-            TitleWordRelevance := mwFirstTitleWord
-                                  * WordRelevance
+            TitleWordRelevance := mwFirstTitleWord * WordRelevance
         end
         else
         begin
-          TitleWordRelevance := mwTitleWord
-                                * WordRelevance;
+          TitleWordRelevance := mwTitleWord * WordRelevance;
         end;
         inc( Results[ TopicIndex ],
@@ -269 +283 @@
   i : integer;
 begin
+  if IsLogAspectsEnabled(LogSearch) then
+  begin
+    LogEvent(LogSearch, ' calling SearchIndex for "' + SearchWord + '"');
+  end;
+  
   tmpIndexWords := TStringList.Create;
 
@@ -284 +303 @@
       IndexEntryWord := tmpIndexWords[i];
 
-      WordRelevance := CompareWord( SearchWord,
-                                    IndexEntryWord );
+      WordRelevance := CompareWord( SearchWord, IndexEntryWord );
       if WordRelevance > 0 then
       begin
@@ -294 +312 @@
           begin
             // in fact it's the only word
-            IndexEntryWordRelevance := mwOnlyIndexWord
-                                       * WordRelevance
+            IndexEntryWordRelevance := mwOnlyIndexWord * WordRelevance
           end
           else
-            IndexEntryWordRelevance := mwFirstIndexWord
-                                    * WordRelevance
+            IndexEntryWordRelevance := mwFirstIndexWord * WordRelevance
         end
         else
         begin
-          IndexEntryWordRelevance := mwIndexWord
-                                  * WordRelevance;
+          IndexEntryWordRelevance := mwIndexWord * WordRelevance;
         end;
         inc( Results[ Topic.Index ],
@@ -327 +342 @@
                           WordSequences: TList );
 var
-  TopicCount: longint;
-  Topic: TTopic;
-  TopicIndex: longint;
-  TermIndex: longint;
-  Term: TSearchTerm;
+  tmpTopicCount: longint;
+  tmpTopic: TTopic;
+  tmpTopicIndex: longint;
+  tmpTermIndex: longint;
+  tmpTerm: TSearchTerm;
 
   DictionaryRelevances: UInt32ArrayPointer;
@@ -353 +368 @@
   TermWordSequence: TList;
 begin
+  LogEvent(LogSearch, 'SearchHelpFile');
+  Query.Log;
+
   if HelpFile.SearchTable = nil then
   begin
@@ -359 +377 @@
 
   // Reset flags per topic
-  TopicCount := HelpFile.TopicCount;
+  tmpTopicCount := HelpFile.TopicCount;
 
   // Get memory for topic relevance arrays
 
-  AllocUInt32Array( TopicsMatchingDictWord,
-                    TopicCount );
-  AllocUInt32Array( TopicsMatchingTermPart,
-                    TopicCount );
-  AllocUInt32Array( TopicsMatchingTerm,
-                    TopicCount );
-  AllocUInt32Array( TopicRelevances,  // functions as a flag and a cumulative relevance
-                    TopicCount );
-  AllocUInt32Array( TopicsExcluded, // Exclusions are treated as boolean only
-                    TopicCount );
-
-  ClearUInt32Array( TopicRelevances,
-                    TopicCount );
-  ClearUInt32Array( TopicsExcluded,
-                    TopicCount );
-
-  for TermIndex := 0 to Query.TermCount - 1 do
-  begin
-    Term := Query.Term[ TermIndex ];
-
-    LogEvent(LogSearch, 'Searching for term "'
-                  + Term.Text
+  AllocUInt32Array( TopicsMatchingDictWord, tmpTopicCount );
+  AllocUInt32Array( TopicsMatchingTermPart, tmpTopicCount );
+  AllocUInt32Array( TopicsMatchingTerm, tmpTopicCount );
+  AllocUInt32Array( TopicRelevances, tmpTopicCount ); // functions as a flag and a cumulative relevance
+
+  AllocUInt32Array( TopicsExcluded, tmpTopicCount ); // Exclusions are treated as boolean only
+
+
+  ClearUInt32Array( TopicRelevances, tmpTopicCount );
+  ClearUInt32Array( TopicsExcluded, tmpTopicCount );
+
+  for tmpTermIndex := 0 to Query.TermCount - 1 do
+  begin
+    tmpTerm := Query.Term[ tmpTermIndex ];
+
+    if IsLogAspectsEnabled(LogSearch) then
+    begin
+      LogEvent(LogSearch, 'Searching for term "'
+                  + tmpTerm.Text
                   + '", '
-                  + IntToStr( Term.Parts.Count )
+                  + IntToStr( tmpTerm.Parts.Count )
                   + ' parts' );
+    end;
 
     // look thru all parts of the term.           eg. CAKE_SAUSAGE
@@ -394 +410 @@
 
     if WordSequences <> nil then
-      if Term.CombineMethod <> cmExcluded then
+      if tmpTerm.CombineMethod <> cmExcluded then
+      begin
         // this term is an inclusive one, so we want to remember the matches
         WordSequences.Add( TermWordSequence );
-
-    for TermPartIndex := 0 to Term.Parts.Count - 1 do
-    begin
-      TermPart := Term.Parts[ TermPartIndex ];
-
-      LogEvent(LogSearch, '  Searching for [' + TermPart + ']' );
-
-      AllocUInt32Array( DictionaryRelevances,
-                        HelpFile.DictionaryCount );
+      end;
+
+    for TermPartIndex := 0 to tmpTerm.Parts.Count - 1 do
+    begin
+      TermPart := tmpTerm.Parts[ TermPartIndex ];
+
+      if IsLogAspectsEnabled(LogSearch) then
+      begin
+        LogEvent(LogSearch, '  Searching for TermPart [' + TermPart + ']' );
+      end;
+
+      AllocUInt32Array( DictionaryRelevances, HelpFile.DictionaryCount );
 
       TermWordSequence.Add( DictionaryRelevances );
@@ -412 +432 @@
       // alpha numeric match
 
-      if Term.Parts.Count = 1 then
+      if tmpTerm.Parts.Count = 1 then
+      begin
+        if IsLogAspectsEnabled(LogSearch) then
+        begin
+          LogEvent(LogSearch, '  Term has only one part...' );
+          LogEvent(LogSearch, '  SearchDictionary [' + TermPart + ']' );
+        end;
+
         // general match allowing all kinds of partial matches
-        SearchDictionary( HelpFile,
-                          TermPart,
-                          DictionaryRelevances )
+        SearchDictionary( HelpFile, TermPart, DictionaryRelevances )
+      end
 
       else if TermPartIndex = 0 then
+      begin
+        if IsLogAspectsEnabled(LogSearch) then
+        begin
+          LogEvent(LogSearch, '  Term has more then one part... we are at first' );
+          LogEvent(LogSearch, '  SearchDictionaryEnd [' + TermPart + ']' );
+        end;
+
         // first term part: word must match end of a topic word e.g. must end in "cake"
-        SearchDictionaryEnds( HelpFile,
-                              TermPart,
-                              DictionaryRelevances )
-
-      else if TermPartIndex = Term.Parts.Count - 1 then
+        SearchDictionaryEnds( HelpFile, TermPart, DictionaryRelevances )
+      end
+
+      else if TermPartIndex = tmpTerm.Parts.Count - 1 then
+      begin
+        if IsLogAspectsEnabled(LogSearch) then
+        begin
+          LogEvent(LogSearch, '  Term has more then one part... we are at last' );
+          LogEvent(LogSearch, '  SearchDictionaryEnd [' + TermPart + ']' );
+        end;
+
         // last term part: word must match start of a topic word e.g. must start with "sausage"
-        SearchDictionaryStarts( HelpFile,
-                                TermPart,
-                                DictionaryRelevances )
+        SearchDictionaryStarts( HelpFile, TermPart, DictionaryRelevances )
+      end
 
       else
+      begin
+        if IsLogAspectsEnabled(LogSearch) then
+        begin
+          LogEvent(LogSearch, '  Term has more then one part... we are inside' );
+          LogEvent(LogSearch, '  SearchDictionaryEnd [' + TermPart + ']' );
+        end;
+
         // intermediate term part: word must match exactly  e.g. must be "_"
-        SearchDictionaryExact( HelpFile,
-                               TermPart,
-                               DictionaryRelevances );
+        SearchDictionaryExact( HelpFile, TermPart, DictionaryRelevances )
+      end;
 
       // For each word in the dictionary that matches
@@ -440 +484 @@
 
       LogEvent(LogSearch, '  Dictionary search done' );
-      ClearUInt32Array( TopicsMatchingTermPart,
-                        TopicCount );
+      ClearUInt32Array( TopicsMatchingTermPart, tmpTopicCount );
 
       for DictIndex := 0 to HelpFile.DictionaryCount - 1 do
@@ -460 +503 @@
           OrUInt32Array( TopicsMatchingDictWord,
                          TopicsMatchingTermPart,
-                         TopicCount );
+                         tmpTopicCount );
         end
       end;
 
-      LogEvent(LogSearch, 'Topic searches done' );
+      LogEvent(LogSearch, '  Topic searches done' );
 
       if TermPartIndex = 0 then
@@ -470 +513 @@
         CopyUInt32Array( TopicsMatchingTermPart,
                          TopicsMatchingTerm,
-                         TopicCount )
+                         tmpTopicCount )
       else
         // and with previous term part results
         AndUInt32Array( TopicsMatchingTermPart,
                         TopicsMatchingTerm,
-                        TopicCount );
+                        tmpTopicCount );
 
       // loop for next term part (IPF word)
@@ -484 +527 @@
 
     LogEvent(LogSearch, 'Checking for sequences' );
-    for TopicIndex := 0 to TopicCount - 1 do
-    begin
-      if TopicsMatchingTerm[ TopicIndex ] > 0 then
-      begin
-        Topic := HelpFile.Topics[ TopicIndex ];
+    for tmpTopicIndex := 0 to tmpTopicCount - 1 do
+    begin
+      if TopicsMatchingTerm[ tmpTopicIndex ] > 0 then
+      begin
+        tmpTopic := HelpFile.Topics[ tmpTopicIndex ];
         // Topic text contained a match for the all the parts
         // of the term.
@@ -495 +538 @@
         // - count occurrences for relevance.
 
-        TopicRelevanceForTerm :=
-          Topic.SearchForWordSequences( TermWordSequence,
-                                        false ); // don't stop at first match
-
-        TopicRelevanceForTerm :=
-          TopicRelevanceForTerm div Term.Parts.Count; // divide to bring back into scale
-
-        TopicsMatchingTerm[ TopicIndex ] := TopicRelevanceForTerm;
+        TopicRelevanceForTerm := tmpTopic.SearchForWordSequences( TermWordSequence, false ); // don't stop at first match
+
+        TopicRelevanceForTerm := TopicRelevanceForTerm div tmpTerm.Parts.Count; // divide to bring back into scale
+
+        TopicsMatchingTerm[ tmpTopicIndex ] := TopicRelevanceForTerm;
 
       end;
@@ -518 +558 @@
 
     LogEvent(LogSearch, '  Searching titles' );
-    SearchTopicTitles( HelpFile, Term.Text, TopicsMatchingTerm );
+    SearchTopicTitles( HelpFile, tmpTerm.Text, TopicsMatchingTerm );
 
     LogEvent(LogSearch, '  Searching index' );
-    SearchIndex( HelpFile, Term.Text, TopicsMatchingTerm );
+    SearchIndex( HelpFile, tmpTerm.Text, TopicsMatchingTerm );
 
     LogEvent(LogSearch, '  Combining' );
-    case Term.CombineMethod of
+    case tmpTerm.CombineMethod of
       cmOptional:
+      begin
+        LogEvent(LogSearch, '  Combining optional');
         AddUInt32Array( TopicsMatchingTerm,
                         TopicRelevances,
-                        TopicCount );
+                        tmpTopicCount );
+      end;
 
       cmRequired:
       begin
+        LogEvent(LogSearch, '  Combining required');
         // if zero then add to exclusions
         NotOrUInt32Array( TopicsMatchingTerm,
                           TopicsExcluded,
-                          TopicCount );
+                          tmpTopicCount );
 
         AddUInt32Array( TopicsMatchingTerm,
                         TopicRelevances,
-                        TopicCount );
+                        tmpTopicCount );
       end;
 
       cmExcluded:
+      begin
+        LogEvent(LogSearch, '  Combining excluded');
         OrUInt32Array( TopicsMatchingTerm,
                        TopicsExcluded,
-                       TopicCount );
+                       tmpTopicCount );
+      end;
     end;
 
@@ -557 +604 @@
   // Now convert to list form.
 
-  for TopicIndex := 0 to TopicCount - 1 do
-  begin
-    if TopicsExcluded[ TopicIndex ] = 0 then
-    begin
-      Topic := HelpFile.Topics[ TopicIndex ];
-      Topic.SearchRelevance := TopicRelevances[ TopicIndex ];
-      if Topic.SearchRelevance > 0 then
-      begin
-        Results.Add( Topic );
+  for tmpTopicIndex := 0 to tmpTopicCount - 1 do
+  begin
+    if TopicsExcluded[ tmpTopicIndex ] = 0 then
+    begin
+      tmpTopic := HelpFile.Topics[ tmpTopicIndex ];
+      tmpTopic.SearchRelevance := TopicRelevances[ tmpTopicIndex ];
+      if tmpTopic.SearchRelevance > 0 then
+      begin
+        Results.Add( tmpTopic );
       end;
     end;
@@ -571 +618 @@
 
   LogEvent(LogSearch, 'Freeing arrays' );
-  FreeUInt32Array( TopicRelevances, TopicCount );
-  FreeUInt32Array( TopicsExcluded, TopicCount );
-  FreeUInt32Array( TopicsMatchingTerm, TopicCount );
-  FreeUInt32Array( TopicsMatchingTermPart, TopicCount );
-  FreeUInt32Array( TopicsMatchingDictWord, TopicCount );
+  FreeUInt32Array( TopicRelevances, tmpTopicCount );
+  FreeUInt32Array( TopicsExcluded, tmpTopicCount );
+  FreeUInt32Array( TopicsMatchingTerm, tmpTopicCount );
+  FreeUInt32Array( TopicsMatchingTermPart, tmpTopicCount );
+  FreeUInt32Array( TopicsMatchingDictWord, tmpTopicCount );
 
   LogEvent(LogSearch, 'Done' );