michael@0: /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: //#define DEBUG_FIND 1
michael@0: 
michael@0: #include "nsFind.h"
michael@0: #include "nsContentCID.h"
michael@0: #include "nsIContent.h"
michael@0: #include "nsIDOMNode.h"
michael@0: #include "nsIDOMNodeList.h"
michael@0: #include "nsISelection.h"
michael@0: #include "nsISelectionController.h"
michael@0: #include "nsIFrame.h"
michael@0: #include "nsITextControlFrame.h"
michael@0: #include "nsIFormControl.h"
michael@0: #include "nsIEditor.h"
michael@0: #include "nsIPlaintextEditor.h"
michael@0: #include "nsTextFragment.h"
michael@0: #include "nsString.h"
michael@0: #include "nsIAtom.h"
michael@0: #include "nsServiceManagerUtils.h"
michael@0: #include "nsUnicharUtils.h"
michael@0: #include "nsIDOMElement.h"
michael@0: #include "nsIWordBreaker.h"
michael@0: #include "nsCRT.h"
michael@0: #include "nsRange.h"
michael@0: #include "nsContentUtils.h"
michael@0: #include "mozilla/DebugOnly.h"
michael@0: 
michael@0: using namespace mozilla;
michael@0: 
michael@0: // Yikes!  Casting a char to unichar can fill with ones!
michael@0: #define CHAR_TO_UNICHAR(c) ((char16_t)(const unsigned char)c)
michael@0: 
michael@0: static NS_DEFINE_CID(kCContentIteratorCID, NS_CONTENTITERATOR_CID);
michael@0: static NS_DEFINE_CID(kCPreContentIteratorCID, NS_PRECONTENTITERATOR_CID);
michael@0: 
michael@0: #define CH_QUOTE ((char16_t) 0x22)
michael@0: #define CH_APOSTROPHE ((char16_t) 0x27)
michael@0: #define CH_LEFT_SINGLE_QUOTE ((char16_t) 0x2018)
michael@0: #define CH_RIGHT_SINGLE_QUOTE ((char16_t) 0x2019)
michael@0: #define CH_LEFT_DOUBLE_QUOTE ((char16_t) 0x201C)
michael@0: #define CH_RIGHT_DOUBLE_QUOTE ((char16_t) 0x201D)
michael@0: 
michael@0: #define CH_SHY ((char16_t) 0xAD)
michael@0: 
michael@0: // nsFind::Find casts CH_SHY to char before calling StripChars
michael@0: // This works correctly if and only if CH_SHY <= 255
michael@0: PR_STATIC_ASSERT(CH_SHY <= 255);
michael@0: 
michael@0: // -----------------------------------------------------------------------
michael@0: // nsFindContentIterator is a special iterator that also goes through
michael@0: // any existing <textarea>'s or text <input>'s editor to lookup the
michael@0: // anonymous DOM content there.
michael@0: //
michael@0: // Details:
michael@0: // 1) We use two iterators: The "outer-iterator" goes through the
michael@0: // normal DOM. The "inner-iterator" goes through the anonymous DOM
michael@0: // inside the editor.
michael@0: //
michael@0: // 2) [MaybeSetupInnerIterator] As soon as the outer-iterator's current
michael@0: // node is changed, a check is made to see if the node is a <textarea> or
michael@0: // a text <input> node. If so, an inner-iterator is created to lookup the
michael@0: // anynomous contents of the editor underneath the text control.
michael@0: //
michael@0: // 3) When the inner-iterator is created, we position the outer-iterator
michael@0: // 'after' (or 'before' in backward search) the text control to avoid
michael@0: // revisiting that control.
michael@0: //
michael@0: // 4) As a consequence of searching through text controls, we can be
michael@0: // called via FindNext with the current selection inside a <textarea>
michael@0: // or a text <input>. This means that we can be given an initial search
michael@0: // range that stretches across the anonymous DOM and the normal DOM. To
michael@0: // cater for this situation, we split the anonymous part into the
michael@0: // inner-iterator and then reposition the outer-iterator outside.
michael@0: //
michael@0: // 5) The implementation assumes that First() and Next() are only called
michael@0: // in find-forward mode, while Last() and Prev() are used in find-backward.
michael@0: 
michael@0: class nsFindContentIterator : public nsIContentIterator
michael@0: {
michael@0: public:
michael@0:   nsFindContentIterator(bool aFindBackward)
michael@0:     : mStartOffset(0),
michael@0:       mEndOffset(0),
michael@0:       mFindBackward(aFindBackward)
michael@0:   {
michael@0:   }
michael@0: 
michael@0:   virtual ~nsFindContentIterator()
michael@0:   {
michael@0:   }
michael@0: 
michael@0:   // nsISupports
michael@0:   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
michael@0:     NS_DECL_CYCLE_COLLECTION_CLASS(nsFindContentIterator)
michael@0: 
michael@0:   // nsIContentIterator
michael@0:   virtual nsresult Init(nsINode* aRoot)
michael@0:   {
michael@0:     NS_NOTREACHED("internal error");
michael@0:     return NS_ERROR_NOT_IMPLEMENTED;
michael@0:   }
michael@0:   virtual nsresult Init(nsIDOMRange* aRange)
michael@0:   {
michael@0:     NS_NOTREACHED("internal error");
michael@0:     return NS_ERROR_NOT_IMPLEMENTED;
michael@0:   }
michael@0:   // Not a range because one of the endpoints may be anonymous.
michael@0:   nsresult Init(nsIDOMNode* aStartNode, int32_t aStartOffset,
michael@0:                 nsIDOMNode* aEndNode, int32_t aEndOffset);
michael@0:   virtual void First();
michael@0:   virtual void Last();
michael@0:   virtual void Next();
michael@0:   virtual void Prev();
michael@0:   virtual nsINode* GetCurrentNode();
michael@0:   virtual bool IsDone();
michael@0:   virtual nsresult PositionAt(nsINode* aCurNode);
michael@0: 
michael@0: private:
michael@0:   nsCOMPtr<nsIContentIterator> mOuterIterator;
michael@0:   nsCOMPtr<nsIContentIterator> mInnerIterator;
michael@0:   // Can't use a range here, since we want to represent part of the
michael@0:   // flattened tree, including native anonymous content.
michael@0:   nsCOMPtr<nsIDOMNode> mStartNode;
michael@0:   int32_t mStartOffset;
michael@0:   nsCOMPtr<nsIDOMNode> mEndNode;
michael@0:   int32_t mEndOffset;
michael@0: 
michael@0:   nsCOMPtr<nsIContent> mStartOuterContent;
michael@0:   nsCOMPtr<nsIContent> mEndOuterContent;
michael@0:   bool mFindBackward;
michael@0: 
michael@0:   void Reset();
michael@0:   void MaybeSetupInnerIterator();
michael@0:   void SetupInnerIterator(nsIContent* aContent);
michael@0: };
michael@0: 
michael@0: NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsFindContentIterator)
michael@0:   NS_INTERFACE_MAP_ENTRY(nsIContentIterator)
michael@0:   NS_INTERFACE_MAP_ENTRY(nsISupports)
michael@0: NS_INTERFACE_MAP_END
michael@0: 
michael@0: NS_IMPL_CYCLE_COLLECTING_ADDREF(nsFindContentIterator)
michael@0: NS_IMPL_CYCLE_COLLECTING_RELEASE(nsFindContentIterator)
michael@0: 
michael@0: NS_IMPL_CYCLE_COLLECTION(nsFindContentIterator, mOuterIterator, mInnerIterator,
michael@0:                          mStartOuterContent, mEndOuterContent, mEndNode, mStartNode)
michael@0: 
michael@0: 
michael@0: nsresult
michael@0: nsFindContentIterator::Init(nsIDOMNode* aStartNode, int32_t aStartOffset,
michael@0:                             nsIDOMNode* aEndNode, int32_t aEndOffset)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aStartNode);
michael@0:   NS_ENSURE_ARG_POINTER(aEndNode);
michael@0:   if (!mOuterIterator) {
michael@0:     if (mFindBackward) {
michael@0:       // Use post-order in the reverse case, so we get parents
michael@0:       // before children in case we want to prevent descending
michael@0:       // into a node.
michael@0:       mOuterIterator = do_CreateInstance(kCContentIteratorCID);
michael@0:     }
michael@0:     else {
michael@0:       // Use pre-order in the forward case, so we get parents
michael@0:       // before children in case we want to prevent descending
michael@0:       // into a node.
michael@0:       mOuterIterator = do_CreateInstance(kCPreContentIteratorCID);
michael@0:     }
michael@0:     NS_ENSURE_ARG_POINTER(mOuterIterator);
michael@0:   }
michael@0: 
michael@0:   // Set up the search "range" that we will examine
michael@0:   mStartNode = aStartNode;
michael@0:   mStartOffset = aStartOffset;
michael@0:   mEndNode = aEndNode;
michael@0:   mEndOffset = aEndOffset;
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFindContentIterator::First()
michael@0: {
michael@0:   Reset();
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFindContentIterator::Last()
michael@0: {
michael@0:   Reset();
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFindContentIterator::Next()
michael@0: {
michael@0:   if (mInnerIterator) {
michael@0:     mInnerIterator->Next();
michael@0:     if (!mInnerIterator->IsDone())
michael@0:       return;
michael@0: 
michael@0:     // by construction, mOuterIterator is already on the next node
michael@0:   }
michael@0:   else {
michael@0:     mOuterIterator->Next();
michael@0:   }
michael@0:   MaybeSetupInnerIterator();
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFindContentIterator::Prev()
michael@0: {
michael@0:   if (mInnerIterator) {
michael@0:     mInnerIterator->Prev();
michael@0:     if (!mInnerIterator->IsDone())
michael@0:       return;
michael@0: 
michael@0:     // by construction, mOuterIterator is already on the previous node
michael@0:   }
michael@0:   else {
michael@0:     mOuterIterator->Prev();
michael@0:   }
michael@0:   MaybeSetupInnerIterator();
michael@0: }
michael@0: 
michael@0: nsINode*
michael@0: nsFindContentIterator::GetCurrentNode()
michael@0: {
michael@0:   if (mInnerIterator && !mInnerIterator->IsDone()) {
michael@0:     return mInnerIterator->GetCurrentNode();
michael@0:   }
michael@0:   return mOuterIterator->GetCurrentNode();
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsFindContentIterator::IsDone() {
michael@0:   if (mInnerIterator && !mInnerIterator->IsDone()) {
michael@0:     return false;
michael@0:   }
michael@0:   return mOuterIterator->IsDone();
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsFindContentIterator::PositionAt(nsINode* aCurNode)
michael@0: {
michael@0:   nsINode* oldNode = mOuterIterator->GetCurrentNode();
michael@0:   nsresult rv = mOuterIterator->PositionAt(aCurNode);
michael@0:   if (NS_SUCCEEDED(rv)) {
michael@0:     MaybeSetupInnerIterator();
michael@0:   }
michael@0:   else {
michael@0:     mOuterIterator->PositionAt(oldNode);
michael@0:     if (mInnerIterator)
michael@0:       rv = mInnerIterator->PositionAt(aCurNode);
michael@0:   }
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFindContentIterator::Reset()
michael@0: {
michael@0:   mInnerIterator = nullptr;
michael@0:   mStartOuterContent = nullptr;
michael@0:   mEndOuterContent = nullptr;
michael@0: 
michael@0:   // As a consequence of searching through text controls, we may have been
michael@0:   // initialized with a selection inside a <textarea> or a text <input>.
michael@0: 
michael@0:   // see if the start node is an anonymous text node inside a text control
michael@0:   nsCOMPtr<nsIContent> startContent(do_QueryInterface(mStartNode));
michael@0:   if (startContent) {
michael@0:     mStartOuterContent = startContent->FindFirstNonChromeOnlyAccessContent();
michael@0:   }
michael@0: 
michael@0:   // see if the end node is an anonymous text node inside a text control
michael@0:   nsCOMPtr<nsIContent> endContent(do_QueryInterface(mEndNode));
michael@0:   if (endContent) {
michael@0:     mEndOuterContent = endContent->FindFirstNonChromeOnlyAccessContent();
michael@0:   }
michael@0: 
michael@0:   // Note: OK to just set up the outer iterator here; if our range has a native
michael@0:   // anonymous endpoint we'll end up setting up an inner iterator, and
michael@0:   // reset the outer one in the process.
michael@0:   nsCOMPtr<nsINode> node = do_QueryInterface(mStartNode);
michael@0:   NS_ENSURE_TRUE_VOID(node);
michael@0: 
michael@0:   nsCOMPtr<nsIDOMRange> range = nsFind::CreateRange(node);
michael@0:   range->SetStart(mStartNode, mStartOffset);
michael@0:   range->SetEnd(mEndNode, mEndOffset);
michael@0:   mOuterIterator->Init(range);
michael@0: 
michael@0:   if (!mFindBackward) {
michael@0:     if (mStartOuterContent != startContent) {
michael@0:       // the start node was an anonymous text node
michael@0:       SetupInnerIterator(mStartOuterContent);
michael@0:       if (mInnerIterator)
michael@0:         mInnerIterator->First();
michael@0:     }
michael@0:     if (!mOuterIterator->IsDone())
michael@0:       mOuterIterator->First();
michael@0:   }
michael@0:   else {
michael@0:     if (mEndOuterContent != endContent) {
michael@0:       // the end node was an anonymous text node
michael@0:       SetupInnerIterator(mEndOuterContent);
michael@0:       if (mInnerIterator)
michael@0:         mInnerIterator->Last();
michael@0:     }
michael@0:     if (!mOuterIterator->IsDone())
michael@0:       mOuterIterator->Last();
michael@0:   }
michael@0: 
michael@0:   // if we didn't create an inner-iterator, the boundary node could still be
michael@0:   // a text control, in which case we also need an inner-iterator straightaway
michael@0:   if (!mInnerIterator) {
michael@0:     MaybeSetupInnerIterator();
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFindContentIterator::MaybeSetupInnerIterator()
michael@0: {
michael@0:   mInnerIterator = nullptr;
michael@0: 
michael@0:   nsCOMPtr<nsIContent> content =
michael@0:     do_QueryInterface(mOuterIterator->GetCurrentNode());
michael@0:   if (!content || !content->IsNodeOfType(nsINode::eHTML_FORM_CONTROL))
michael@0:     return;
michael@0: 
michael@0:   nsCOMPtr<nsIFormControl> formControl(do_QueryInterface(content));
michael@0:   if (!formControl->IsTextControl(true)) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   SetupInnerIterator(content);
michael@0:   if (mInnerIterator) {
michael@0:     if (!mFindBackward) {
michael@0:       mInnerIterator->First();
michael@0:       // finish setup: position mOuterIterator on the actual "next"
michael@0:       // node (this completes its re-init, @see SetupInnerIterator)
michael@0:       if (!mOuterIterator->IsDone())
michael@0:         mOuterIterator->First();
michael@0:     }
michael@0:     else {
michael@0:       mInnerIterator->Last();
michael@0:       // finish setup: position mOuterIterator on the actual "previous"
michael@0:       // node (this completes its re-init, @see SetupInnerIterator)
michael@0:       if (!mOuterIterator->IsDone())
michael@0:         mOuterIterator->Last();
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFindContentIterator::SetupInnerIterator(nsIContent* aContent)
michael@0: {
michael@0:   if (!aContent) {
michael@0:     return;
michael@0:   }
michael@0:   NS_ASSERTION(!aContent->IsRootOfNativeAnonymousSubtree(), "invalid call");
michael@0: 
michael@0:   nsITextControlFrame* tcFrame = do_QueryFrame(aContent->GetPrimaryFrame());
michael@0:   if (!tcFrame)
michael@0:     return;
michael@0: 
michael@0:   nsCOMPtr<nsIEditor> editor;
michael@0:   tcFrame->GetEditor(getter_AddRefs(editor));
michael@0:   if (!editor)
michael@0:     return;
michael@0: 
michael@0:   // don't mess with disabled input fields
michael@0:   uint32_t editorFlags = 0;
michael@0:   editor->GetFlags(&editorFlags);
michael@0:   if (editorFlags & nsIPlaintextEditor::eEditorDisabledMask)
michael@0:     return;
michael@0: 
michael@0:   nsCOMPtr<nsIDOMElement> rootElement;
michael@0:   editor->GetRootElement(getter_AddRefs(rootElement));
michael@0: 
michael@0:   nsCOMPtr<nsIDOMRange> innerRange = nsFind::CreateRange(aContent);
michael@0:   nsCOMPtr<nsIDOMRange> outerRange = nsFind::CreateRange(aContent);
michael@0:   if (!innerRange || !outerRange) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   // now create the inner-iterator
michael@0:   mInnerIterator = do_CreateInstance(kCPreContentIteratorCID);
michael@0: 
michael@0:   if (mInnerIterator) {
michael@0:     innerRange->SelectNodeContents(rootElement);
michael@0: 
michael@0:     // fix up the inner bounds, we may have to only lookup a portion
michael@0:     // of the text control if the current node is a boundary point
michael@0:     if (aContent == mStartOuterContent) {
michael@0:       innerRange->SetStart(mStartNode, mStartOffset);
michael@0:     }
michael@0:     if (aContent == mEndOuterContent) {
michael@0:       innerRange->SetEnd(mEndNode, mEndOffset);
michael@0:     }
michael@0:     // Note: we just init here. We do First() or Last() later.
michael@0:     mInnerIterator->Init(innerRange);
michael@0: 
michael@0:     // make sure to place the outer-iterator outside
michael@0:     // the text control so that we don't go there again.
michael@0:     nsresult res1, res2;
michael@0:     nsCOMPtr<nsIDOMNode> outerNode(do_QueryInterface(aContent));
michael@0:     if (!mFindBackward) { // find forward
michael@0:       // cut the outer-iterator after the current node
michael@0:       res1 = outerRange->SetEnd(mEndNode, mEndOffset);
michael@0:       res2 = outerRange->SetStartAfter(outerNode);
michael@0:     }
michael@0:     else { // find backward
michael@0:       // cut the outer-iterator before the current node
michael@0:       res1 = outerRange->SetStart(mStartNode, mStartOffset);
michael@0:       res2 = outerRange->SetEndBefore(outerNode);
michael@0:     }
michael@0:     if (NS_FAILED(res1) || NS_FAILED(res2)) {
michael@0:       // we are done with the outer-iterator, the
michael@0:       // inner-iterator will traverse what we want
michael@0:       outerRange->Collapse(true);
michael@0:     }
michael@0: 
michael@0:     // Note: we just re-init here, using the segment of our search range that
michael@0:     // is yet to be visited. Thus when we later do mOuterIterator->First() [or
michael@0:     // mOuterIterator->Last()], we will effectively be on the next node [or
michael@0:     // the previous node] _with respect to_ the search range.
michael@0:     mOuterIterator->Init(outerRange);
michael@0:   }
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: NS_NewFindContentIterator(bool aFindBackward,
michael@0:                           nsIContentIterator** aResult)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aResult);
michael@0:   if (!aResult) {
michael@0:     return NS_ERROR_NULL_POINTER;
michael@0:   }
michael@0: 
michael@0:   nsFindContentIterator* it = new nsFindContentIterator(aFindBackward);
michael@0:   if (!it) {
michael@0:     return NS_ERROR_OUT_OF_MEMORY;
michael@0:   }
michael@0:   return it->QueryInterface(NS_GET_IID(nsIContentIterator), (void **)aResult);
michael@0: }
michael@0: // --------------------------------------------------------------------
michael@0: 
michael@0: NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsFind)
michael@0:   NS_INTERFACE_MAP_ENTRY(nsIFind)
michael@0:   NS_INTERFACE_MAP_ENTRY(nsISupports)
michael@0: NS_INTERFACE_MAP_END
michael@0: 
michael@0: NS_IMPL_CYCLE_COLLECTING_ADDREF(nsFind)
michael@0: NS_IMPL_CYCLE_COLLECTING_RELEASE(nsFind)
michael@0: 
michael@0:   NS_IMPL_CYCLE_COLLECTION(nsFind, mLastBlockParent, mIterNode, mIterator)
michael@0: 
michael@0: nsFind::nsFind()
michael@0:   : mFindBackward(false)
michael@0:   , mCaseSensitive(false)
michael@0:   , mIterOffset(0)
michael@0: {
michael@0: }
michael@0: 
michael@0: nsFind::~nsFind()
michael@0: {
michael@0: }
michael@0: 
michael@0: #ifdef DEBUG_FIND
michael@0: static void DumpNode(nsIDOMNode* aNode)
michael@0: {
michael@0:   if (!aNode)
michael@0:   {
michael@0:     printf(">>>> Node: NULL\n");
michael@0:     return;
michael@0:   }
michael@0:   nsAutoString nodeName;
michael@0:   aNode->GetNodeName(nodeName);
michael@0:   nsCOMPtr<nsIContent> textContent (do_QueryInterface(aNode));
michael@0:   if (textContent && textContent->IsNodeOfType(nsINode::eTEXT))
michael@0:   {
michael@0:     nsAutoString newText;
michael@0:     textContent->AppendTextTo(newText);
michael@0:     printf(">>>> Text node (node name %s): '%s'\n",
michael@0:            NS_LossyConvertUTF16toASCII(nodeName).get(),
michael@0:            NS_LossyConvertUTF16toASCII(newText).get());
michael@0:   }
michael@0:   else
michael@0:     printf(">>>> Node: %s\n", NS_LossyConvertUTF16toASCII(nodeName).get());
michael@0: }
michael@0: #endif
michael@0: 
michael@0: nsresult
michael@0: nsFind::InitIterator(nsIDOMNode* aStartNode, int32_t aStartOffset,
michael@0:                      nsIDOMNode* aEndNode, int32_t aEndOffset)
michael@0: {
michael@0:   if (!mIterator)
michael@0:   {
michael@0:     mIterator = new nsFindContentIterator(mFindBackward);
michael@0:     NS_ENSURE_TRUE(mIterator, NS_ERROR_OUT_OF_MEMORY);
michael@0:   }
michael@0: 
michael@0:   NS_ENSURE_ARG_POINTER(aStartNode);
michael@0:   NS_ENSURE_ARG_POINTER(aEndNode);
michael@0: 
michael@0: #ifdef DEBUG_FIND
michael@0:   printf("InitIterator search range:\n");
michael@0:   printf(" -- start %d, ", aStartOffset); DumpNode(aStartNode);
michael@0:   printf(" -- end %d, ", aEndOffset); DumpNode(aEndNode);
michael@0: #endif
michael@0: 
michael@0:   nsresult rv =
michael@0:     mIterator->Init(aStartNode, aStartOffset, aEndNode, aEndOffset);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0:   if (mFindBackward) {
michael@0:     mIterator->Last();
michael@0:   }
michael@0:   else {
michael@0:     mIterator->First();
michael@0:   }
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /* attribute boolean findBackward; */
michael@0: NS_IMETHODIMP
michael@0: nsFind::GetFindBackwards(bool *aFindBackward)
michael@0: {
michael@0:   if (!aFindBackward)
michael@0:     return NS_ERROR_NULL_POINTER;
michael@0: 
michael@0:   *aFindBackward = mFindBackward;
michael@0:   return NS_OK;
michael@0: }
michael@0: NS_IMETHODIMP
michael@0: nsFind::SetFindBackwards(bool aFindBackward)
michael@0: {
michael@0:   mFindBackward = aFindBackward;
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /* attribute boolean caseSensitive; */
michael@0: NS_IMETHODIMP
michael@0: nsFind::GetCaseSensitive(bool *aCaseSensitive)
michael@0: {
michael@0:   if (!aCaseSensitive)
michael@0:     return NS_ERROR_NULL_POINTER;
michael@0: 
michael@0:   *aCaseSensitive = mCaseSensitive;
michael@0:   return NS_OK;
michael@0: }
michael@0: NS_IMETHODIMP
michael@0: nsFind::SetCaseSensitive(bool aCaseSensitive)
michael@0: {
michael@0:   mCaseSensitive = aCaseSensitive;
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFind::GetWordBreaker(nsIWordBreaker** aWordBreaker)
michael@0: {
michael@0:   *aWordBreaker = mWordBreaker;
michael@0:   NS_IF_ADDREF(*aWordBreaker);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFind::SetWordBreaker(nsIWordBreaker* aWordBreaker)
michael@0: {
michael@0:   mWordBreaker = aWordBreaker;
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: //
michael@0: // Here begins the find code.
michael@0: // A ten-thousand-foot view of how it works:
michael@0: // Find needs to be able to compare across inline (but not block) nodes,
michael@0: // e.g. find for "abc" should match a<b>b</b>c.
michael@0: // So after we've searched a node, we're not done with it;
michael@0: // in the case of a partial match we may need to reset the
michael@0: // iterator to go back to a previously visited node,
michael@0: // so we always save the "match anchor" node and offset.
michael@0: //
michael@0: // Text nodes store their text in an nsTextFragment, which is
michael@0: // effectively a union of a one-byte string or a two-byte string.
michael@0: // Single and double strings are intermixed in the dom.
michael@0: // We don't have string classes which can deal with intermixed strings,
michael@0: // so all the handling is done explicitly here.
michael@0: //
michael@0: 
michael@0: nsresult
michael@0: nsFind::NextNode(nsIDOMRange* aSearchRange,
michael@0:                  nsIDOMRange* aStartPoint, nsIDOMRange* aEndPoint,
michael@0:                  bool aContinueOk)
michael@0: {
michael@0:   nsresult rv;
michael@0: 
michael@0:   nsCOMPtr<nsIContent> content;
michael@0: 
michael@0:   if (!mIterator || aContinueOk)
michael@0:   {
michael@0:     // If we are continuing, that means we have a match in progress.
michael@0:     // In that case, we want to continue from the end point
michael@0:     // (where we are now) to the beginning/end of the search range.
michael@0:     nsCOMPtr<nsIDOMNode> startNode;
michael@0:     nsCOMPtr<nsIDOMNode> endNode;
michael@0:     int32_t startOffset, endOffset;
michael@0:     if (aContinueOk)
michael@0:     {
michael@0: #ifdef DEBUG_FIND
michael@0:       printf("Match in progress: continuing past endpoint\n");
michael@0: #endif
michael@0:       if (mFindBackward) {
michael@0:         aSearchRange->GetStartContainer(getter_AddRefs(startNode));
michael@0:         aSearchRange->GetStartOffset(&startOffset);
michael@0:         aEndPoint->GetStartContainer(getter_AddRefs(endNode));
michael@0:         aEndPoint->GetStartOffset(&endOffset);
michael@0:       } else {     // forward
michael@0:         aEndPoint->GetEndContainer(getter_AddRefs(startNode));
michael@0:         aEndPoint->GetEndOffset(&startOffset);
michael@0:         aSearchRange->GetEndContainer(getter_AddRefs(endNode));
michael@0:         aSearchRange->GetEndOffset(&endOffset);
michael@0:       }
michael@0:     }
michael@0:     else  // Normal, not continuing
michael@0:     {
michael@0:       if (mFindBackward) {
michael@0:         aSearchRange->GetStartContainer(getter_AddRefs(startNode));
michael@0:         aSearchRange->GetStartOffset(&startOffset);
michael@0:         aStartPoint->GetEndContainer(getter_AddRefs(endNode));
michael@0:         aStartPoint->GetEndOffset(&endOffset);
michael@0:         // XXX Needs work:
michael@0:         // Problem with this approach: if there is a match which starts
michael@0:         // just before the current selection and continues into the selection,
michael@0:         // we will miss it, because our search algorithm only starts
michael@0:         // searching from the end of the word, so we would have to
michael@0:         // search the current selection but discount any matches
michael@0:         // that fall entirely inside it.
michael@0:       } else {     // forward
michael@0:         aStartPoint->GetStartContainer(getter_AddRefs(startNode));
michael@0:         aStartPoint->GetStartOffset(&startOffset);
michael@0:         aEndPoint->GetEndContainer(getter_AddRefs(endNode));
michael@0:         aEndPoint->GetEndOffset(&endOffset);
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     rv = InitIterator(startNode, startOffset, endNode, endOffset);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0:     if (!aStartPoint)
michael@0:       aStartPoint = aSearchRange;
michael@0: 
michael@0:     content = do_QueryInterface(mIterator->GetCurrentNode());
michael@0: #ifdef DEBUG_FIND
michael@0:     nsCOMPtr<nsIDOMNode> dnode (do_QueryInterface(content));
michael@0:     printf(":::::: Got the first node "); DumpNode(dnode);
michael@0: #endif
michael@0:     if (content && content->IsNodeOfType(nsINode::eTEXT) &&
michael@0:         !SkipNode(content))
michael@0:     {
michael@0:       mIterNode = do_QueryInterface(content);
michael@0:       // Also set mIterOffset if appropriate:
michael@0:       nsCOMPtr<nsIDOMNode> node;
michael@0:       if (mFindBackward) {
michael@0:         aStartPoint->GetEndContainer(getter_AddRefs(node));
michael@0:         if (mIterNode.get() == node.get())
michael@0:           aStartPoint->GetEndOffset(&mIterOffset);
michael@0:         else
michael@0:           mIterOffset = -1;   // sign to start from end
michael@0:       }
michael@0:       else
michael@0:       {
michael@0:         aStartPoint->GetStartContainer(getter_AddRefs(node));
michael@0:         if (mIterNode.get() == node.get())
michael@0:           aStartPoint->GetStartOffset(&mIterOffset);
michael@0:         else
michael@0:           mIterOffset = 0;
michael@0:       }
michael@0: #ifdef DEBUG_FIND
michael@0:       printf("Setting initial offset to %d\n", mIterOffset);
michael@0: #endif
michael@0:       return NS_OK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   while (1)
michael@0:   {
michael@0:     if (mFindBackward)
michael@0:       mIterator->Prev();
michael@0:     else
michael@0:       mIterator->Next();
michael@0: 
michael@0:     content = do_QueryInterface(mIterator->GetCurrentNode());
michael@0:     if (!content)
michael@0:       break;
michael@0: 
michael@0: #ifdef DEBUG_FIND
michael@0:     nsCOMPtr<nsIDOMNode> dnode (do_QueryInterface(content));
michael@0:     printf(":::::: Got another node "); DumpNode(dnode);
michael@0: #endif
michael@0: 
michael@0:     // If we ever cross a block node, we might want to reset
michael@0:     // the match anchor:
michael@0:     // we don't match patterns extending across block boundaries.
michael@0:     // But we can't depend on this test here now, because the iterator
michael@0:     // doesn't give us the parent going in and going out, and we
michael@0:     // need it both times to depend on this.
michael@0:     //if (IsBlockNode(content))
michael@0: 
michael@0:     // Now see if we need to skip this node --
michael@0:     // e.g. is it part of a script or other invisible node?
michael@0:     // Note that we don't ask for CSS information;
michael@0:     // a node can be invisible due to CSS, and we'd still find it.
michael@0:     if (SkipNode(content))
michael@0:       continue;
michael@0: 
michael@0:     if (content->IsNodeOfType(nsINode::eTEXT))
michael@0:       break;
michael@0: #ifdef DEBUG_FIND
michael@0:     dnode = do_QueryInterface(content);
michael@0:     printf("Not a text node: "); DumpNode(dnode);
michael@0: #endif
michael@0:   }
michael@0: 
michael@0:   if (content)
michael@0:     mIterNode = do_QueryInterface(content);
michael@0:   else
michael@0:     mIterNode = nullptr;
michael@0:   mIterOffset = -1;
michael@0: 
michael@0: #ifdef DEBUG_FIND
michael@0:   printf("Iterator gave: "); DumpNode(mIterNode);
michael@0: #endif
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: bool nsFind::IsBlockNode(nsIContent* aContent)
michael@0: {
michael@0:   if (!aContent->IsHTML()) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   nsIAtom *atom = aContent->Tag();
michael@0: 
michael@0:   if (atom == nsGkAtoms::img ||
michael@0:       atom == nsGkAtoms::hr ||
michael@0:       atom == nsGkAtoms::th ||
michael@0:       atom == nsGkAtoms::td)
michael@0:     return true;
michael@0: 
michael@0:   return nsContentUtils::IsHTMLBlock(atom);
michael@0: }
michael@0: 
michael@0: bool nsFind::IsTextNode(nsIDOMNode* aNode)
michael@0: {
michael@0:   uint16_t nodeType;
michael@0:   aNode->GetNodeType(&nodeType);
michael@0: 
michael@0:   return nodeType == nsIDOMNode::TEXT_NODE ||
michael@0:          nodeType == nsIDOMNode::CDATA_SECTION_NODE;
michael@0: }
michael@0: 
michael@0: bool nsFind::IsVisibleNode(nsIDOMNode *aDOMNode)
michael@0: {
michael@0:   nsCOMPtr<nsIContent> content(do_QueryInterface(aDOMNode));
michael@0:   if (!content)
michael@0:     return false;
michael@0: 
michael@0:   nsIFrame *frame = content->GetPrimaryFrame();
michael@0:   if (!frame) {
michael@0:     // No frame! Not visible then.
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   return frame->StyleVisibility()->IsVisible();
michael@0: }
michael@0: 
michael@0: bool nsFind::SkipNode(nsIContent* aContent)
michael@0: {
michael@0:   nsIAtom *atom;
michael@0: 
michael@0: #ifdef HAVE_BIDI_ITERATOR
michael@0:   atom = aContent->Tag();
michael@0: 
michael@0:   // We may not need to skip comment nodes,
michael@0:   // now that IsTextNode distinguishes them from real text nodes.
michael@0:   return (aContent->IsNodeOfType(nsINode::eCOMMENT) ||
michael@0:           (aContent->IsHTML() &&
michael@0:            (atom == sScriptAtom ||
michael@0:             atom == sNoframesAtom ||
michael@0:             atom == sSelectAtom)));
michael@0: 
michael@0: #else /* HAVE_BIDI_ITERATOR */
michael@0:   // Temporary: eventually we will have an iterator to do this,
michael@0:   // but for now, we have to climb up the tree for each node
michael@0:   // and see whether any parent is a skipped node,
michael@0:   // and take the performance hit.
michael@0: 
michael@0:   nsIContent *content = aContent;
michael@0:   while (content)
michael@0:   {
michael@0:     atom = content->Tag();
michael@0: 
michael@0:     if (aContent->IsNodeOfType(nsINode::eCOMMENT) ||
michael@0:         (content->IsHTML() &&
michael@0:          (atom == nsGkAtoms::script ||
michael@0:           atom == nsGkAtoms::noframes ||
michael@0:           atom == nsGkAtoms::select)))
michael@0:     {
michael@0: #ifdef DEBUG_FIND
michael@0:       printf("Skipping node: ");
michael@0:       nsCOMPtr<nsIDOMNode> node (do_QueryInterface(content));
michael@0:       DumpNode(node);
michael@0: #endif
michael@0: 
michael@0:       return true;
michael@0:     }
michael@0: 
michael@0:     // Only climb to the nearest block node
michael@0:     if (IsBlockNode(content))
michael@0:       return false;
michael@0: 
michael@0:     content = content->GetParent();
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: #endif /* HAVE_BIDI_ITERATOR */
michael@0: }
michael@0: 
michael@0: nsresult nsFind::GetBlockParent(nsIDOMNode* aNode, nsIDOMNode** aParent)
michael@0: {
michael@0:   while (aNode)
michael@0:   {
michael@0:     nsCOMPtr<nsIDOMNode> parent;
michael@0:     nsresult rv = aNode->GetParentNode(getter_AddRefs(parent));
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0:     nsCOMPtr<nsIContent> content (do_QueryInterface(parent));
michael@0:     if (content && IsBlockNode(content))
michael@0:     {
michael@0:       *aParent = parent;
michael@0:       NS_ADDREF(*aParent);
michael@0:       return NS_OK;
michael@0:     }
michael@0:     aNode = parent;
michael@0:   }
michael@0:   return NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: // Call ResetAll before returning,
michael@0: // to remove all references to external objects.
michael@0: void nsFind::ResetAll()
michael@0: {
michael@0:   mIterator = nullptr;
michael@0:   mLastBlockParent = nullptr;
michael@0: }
michael@0: 
michael@0: #define NBSP_CHARCODE (CHAR_TO_UNICHAR(160))
michael@0: #define IsSpace(c) (nsCRT::IsAsciiSpace(c) || (c) == NBSP_CHARCODE)
michael@0: #define OVERFLOW_PINDEX (mFindBackward ? pindex < 0 : pindex > patLen)
michael@0: #define DONE_WITH_PINDEX (mFindBackward ? pindex <= 0 : pindex >= patLen)
michael@0: #define ALMOST_DONE_WITH_PINDEX (mFindBackward ? pindex <= 0 : pindex >= patLen-1)
michael@0: 
michael@0: //
michael@0: // Find:
michael@0: // Take nodes out of the tree with NextNode,
michael@0: // until null (NextNode will return 0 at the end of our range).
michael@0: //
michael@0: NS_IMETHODIMP
michael@0: nsFind::Find(const char16_t *aPatText, nsIDOMRange* aSearchRange,
michael@0:              nsIDOMRange* aStartPoint, nsIDOMRange* aEndPoint,
michael@0:              nsIDOMRange** aRangeRet)
michael@0: {
michael@0: #ifdef DEBUG_FIND
michael@0:   printf("============== nsFind::Find('%s'%s, %p, %p, %p)\n",
michael@0:          NS_LossyConvertUTF16toASCII(aPatText).get(),
michael@0:          mFindBackward ? " (backward)" : " (forward)",
michael@0:          (void*)aSearchRange, (void*)aStartPoint, (void*)aEndPoint);
michael@0: #endif
michael@0: 
michael@0:   NS_ENSURE_ARG(aSearchRange);
michael@0:   NS_ENSURE_ARG(aStartPoint);
michael@0:   NS_ENSURE_ARG(aEndPoint);
michael@0:   NS_ENSURE_ARG_POINTER(aRangeRet);
michael@0:   *aRangeRet = 0;
michael@0: 
michael@0:   if (!aPatText)
michael@0:     return NS_ERROR_NULL_POINTER;
michael@0: 
michael@0:   ResetAll();
michael@0: 
michael@0:   nsAutoString patAutoStr(aPatText);
michael@0:   if (!mCaseSensitive)
michael@0:     ToLowerCase(patAutoStr);
michael@0: 
michael@0:   // Ignore soft hyphens in the pattern
michael@0:   static const char kShy[] = { char(CH_SHY), 0 };
michael@0:   patAutoStr.StripChars(kShy);
michael@0: 
michael@0:   const char16_t* patStr = patAutoStr.get();
michael@0:   int32_t patLen = patAutoStr.Length() - 1;
michael@0: 
michael@0:   // current offset into the pattern -- reset to beginning/end:
michael@0:   int32_t pindex = (mFindBackward ? patLen : 0);
michael@0: 
michael@0:   // Current offset into the fragment
michael@0:   int32_t findex = 0;
michael@0: 
michael@0:   // Direction to move pindex and ptr*
michael@0:   int incr = (mFindBackward ? -1 : 1);
michael@0: 
michael@0:   nsCOMPtr<nsIContent> tc;
michael@0:   const nsTextFragment *frag = nullptr;
michael@0:   int32_t fragLen = 0;
michael@0: 
michael@0:   // Pointers into the current fragment:
michael@0:   const char16_t *t2b = nullptr;
michael@0:   const char      *t1b = nullptr;
michael@0: 
michael@0:   // Keep track of when we're in whitespace:
michael@0:   // (only matters when we're matching)
michael@0:   bool inWhitespace = false;
michael@0: 
michael@0:   // Place to save the range start point in case we find a match:
michael@0:   nsCOMPtr<nsIDOMNode> matchAnchorNode;
michael@0:   int32_t matchAnchorOffset = 0;
michael@0: 
michael@0:   // Get the end point, so we know when to end searches:
michael@0:   nsCOMPtr<nsIDOMNode> endNode;
michael@0:   int32_t endOffset;
michael@0:   aEndPoint->GetEndContainer(getter_AddRefs(endNode));
michael@0:   aEndPoint->GetEndOffset(&endOffset);
michael@0: 
michael@0:   char16_t prevChar = 0;
michael@0:   while (1)
michael@0:   {
michael@0: #ifdef DEBUG_FIND
michael@0:     printf("Loop ...\n");
michael@0: #endif
michael@0: 
michael@0:     // If this is our first time on a new node, reset the pointers:
michael@0:     if (!frag)
michael@0:     {
michael@0: 
michael@0:       tc = nullptr;
michael@0:       NextNode(aSearchRange, aStartPoint, aEndPoint, false);
michael@0:       if (!mIterNode)    // Out of nodes
michael@0:       {
michael@0:         // Are we in the middle of a match?
michael@0:         // If so, try again with continuation.
michael@0:         if (matchAnchorNode)
michael@0:           NextNode(aSearchRange, aStartPoint, aEndPoint, true);
michael@0: 
michael@0:         // Reset the iterator, so this nsFind will be usable if
michael@0:         // the user wants to search again (from beginning/end).
michael@0:         ResetAll();
michael@0:         return NS_OK;
michael@0:       }
michael@0: 
michael@0:       // We have a new text content.  If its block parent is different
michael@0:       // from the block parent of the last text content, then we
michael@0:       // need to clear the match since we don't want to find
michael@0:       // across block boundaries.
michael@0:       nsCOMPtr<nsIDOMNode> blockParent;
michael@0:       GetBlockParent(mIterNode, getter_AddRefs(blockParent));
michael@0: #ifdef DEBUG_FIND
michael@0:       printf("New node: old blockparent = %p, new = %p\n",
michael@0:              (void*)mLastBlockParent.get(), (void*)blockParent.get());
michael@0: #endif
michael@0:       if (blockParent != mLastBlockParent)
michael@0:       {
michael@0: #ifdef DEBUG_FIND
michael@0:         printf("Different block parent!\n");
michael@0: #endif
michael@0:         mLastBlockParent = blockParent;
michael@0:         // End any pending match:
michael@0:         matchAnchorNode = nullptr;
michael@0:         matchAnchorOffset = 0;
michael@0:         pindex = (mFindBackward ? patLen : 0);
michael@0:         inWhitespace = false;
michael@0:       }
michael@0: 
michael@0:       // Get the text content:
michael@0:       tc = do_QueryInterface(mIterNode);
michael@0:       if (!tc || !(frag = tc->GetText())) // Out of nodes
michael@0:       {
michael@0:         mIterator = nullptr;
michael@0:         mLastBlockParent = 0;
michael@0:         ResetAll();
michael@0:         return NS_OK;
michael@0:       }
michael@0: 
michael@0:       fragLen = frag->GetLength();
michael@0: 
michael@0:       // Set our starting point in this node.
michael@0:       // If we're going back to the anchor node, which means that we
michael@0:       // just ended a partial match, use the saved offset:
michael@0:       if (mIterNode == matchAnchorNode)
michael@0:         findex = matchAnchorOffset + (mFindBackward ? 1 : 0);
michael@0: 
michael@0:       // mIterOffset, if set, is the range's idea of an offset,
michael@0:       // and points between characters.  But when translated
michael@0:       // to a string index, it points to a character.  If we're
michael@0:       // going backward, this is one character too late and
michael@0:       // we'll match part of our previous pattern.
michael@0:       else if (mIterOffset >= 0)
michael@0:         findex = mIterOffset - (mFindBackward ? 1 : 0);
michael@0: 
michael@0:       // Otherwise, just start at the appropriate end of the fragment:
michael@0:       else if (mFindBackward)
michael@0:         findex = fragLen - 1;
michael@0:       else
michael@0:         findex = 0;
michael@0: 
michael@0:       // Offset can only apply to the first node:
michael@0:       mIterOffset = -1;
michael@0: 
michael@0:       // If this is outside the bounds of the string, then skip this node:
michael@0:       if (findex < 0 || findex > fragLen-1)
michael@0:       {
michael@0: #ifdef DEBUG_FIND
michael@0:         printf("At the end of a text node -- skipping to the next\n");
michael@0: #endif
michael@0:         frag = 0;
michael@0:         continue;
michael@0:       }
michael@0: 
michael@0: #ifdef DEBUG_FIND
michael@0:       printf("Starting from offset %d\n", findex);
michael@0: #endif
michael@0:       if (frag->Is2b())
michael@0:       {
michael@0:         t2b = frag->Get2b();
michael@0:         t1b = nullptr;
michael@0: #ifdef DEBUG_FIND
michael@0:         nsAutoString str2(t2b, fragLen);
michael@0:         printf("2 byte, '%s'\n", NS_LossyConvertUTF16toASCII(str2).get());
michael@0: #endif
michael@0:       }
michael@0:       else
michael@0:       {
michael@0:         t1b = frag->Get1b();
michael@0:         t2b = nullptr;
michael@0: #ifdef DEBUG_FIND
michael@0:         nsAutoCString str1(t1b, fragLen);
michael@0:         printf("1 byte, '%s'\n", str1.get());
michael@0: #endif
michael@0:       }
michael@0:     }
michael@0:     else // still on the old node
michael@0:     {
michael@0:       // Still on the old node.  Advance the pointers,
michael@0:       // then see if we need to pull a new node.
michael@0:       findex += incr;
michael@0: #ifdef DEBUG_FIND
michael@0:       printf("Same node -- (%d, %d)\n", pindex, findex);
michael@0: #endif
michael@0:       if (mFindBackward ? (findex < 0) : (findex >= fragLen))
michael@0:       {
michael@0: #ifdef DEBUG_FIND
michael@0:         printf("Will need to pull a new node: mAO = %d, frag len=%d\n",
michael@0:                matchAnchorOffset, fragLen);
michael@0: #endif
michael@0:         // Done with this node.  Pull a new one.
michael@0:         frag = nullptr;
michael@0:         continue;
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     // Have we gone past the endpoint yet?
michael@0:     // If we have, and we're not in the middle of a match, return.
michael@0:     if (mIterNode == endNode &&
michael@0:         ((mFindBackward && (findex < endOffset)) ||
michael@0:          (!mFindBackward && (findex > endOffset))))
michael@0:     {
michael@0:       ResetAll();
michael@0:       return NS_OK;
michael@0:     }
michael@0: 
michael@0:     // The two characters we'll be comparing:
michael@0:     char16_t c = (t2b ? t2b[findex] : CHAR_TO_UNICHAR(t1b[findex]));
michael@0:     char16_t patc = patStr[pindex];
michael@0: 
michael@0: #ifdef DEBUG_FIND
michael@0:     printf("Comparing '%c'=%x to '%c' (%d of %d), findex=%d%s\n",
michael@0:            (char)c, (int)c, patc, pindex, patLen, findex,
michael@0:            inWhitespace ? " (inWhitespace)" : "");
michael@0: #endif
michael@0: 
michael@0:     // Do we need to go back to non-whitespace mode?
michael@0:     // If inWhitespace, then this space in the pat str
michael@0:     // has already matched at least one space in the document.
michael@0:     if (inWhitespace && !IsSpace(c))
michael@0:     {
michael@0:       inWhitespace = false;
michael@0:       pindex += incr;
michael@0: #ifdef DEBUG
michael@0:       // This shouldn't happen -- if we were still matching, and we
michael@0:       // were at the end of the pat string, then we should have
michael@0:       // caught it in the last iteration and returned success.
michael@0:       if (OVERFLOW_PINDEX)
michael@0:         NS_ASSERTION(false, "Missed a whitespace match");
michael@0: #endif
michael@0:       patc = patStr[pindex];
michael@0:     }
michael@0:     if (!inWhitespace && IsSpace(patc))
michael@0:       inWhitespace = true;
michael@0: 
michael@0:     // convert to lower case if necessary
michael@0:     else if (!inWhitespace && !mCaseSensitive && IsUpperCase(c))
michael@0:       c = ToLowerCase(c);
michael@0: 
michael@0:     switch (c) {
michael@0:       // ignore soft hyphens in the document
michael@0:       case CH_SHY:
michael@0:         continue;
michael@0:       // treat curly and straight quotes as identical
michael@0:       case CH_LEFT_SINGLE_QUOTE:
michael@0:       case CH_RIGHT_SINGLE_QUOTE:
michael@0:         c = CH_APOSTROPHE;
michael@0:         break;
michael@0:       case CH_LEFT_DOUBLE_QUOTE:
michael@0:       case CH_RIGHT_DOUBLE_QUOTE:
michael@0:         c = CH_QUOTE;
michael@0:         break;
michael@0:     }
michael@0: 
michael@0:     switch (patc) {
michael@0:       // treat curly and straight quotes as identical
michael@0:       case CH_LEFT_SINGLE_QUOTE:
michael@0:       case CH_RIGHT_SINGLE_QUOTE:
michael@0:         patc = CH_APOSTROPHE;
michael@0:         break;
michael@0:       case CH_LEFT_DOUBLE_QUOTE:
michael@0:       case CH_RIGHT_DOUBLE_QUOTE:
michael@0:         patc = CH_QUOTE;
michael@0:         break;
michael@0:     }
michael@0: 
michael@0:     // a '\n' between CJ characters is ignored
michael@0:     if (pindex != (mFindBackward ? patLen : 0) && c != patc && !inWhitespace) {
michael@0:       if (c == '\n' && t2b && IS_CJ_CHAR(prevChar)) {
michael@0:         int32_t nindex = findex + incr;
michael@0:         if (mFindBackward ? (nindex >= 0) : (nindex < fragLen)) {
michael@0:           if (IS_CJ_CHAR(t2b[nindex]))
michael@0:             continue;
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     // Compare
michael@0:     if ((c == patc) || (inWhitespace && IsSpace(c)))
michael@0:     {
michael@0:       prevChar = c;
michael@0: #ifdef DEBUG_FIND
michael@0:       if (inWhitespace)
michael@0:         printf("YES (whitespace)(%d of %d)\n", pindex, patLen);
michael@0:       else
michael@0:         printf("YES! '%c' == '%c' (%d of %d)\n", c, patc, pindex, patLen);
michael@0: #endif
michael@0: 
michael@0:       // Save the range anchors if we haven't already:
michael@0:       if (!matchAnchorNode) {
michael@0:         matchAnchorNode = mIterNode;
michael@0:         matchAnchorOffset = findex;
michael@0:       }
michael@0: 
michael@0:       // Are we done?
michael@0:       if (DONE_WITH_PINDEX)
michael@0:         // Matched the whole string!
michael@0:       {
michael@0: #ifdef DEBUG_FIND
michael@0:         printf("Found a match!\n");
michael@0: #endif
michael@0: 
michael@0:         // Make the range:
michael@0:         nsCOMPtr<nsIDOMNode> startParent;
michael@0:         nsCOMPtr<nsIDOMNode> endParent;
michael@0:         nsCOMPtr<nsIDOMRange> range = CreateRange(tc);
michael@0:         if (range)
michael@0:         {
michael@0:           int32_t matchStartOffset, matchEndOffset;
michael@0:           // convert char index to range point:
michael@0:           int32_t mao = matchAnchorOffset + (mFindBackward ? 1 : 0);
michael@0:           if (mFindBackward)
michael@0:           {
michael@0:             startParent = do_QueryInterface(tc);
michael@0:             endParent = matchAnchorNode;
michael@0:             matchStartOffset = findex;
michael@0:             matchEndOffset = mao;
michael@0:           }
michael@0:           else
michael@0:           {
michael@0:             startParent = matchAnchorNode;
michael@0:             endParent = do_QueryInterface(tc);
michael@0:             matchStartOffset = mao;
michael@0:             matchEndOffset = findex+1;
michael@0:           }
michael@0:           if (startParent && endParent &&
michael@0:               IsVisibleNode(startParent) && IsVisibleNode(endParent))
michael@0:           {
michael@0:             range->SetStart(startParent, matchStartOffset);
michael@0:             range->SetEnd(endParent, matchEndOffset);
michael@0:             *aRangeRet = range.get();
michael@0:             NS_ADDREF(*aRangeRet);
michael@0:           }
michael@0:           else {
michael@0:             startParent = nullptr; // This match is no good -- invisible or bad range
michael@0:           }
michael@0:         }
michael@0: 
michael@0:         if (startParent) {
michael@0:           // If startParent == nullptr, we didn't successfully make range
michael@0:           // or, we didn't make a range because the start or end node were invisible
michael@0:           // Reset the offset to the other end of the found string:
michael@0:           mIterOffset = findex + (mFindBackward ? 1 : 0);
michael@0:   #ifdef DEBUG_FIND
michael@0:           printf("mIterOffset = %d, mIterNode = ", mIterOffset);
michael@0:           DumpNode(mIterNode);
michael@0:   #endif
michael@0: 
michael@0:           ResetAll();
michael@0:           return NS_OK;
michael@0:         }
michael@0:         matchAnchorNode = nullptr;  // This match is no good, continue on in document
michael@0:       }
michael@0: 
michael@0:       if (matchAnchorNode) {
michael@0:         // Not done, but still matching.
michael@0:         // Advance and loop around for the next characters.
michael@0:         // But don't advance from a space to a non-space:
michael@0:         if (!inWhitespace || DONE_WITH_PINDEX || IsSpace(patStr[pindex+incr]))
michael@0:         {
michael@0:           pindex += incr;
michael@0:           inWhitespace = false;
michael@0: #ifdef DEBUG_FIND
michael@0:           printf("Advancing pindex to %d\n", pindex);
michael@0: #endif
michael@0:         }
michael@0: 
michael@0:         continue;
michael@0:       }
michael@0:     }
michael@0: 
michael@0: #ifdef DEBUG_FIND
michael@0:     printf("NOT: %c == %c\n", c, patc);
michael@0: #endif
michael@0: 
michael@0:     // If we didn't match, go back to the beginning of patStr,
michael@0:     // and set findex back to the next char after
michael@0:     // we started the current match.
michael@0:     if (matchAnchorNode)    // we're ending a partial match
michael@0:     {
michael@0:       findex = matchAnchorOffset;
michael@0:       mIterOffset = matchAnchorOffset;
michael@0:           // +incr will be added to findex when we continue
michael@0: 
michael@0:       // Are we going back to a previous node?
michael@0:       if (matchAnchorNode != mIterNode)
michael@0:       {
michael@0:         nsCOMPtr<nsIContent> content (do_QueryInterface(matchAnchorNode));
michael@0:         DebugOnly<nsresult> rv = NS_ERROR_UNEXPECTED;
michael@0:         if (content)
michael@0:           rv = mIterator->PositionAt(content);
michael@0:         frag = 0;
michael@0:         NS_ASSERTION(NS_SUCCEEDED(rv), "Text content wasn't nsIContent!");
michael@0: #ifdef DEBUG_FIND
michael@0:         printf("Repositioned anchor node\n");
michael@0: #endif
michael@0:       }
michael@0: #ifdef DEBUG_FIND
michael@0:       printf("Ending a partial match; findex -> %d, mIterOffset -> %d\n",
michael@0:              findex, mIterOffset);
michael@0: #endif
michael@0:     }
michael@0:     matchAnchorNode = nullptr;
michael@0:     matchAnchorOffset = 0;
michael@0:     inWhitespace = false;
michael@0:     pindex = (mFindBackward ? patLen : 0);
michael@0: #ifdef DEBUG_FIND
michael@0:     printf("Setting findex back to %d, pindex to %d\n", findex, pindex);
michael@0: 
michael@0: #endif
michael@0:   } // end while loop
michael@0: 
michael@0:   // Out of nodes, and didn't match.
michael@0:   ResetAll();
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: already_AddRefed<nsIDOMRange>
michael@0: nsFind::CreateRange(nsINode* aNode)
michael@0: {
michael@0:   nsRefPtr<nsRange> range = new nsRange(aNode);
michael@0:   range->SetMaySpanAnonymousSubtrees(true);
michael@0:   return range.forget();
michael@0: }