More mac tweaks.

git-svn-id: svn://10.0.0.236/branches/logging_102400_branch@81877 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/htmlparser/src/nsAVLTree.cpp

@@ -0,0 +1,621 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+#include "nsAVLTree.h"
+ 
+
+enum eLean      {eLeft,eNeutral,eRight};
+
+struct NS_COM nsAVLNode {
+public:
+
+  nsAVLNode(void* aValue) {
+    mLeft=0;
+    mRight=0;
+    mSkew=eNeutral;
+    mValue=aValue;
+  }
+
+  nsAVLNode*  mLeft;
+  nsAVLNode*  mRight;
+  eLean       mSkew;
+  void*       mValue;
+};
+
+
+/************************************************************
+  Now begin the tree class. Don't forget that the comparison
+  between nodes must occur via the comparitor function, 
+  otherwise all you're testing is pointer addresses.
+ ************************************************************/
+
+/** ------------------------------------------------
+ * 
+ * 
+ * @update gess 4/22/98
+ * @param  
+ * @return 
+ */ //----------------------------------------------
+nsAVLTree::nsAVLTree(nsAVLNodeComparitor& aComparitor, 
+                     nsAVLNodeFunctor* aDeallocator) :
+  mComparitor(aComparitor), mDeallocator(aDeallocator) {
+  mRoot=0;
+  mCount=0;
+}
+
+
+static void 
+avlDeleteTree(nsAVLNode* aNode){
+  if (aNode) {
+    avlDeleteTree(aNode->mLeft);
+    avlDeleteTree(aNode->mRight);
+    delete aNode;
+  }
+}
+
+/**
+ * 
+ * @update	gess12/27/98
+ * @param 
+ * @return
+ */
+nsAVLTree::~nsAVLTree(){
+  if (mDeallocator) {
+    ForEachDepthFirst(*mDeallocator);
+  }
+  avlDeleteTree(mRoot);
+}
+
+
+class CDoesntExist: public nsAVLNodeFunctor {
+public:
+  CDoesntExist(const nsAVLTree& anotherTree) : mOtherTree(anotherTree) {
+  }
+  virtual void* operator()(void* anItem) {
+    void* result=mOtherTree.FindItem(anItem);
+    if(result)
+      return nsnull;
+    return anItem;
+  }
+protected:
+  const nsAVLTree& mOtherTree;
+};
+
+/**
+ * This method compares two trees (members by identity).
+ * @update	gess12/27/98
+ * @param   tree to compare against
+ * @return  true if they are identical (contain same stuff).
+ */
+PRBool nsAVLTree::operator==(const nsAVLTree& aCopy) const{
+  CDoesntExist functor(aCopy);
+  void* theItem=FirstThat(functor);
+  PRBool result=PRBool(!theItem);
+  return result;
+}
+
+
+/**
+ * 
+ * @update	gess12/27/98
+ * @param 
+ * @return
+ */
+static void 
+avlRotateRight(nsAVLNode*& aRootNode){
+  nsAVLNode* ptr2;
+  nsAVLNode* ptr3;
+
+  ptr2=aRootNode->mRight;
+  if(ptr2->mSkew==eRight) {
+    aRootNode->mRight=ptr2->mLeft;
+    ptr2->mLeft=aRootNode;
+    aRootNode->mSkew=eNeutral;
+    aRootNode=ptr2;
+  }
+  else {
+    ptr3=ptr2->mLeft;
+    ptr2->mLeft=ptr3->mRight;
+    ptr3->mRight=ptr2;
+    aRootNode->mRight=ptr3->mLeft;
+    ptr3->mLeft=aRootNode;
+    if(ptr3->mSkew==eLeft)
+      ptr2->mSkew=eRight;
+    else ptr2->mSkew=eNeutral;
+    if(ptr3->mSkew==eRight)
+      aRootNode->mSkew=eLeft;
+    else aRootNode->mSkew=eNeutral;
+    aRootNode=ptr3;
+  }
+  aRootNode->mSkew=eNeutral;
+  return;
+}
+
+
+
+/**
+ * 
+ * @update	gess12/27/98
+ * @param 
+ * @return
+ */
+static void 
+avlRotateLeft(nsAVLNode*& aRootNode){
+  nsAVLNode* ptr2;
+  nsAVLNode* ptr3;
+
+  ptr2=aRootNode->mLeft;
+  if(ptr2->mSkew==eLeft) {
+    aRootNode->mLeft=ptr2->mRight;
+    ptr2->mRight=aRootNode;
+    aRootNode->mSkew=eNeutral;
+    aRootNode=ptr2;
+  }
+  else {
+    ptr3=ptr2->mRight;
+    ptr2->mRight=ptr3->mLeft;
+    ptr3->mLeft=ptr2;
+    aRootNode->mLeft=ptr3->mRight;
+    ptr3->mRight=aRootNode;
+    if(ptr3->mSkew==eRight)
+      ptr2->mSkew=eLeft;
+    else ptr2->mSkew=eNeutral;
+    if(ptr3->mSkew==eLeft)
+      aRootNode->mSkew=eRight;
+    else aRootNode->mSkew=eNeutral;
+    aRootNode=ptr3;
+  }
+  aRootNode->mSkew=eNeutral;
+  return;
+}
+
+
+/** ------------------------------------------------
+ * 
+ * 
+ * @update gess 4/22/98
+ * @param  
+ * @return 
+ */ //----------------------------------------------
+static eAVLStatus 
+avlInsert(nsAVLNode*& aRootNode, nsAVLNode* aNewNode, 
+          nsAVLNodeComparitor& aComparitor) {
+  eAVLStatus result=eAVL_unknown;
+  
+  if(!aRootNode) {
+    aRootNode = aNewNode;
+    return eAVL_ok;
+  }
+  
+  if(aNewNode==aRootNode->mValue) {
+    return eAVL_duplicate;
+  }
+
+  PRInt32 theCompareResult=aComparitor(aRootNode->mValue,aNewNode->mValue);
+  if(0 < theCompareResult) { //if(anItem<aRootNode->mValue)
+    result=avlInsert(aRootNode->mLeft,aNewNode,aComparitor);
+    if(eAVL_ok==result) {
+      switch(aRootNode->mSkew){
+        case eLeft:
+          avlRotateLeft(aRootNode);
+          result=eAVL_fail;
+          break;
+        case eRight:
+          aRootNode->mSkew=eNeutral;
+          result=eAVL_fail;
+          break;
+        case eNeutral:
+          aRootNode->mSkew=eLeft;
+          break;
+      } //switch
+    }//if
+  } //if
+  else { 
+    result=avlInsert(aRootNode->mRight,aNewNode,aComparitor);
+    if(eAVL_ok==result) {
+      switch(aRootNode->mSkew){
+        case eLeft:
+          aRootNode->mSkew=eNeutral;
+          result=eAVL_fail;
+          break;
+        case eRight:
+          avlRotateRight(aRootNode);
+          result=eAVL_fail;
+          break;
+        case eNeutral:
+          aRootNode->mSkew=eRight;
+          break;
+      } //switch
+    }
+  } //if
+  return result;
+}
+
+/** ------------------------------------------------
+ * 
+ * 
+ * @update gess 4/22/98
+ * @param  
+ * @return 
+ */ //----------------------------------------------
+static void 
+avlBalanceLeft(nsAVLNode*& aRootNode, PRBool& delOk){
+  nsAVLNode*  ptr2;
+  nsAVLNode*  ptr3;
+  eLean       balnc2;
+  eLean       balnc3;
+
+  switch(aRootNode->mSkew){
+    case eLeft:
+      ptr2=aRootNode->mLeft;
+      balnc2=ptr2->mSkew;
+      if(balnc2!=eRight) {
+        aRootNode->mLeft=ptr2->mRight;
+        ptr2->mRight=aRootNode;
+        if(balnc2==eNeutral){
+          aRootNode->mSkew=eLeft;
+          ptr2->mSkew=eRight;
+          delOk=PR_FALSE;
+        }
+        else{
+          aRootNode->mSkew=eNeutral;
+          ptr2->mSkew=eNeutral;
+        }
+        aRootNode=ptr2;
+      }
+      else{
+        ptr3=ptr2->mRight;
+        balnc3=ptr3->mSkew;
+        ptr2->mRight=ptr3->mLeft;
+        ptr3->mLeft=ptr2;
+        aRootNode->mLeft=ptr3->mRight;
+        ptr3->mRight=aRootNode;
+        if(balnc3==eRight) {
+          ptr2->mSkew=eLeft;
+        }
+        else {
+          ptr2->mSkew=eNeutral;
+        }
+        if(balnc3==eLeft) {
+          aRootNode->mSkew=eRight;
+        }
+        else {
+          aRootNode->mSkew=eNeutral;
+        }
+        aRootNode=ptr3;
+        ptr3->mSkew=eNeutral;
+      }
+      break;
+
+    case eRight:
+      aRootNode->mSkew=eNeutral;
+      break;
+    
+    case eNeutral:
+      aRootNode->mSkew=eLeft;
+      delOk=PR_FALSE;
+      break;
+  }//switch
+  return;
+}
+
+/** ------------------------------------------------
+ * 
+ * 
+ * @update gess 4/22/98
+ * @param  
+ * @return 
+ */ //----------------------------------------------
+static void 
+avlBalanceRight(nsAVLNode*& aRootNode, PRBool& delOk){
+  nsAVLNode*  ptr2;
+  nsAVLNode*  ptr3;
+  eLean       balnc2;
+  eLean       balnc3;
+
+  switch(aRootNode->mSkew){
+    case eLeft:
+      aRootNode->mSkew=eNeutral;
+      break;
+
+    case eRight:
+      ptr2=aRootNode->mRight;
+      balnc2=ptr2->mSkew;
+      if(balnc2!=eLeft) {
+        aRootNode->mRight=ptr2->mLeft;
+        ptr2->mLeft=aRootNode;
+        if(balnc2==eNeutral){
+          aRootNode->mSkew=eRight;
+          ptr2->mSkew=eLeft;
+          delOk=PR_FALSE;
+        }
+        else{
+          aRootNode->mSkew=eNeutral;
+          ptr2->mSkew=eNeutral;
+        }
+        aRootNode=ptr2;
+      }
+      else{
+        ptr3=ptr2->mLeft;
+        balnc3=ptr3->mSkew;
+        ptr2->mLeft=ptr3->mRight;
+        ptr3->mRight=ptr2;
+        aRootNode->mRight=ptr3->mLeft;
+        ptr3->mLeft=aRootNode;
+        if(balnc3==eLeft) {
+          ptr2->mSkew=eRight;
+        }
+        else {
+          ptr2->mSkew=eNeutral;
+        }
+        if(balnc3==eRight) {
+          aRootNode->mSkew=eLeft;
+        }
+        else {
+          aRootNode->mSkew=eNeutral;
+        }
+        aRootNode=ptr3;
+        ptr3->mSkew=eNeutral;
+      }
+      break;
+
+    case eNeutral:
+      aRootNode->mSkew=eRight;
+      delOk=PR_FALSE;
+      break;
+  }//switch
+  return;
+}
+
+/** ------------------------------------------------
+ * 
+ * 
+ * @update gess 4/22/98
+ * @param  
+ * @return 
+ */ //----------------------------------------------
+static eAVLStatus 
+avlRemoveChildren(nsAVLNode*& aRootNode,nsAVLNode*& anotherNode, PRBool& delOk){
+  eAVLStatus result=eAVL_ok;
+  
+  if(!anotherNode->mRight){
+    aRootNode->mValue=anotherNode->mValue; //swap
+    anotherNode=anotherNode->mLeft;
+    delOk=PR_TRUE;
+  }
+  else{
+    avlRemoveChildren(aRootNode,anotherNode->mRight,delOk);
+    if(delOk)
+      avlBalanceLeft(anotherNode,delOk);
+  }
+
+  return result;
+}
+
+
+/** ------------------------------------------------
+ * 
+ * 
+ * @update gess 4/22/98
+ * @param  
+ * @return 
+ */ //----------------------------------------------
+static eAVLStatus 
+avlRemove(nsAVLNode*& aRootNode, void* anItem, PRBool& delOk,
+          nsAVLNodeComparitor& aComparitor){
+  eAVLStatus result=eAVL_ok;
+
+  if(!aRootNode)
+    delOk=PR_FALSE;
+  else {
+    PRInt32 cmp=aComparitor(anItem,aRootNode->mValue);
+    if(cmp<0){
+      avlRemove(aRootNode->mLeft,anItem,delOk,aComparitor);
+      if(delOk)
+        avlBalanceRight(aRootNode,delOk);
+    }
+    else if(cmp>0){
+      avlRemove(aRootNode->mRight,anItem,delOk,aComparitor);
+      if(delOk)
+        avlBalanceLeft(aRootNode,delOk);
+    }
+    else{ //they match...
+      nsAVLNode* temp=aRootNode;
+      if(!aRootNode->mRight) {
+        aRootNode=aRootNode->mLeft;
+        delOk=PR_TRUE;
+        delete temp;
+      }
+      else if(!aRootNode->mLeft) {
+        aRootNode=aRootNode->mRight;
+        delOk=PR_TRUE;
+        delete temp;
+      }
+      else {
+        avlRemoveChildren(aRootNode,aRootNode->mLeft,delOk);
+        if(delOk)
+          avlBalanceRight(aRootNode,delOk);
+      }
+    }
+  }
+
+  return result;
+}
+
+/** ------------------------------------------------
+ * 
+ * 
+ * @update gess 4/22/98
+ * @param  
+ * @return 
+ */ //----------------------------------------------
+eAVLStatus 
+nsAVLTree::AddItem(void* anItem){
+  eAVLStatus result=eAVL_ok;
+
+  nsAVLNode* theNewNode=new nsAVLNode(anItem);
+  result=avlInsert(mRoot,theNewNode,mComparitor);
+  if(eAVL_duplicate!=result)
+    mCount++;
+  else {
+    delete theNewNode;
+  }
+  return result;
+}
+
+/** ------------------------------------------------
+ * 
+ * 
+ * @update gess 4/22/98
+ * @param  
+ * @return 
+ */ //----------------------------------------------
+void* nsAVLTree::FindItem(void* aValue) const{
+  nsAVLNode* result=mRoot;
+  PRInt32 count=0;
+  while(result) {
+    count++;
+    PRInt32 cmp=mComparitor(aValue,result->mValue);
+    if(0==cmp) {
+      //we matched...
+      break;
+    }
+    else if(0>cmp){
+      //theNode was greater...
+      result=result->mLeft;
+    }
+    else {
+      //aValue is greater...
+      result=result->mRight;
+    }
+  }
+  if(result) {
+    return result->mValue;
+  }
+  return nsnull;
+}
+
+
+/**
+ * 
+ * @update	gess12/30/98
+ * @param 
+ * @return
+ */
+eAVLStatus 
+nsAVLTree::RemoveItem(void* aValue){
+  PRBool delOk=PR_TRUE;
+  eAVLStatus result=avlRemove(mRoot,aValue,delOk,mComparitor);
+  if(eAVL_ok==result)
+    mCount--;
+  return result;
+} 
+
+/**
+ * 
+ * @update	gess9/11/98
+ * @param 
+ * @return
+ */
+static void 
+avlForEachDepthFirst(nsAVLNode* aNode, nsAVLNodeFunctor& aFunctor){
+  if(aNode) {
+    avlForEachDepthFirst(aNode->mLeft,aFunctor);
+    avlForEachDepthFirst(aNode->mRight,aFunctor);
+    aFunctor(aNode->mValue);
+  }
+}
+
+
+/**
+ * 
+ * @update	gess9/11/98
+ * @param 
+ * @return
+ */
+void 
+nsAVLTree::ForEachDepthFirst(nsAVLNodeFunctor& aFunctor) const{
+  ::avlForEachDepthFirst(mRoot,aFunctor);
+}
+
+/**
+ * 
+ * @update	gess9/11/98
+ * @param 
+ * @return
+ */
+static void 
+avlForEach(nsAVLNode* aNode, nsAVLNodeFunctor& aFunctor) {
+  if(aNode) {
+    avlForEach(aNode->mLeft,aFunctor);
+    aFunctor(aNode->mValue);
+    avlForEach(aNode->mRight,aFunctor);
+  }
+}
+
+
+/**
+ * 
+ * @update	gess9/11/98
+ * @param 
+ * @return
+ */
+void 
+nsAVLTree::ForEach(nsAVLNodeFunctor& aFunctor) const{
+  ::avlForEach(mRoot,aFunctor);
+}
+
+
+/**
+ * 
+ * @update	gess9/11/98
+ * @param 
+ * @return
+ */
+static void* 
+avlFirstThat(nsAVLNode* aNode, nsAVLNodeFunctor& aFunctor) {
+  void* result=nsnull;
+  if(aNode) {
+    result = avlFirstThat(aNode->mLeft,aFunctor);
+    if (result) {
+      return result;
+    }
+    result = aFunctor(aNode->mValue);
+    if (result) {
+      return result;
+    }
+    result = avlFirstThat(aNode->mRight,aFunctor);
+  }
+  return result;
+}
+
+/**
+ * 
+ * @update	gess9/11/98
+ * @param 
+ * @return
+ */
+void* 
+nsAVLTree::FirstThat(nsAVLNodeFunctor& aFunctor) const{
+  return ::avlFirstThat(mRoot,aFunctor);
+}
+

mozilla/htmlparser/src/nsAVLTree.h

@@ -0,0 +1,78 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+#ifndef nsAVLTree_h___
+#define nsAVLTree_h___
+
+
+#include "nscore.h"
+
+
+enum eAVLStatus {eAVL_unknown,eAVL_ok,eAVL_fail,eAVL_duplicate};
+
+
+struct nsAVLNode;
+
+/**
+ * 
+ * @update	gess12/26/98
+ * @param anObject1 is the first object to be compared
+ * @param anObject2 is the second object to be compared
+ * @return -1,0,1 if object1 is less, equal, greater than object2
+ */
+class NS_COM nsAVLNodeComparitor {
+public:
+  virtual PRInt32 operator()(void* anItem1,void* anItem2)=0;
+}; 
+
+class NS_COM nsAVLNodeFunctor {
+public:
+  virtual void* operator()(void* anItem)=0;
+};
+
+class NS_COM nsAVLTree {
+public:
+              nsAVLTree(nsAVLNodeComparitor& aComparitor, nsAVLNodeFunctor* aDeallocator);
+              ~nsAVLTree(void);
+
+  PRBool      operator==(const nsAVLTree& aOther) const;
+  PRInt32     GetCount(void) const {return mCount;}
+
+              //main functions...
+  eAVLStatus  AddItem(void* anItem);
+  eAVLStatus  RemoveItem(void* anItem);
+  void*       FindItem(void* anItem) const;
+  void        ForEach(nsAVLNodeFunctor& aFunctor) const;
+  void        ForEachDepthFirst(nsAVLNodeFunctor& aFunctor) const;
+  void*       FirstThat(nsAVLNodeFunctor& aFunctor) const;
+
+protected: 
+
+  nsAVLNode*  mRoot;
+  PRInt32     mCount;
+  nsAVLNodeComparitor&  mComparitor;
+  nsAVLNodeFunctor*     mDeallocator;
+};
+
+
+#endif /* nsAVLTree_h___ */
+

mozilla/modules/libreg/xpcom/nsIRegistry.idl

@@ -0,0 +1,124 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * The contents of this file are subject to the Mozilla Public License
+ * Version 1.1 (the "MPL"); you may not use this file except in
+ * compliance with the MPL.  You may obtain a copy of the MPL at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the MPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the MPL
+ * for the specific language governing rights and limitations under the
+ * MPL.
+ *
+ * The Initial Developer of this code under the MPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+#include "nsISupports.idl"
+#include "nsIEnumerator.idl"
+
+typedef PRUint32 nsRegistryKey;
+typedef long     nsWellKnownRegistry;
+
+[scriptable,uuid(5D41A440-8E37-11d2-8059-00600811A9C3)]
+interface nsIRegistry : nsISupports
+{
+    const long None = 0;
+    const long Users = 1;
+    const long Common = 2;
+    const long CurrentUser = 3;
+
+    const long ApplicationComponentRegistry = 1;
+    const long ApplicationRegistry = 2;
+
+    // Dont use this one. This for internal use only.
+    const long ApplicationCustomRegistry = -1;
+
+    void open(in string regFile);
+    void openWellKnownRegistry(in nsWellKnownRegistry regid);
+
+    void flush();
+    boolean isOpen();
+    
+    nsRegistryKey addKey(in nsRegistryKey baseKey, in wstring keyname);
+    nsRegistryKey getKey(in nsRegistryKey baseKey, in wstring keyname);
+    void removeKey(in nsRegistryKey baseKey, in wstring keyname);
+
+    wstring getString(in nsRegistryKey baseKey, in wstring valname);
+    void setString(in nsRegistryKey baseKey, in wstring valname, in wstring value);
+
+    string getStringUTF8(in nsRegistryKey baseKey, in string path);
+    void setStringUTF8(in nsRegistryKey baseKey, in string path, in string value);
+
+    void getBytesUTF8(in nsRegistryKey baseKey, in string path, out PRUint32 length, [retval, array, size_is(length)] out PRUint8 valueArray);
+    void setBytesUTF8(in nsRegistryKey baseKey, in string path, in PRUint32 length, [array, size_is(length)] in PRUint8 valueArray);
+    PRInt32 getInt(in nsRegistryKey baseKey, in string path);
+    void setInt(in nsRegistryKey baseKey, in string path, in PRInt32 value);
+    PRInt64 getLongLong(in nsRegistryKey baseKey, in string path);
+    void setLongLong(in nsRegistryKey baseKey, in string path, inout PRInt64 value);
+
+    /**
+     * addSubtree() and friends need to be renamed to addKeyUTF8().
+     * If you are using these forms make sure you pass UTF8 data
+     */
+    nsRegistryKey addSubtree(in nsRegistryKey baseKey, in string path);
+    void removeSubtree(in nsRegistryKey baseKey, in string path);
+    nsRegistryKey getSubtree(in nsRegistryKey baseKey, in string path);
+
+    nsRegistryKey addSubtreeRaw(in nsRegistryKey baseKey, in string path);
+    void removeSubtreeRaw(in nsRegistryKey baseKey, in string path);
+    nsRegistryKey getSubtreeRaw(in nsRegistryKey baseKey, in string path);
+
+    nsIEnumerator enumerateSubtrees(in nsRegistryKey baseKey);
+    nsIEnumerator enumerateAllSubtrees(in nsRegistryKey baseKey);
+    nsIEnumerator enumerateValues(in nsRegistryKey baseKey);
+    
+    const unsigned long String = 1;
+    const unsigned long Int32 = 2;
+    const unsigned long Bytes = 3;
+    const unsigned long File = 4;
+    
+    unsigned long getValueType(in nsRegistryKey baseKey, in string path);
+    PRUint32 getValueLength(in nsRegistryKey baseKey, in string path);
+    void deleteValue(in nsRegistryKey baseKey, in string path);
+
+    /**
+     * escapeKey() takes arbitrary binary data and converts it into
+     * valid ASCII which can be used as registry key or value names
+     */
+    void escapeKey([array, size_is(length)] in PRUint8 key, in PRUint32 terminator, inout PRUint32 length, [retval, array, size_is(length)] out PRUint8 escaped); 
+    void unescapeKey([array, size_is(length)] in PRUint8 escaped, in PRUint32 terminator, inout PRUint32 length, [retval, array, size_is(length)] out PRUint8 key); 
+
+    attribute string currentUserName;
+
+    void pack();
+};
+
+[scriptable, uuid(8cecf236-1dd2-11b2-893c-f9848956eaec)]
+interface nsIRegistryEnumerator : nsIEnumerator
+{
+    void currentItemInPlaceUTF8(out nsRegistryKey key,
+                                [shared, retval] out string item);
+};
+
+[scriptable, uuid(D1B54831-AC07-11d2-805E-00600811A9C3)]
+interface nsIRegistryNode : nsISupports
+{
+    readonly attribute string nameUTF8;
+    readonly attribute wstring name;
+    readonly attribute nsRegistryKey key;
+};
+
+[scriptable,uuid(5316C380-B2F8-11d2-A374-0080C6F80E4B)]
+interface nsIRegistryValue : nsISupports
+{
+    readonly attribute wstring name;
+    readonly attribute string nameUTF8;
+    readonly attribute unsigned long type;
+    readonly attribute PRUint32 length;
+};
+
+%{ C++
+#include "nsIRegistryUtils.h"
+%}

mozilla/modules/libreg/xpcom/nsIRegistryUtils.h

@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+#ifndef __nsIRegistryUtils_h
+#define __nsIRegistryUtils_h
+
+#define NS_REGISTRY_CONTRACTID "@mozilla.org/registry;1"
+#define NS_REGISTRY_CLASSNAME "Mozilla Registry"
+/* be761f00-a3b0-11d2-996c-0080c7cb1081 */
+#define NS_REGISTRY_CID \
+{ 0xbe761f00, 0xa3b0, 0x11d2, \
+  {0x99, 0x6c, 0x00, 0x80, 0xc7, 0xcb, 0x10, 0x81} }
+
+/*------------------------------- Error Codes ----------------------------------
+------------------------------------------------------------------------------*/
+#define NS_ERROR_REG_BADTYPE          NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 1 )
+#define NS_ERROR_REG_NO_MORE          NS_ERROR_GENERATE_SUCCESS( NS_ERROR_MODULE_REG, 2 )
+#define NS_ERROR_REG_NOT_FOUND        NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 3 )
+#define NS_ERROR_REG_NOFILE	          NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 4 )
+#define NS_ERROR_REG_BUFFER_TOO_SMALL NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 5 )
+#define NS_ERROR_REG_NAME_TOO_LONG    NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 6 )
+#define NS_ERROR_REG_NO_PATH          NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 7 )
+#define NS_ERROR_REG_READ_ONLY        NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 8 )
+#define NS_ERROR_REG_BAD_UTF8         NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_REG, 9 )
+
+#endif

mozilla/modules/libreg/xpcom/nsRegistry.h

@@ -0,0 +1,55 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *	Edward Kandrot  <kandrot@netscape.com>
+ */
+
+
+#ifndef nsRegistry_h__
+#define nsRegistry_h__
+
+#include "nsIRegistry.h"
+#include "NSReg.h"
+
+struct nsRegistry : public nsIRegistry {
+    // This class implements the nsISupports interface functions.
+    NS_DECL_ISUPPORTS
+
+    // This class implements the nsIRegistry interface functions.
+    NS_DECL_NSIREGISTRY
+
+    // ctor/dtor
+    nsRegistry();
+    virtual ~nsRegistry();
+
+    int SetBufferSize( int bufsize );  // changes the file buffer size for this registry
+
+protected:
+    HREG   mReg; // Registry handle.
+#ifdef EXTRA_THREADSAFE
+    PRLock *mregLock;    // libreg isn't threadsafe. Use locks to synchronize.
+#endif
+    char *mCurRegFile;    // these are to prevent open from opening the registry again
+    nsWellKnownRegistry mCurRegID;
+
+    NS_IMETHOD Close();
+}; // nsRegistry
+
+#endif

mozilla/parser/htmlparser/src/nsAVLTree.cpp

@@ -0,0 +1,621 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+#include "nsAVLTree.h"
+ 
+
+enum eLean      {eLeft,eNeutral,eRight};
+
+struct NS_COM nsAVLNode {
+public:
+
+  nsAVLNode(void* aValue) {
+    mLeft=0;
+    mRight=0;
+    mSkew=eNeutral;
+    mValue=aValue;
+  }
+
+  nsAVLNode*  mLeft;
+  nsAVLNode*  mRight;
+  eLean       mSkew;
+  void*       mValue;
+};
+
+
+/************************************************************
+  Now begin the tree class. Don't forget that the comparison
+  between nodes must occur via the comparitor function, 
+  otherwise all you're testing is pointer addresses.
+ ************************************************************/
+
+/** ------------------------------------------------
+ * 
+ * 
+ * @update gess 4/22/98
+ * @param  
+ * @return 
+ */ //----------------------------------------------
+nsAVLTree::nsAVLTree(nsAVLNodeComparitor& aComparitor, 
+                     nsAVLNodeFunctor* aDeallocator) :
+  mComparitor(aComparitor), mDeallocator(aDeallocator) {
+  mRoot=0;
+  mCount=0;
+}
+
+
+static void 
+avlDeleteTree(nsAVLNode* aNode){
+  if (aNode) {
+    avlDeleteTree(aNode->mLeft);
+    avlDeleteTree(aNode->mRight);
+    delete aNode;
+  }
+}
+
+/**
+ * 
+ * @update	gess12/27/98
+ * @param 
+ * @return
+ */
+nsAVLTree::~nsAVLTree(){
+  if (mDeallocator) {
+    ForEachDepthFirst(*mDeallocator);
+  }
+  avlDeleteTree(mRoot);
+}
+
+
+class CDoesntExist: public nsAVLNodeFunctor {
+public:
+  CDoesntExist(const nsAVLTree& anotherTree) : mOtherTree(anotherTree) {
+  }
+  virtual void* operator()(void* anItem) {
+    void* result=mOtherTree.FindItem(anItem);
+    if(result)
+      return nsnull;
+    return anItem;
+  }
+protected:
+  const nsAVLTree& mOtherTree;
+};
+
+/**
+ * This method compares two trees (members by identity).
+ * @update	gess12/27/98
+ * @param   tree to compare against
+ * @return  true if they are identical (contain same stuff).
+ */
+PRBool nsAVLTree::operator==(const nsAVLTree& aCopy) const{
+  CDoesntExist functor(aCopy);
+  void* theItem=FirstThat(functor);
+  PRBool result=PRBool(!theItem);
+  return result;
+}
+
+
+/**
+ * 
+ * @update	gess12/27/98
+ * @param 
+ * @return
+ */
+static void 
+avlRotateRight(nsAVLNode*& aRootNode){
+  nsAVLNode* ptr2;
+  nsAVLNode* ptr3;
+
+  ptr2=aRootNode->mRight;
+  if(ptr2->mSkew==eRight) {
+    aRootNode->mRight=ptr2->mLeft;
+    ptr2->mLeft=aRootNode;
+    aRootNode->mSkew=eNeutral;
+    aRootNode=ptr2;
+  }
+  else {
+    ptr3=ptr2->mLeft;
+    ptr2->mLeft=ptr3->mRight;
+    ptr3->mRight=ptr2;
+    aRootNode->mRight=ptr3->mLeft;
+    ptr3->mLeft=aRootNode;
+    if(ptr3->mSkew==eLeft)
+      ptr2->mSkew=eRight;
+    else ptr2->mSkew=eNeutral;
+    if(ptr3->mSkew==eRight)
+      aRootNode->mSkew=eLeft;
+    else aRootNode->mSkew=eNeutral;
+    aRootNode=ptr3;
+  }
+  aRootNode->mSkew=eNeutral;
+  return;
+}
+
+
+
+/**
+ * 
+ * @update	gess12/27/98
+ * @param 
+ * @return
+ */
+static void 
+avlRotateLeft(nsAVLNode*& aRootNode){
+  nsAVLNode* ptr2;
+  nsAVLNode* ptr3;
+
+  ptr2=aRootNode->mLeft;
+  if(ptr2->mSkew==eLeft) {
+    aRootNode->mLeft=ptr2->mRight;
+    ptr2->mRight=aRootNode;
+    aRootNode->mSkew=eNeutral;
+    aRootNode=ptr2;
+  }
+  else {
+    ptr3=ptr2->mRight;
+    ptr2->mRight=ptr3->mLeft;
+    ptr3->mLeft=ptr2;
+    aRootNode->mLeft=ptr3->mRight;
+    ptr3->mRight=aRootNode;
+    if(ptr3->mSkew==eRight)
+      ptr2->mSkew=eLeft;
+    else ptr2->mSkew=eNeutral;
+    if(ptr3->mSkew==eLeft)
+      aRootNode->mSkew=eRight;
+    else aRootNode->mSkew=eNeutral;
+    aRootNode=ptr3;
+  }
+  aRootNode->mSkew=eNeutral;
+  return;
+}
+
+
+/** ------------------------------------------------
+ * 
+ * 
+ * @update gess 4/22/98
+ * @param  
+ * @return 
+ */ //----------------------------------------------
+static eAVLStatus 
+avlInsert(nsAVLNode*& aRootNode, nsAVLNode* aNewNode, 
+          nsAVLNodeComparitor& aComparitor) {
+  eAVLStatus result=eAVL_unknown;
+  
+  if(!aRootNode) {
+    aRootNode = aNewNode;
+    return eAVL_ok;
+  }
+  
+  if(aNewNode==aRootNode->mValue) {
+    return eAVL_duplicate;
+  }
+
+  PRInt32 theCompareResult=aComparitor(aRootNode->mValue,aNewNode->mValue);
+  if(0 < theCompareResult) { //if(anItem<aRootNode->mValue)
+    result=avlInsert(aRootNode->mLeft,aNewNode,aComparitor);
+    if(eAVL_ok==result) {
+      switch(aRootNode->mSkew){
+        case eLeft:
+          avlRotateLeft(aRootNode);
+          result=eAVL_fail;
+          break;
+        case eRight:
+          aRootNode->mSkew=eNeutral;
+          result=eAVL_fail;
+          break;
+        case eNeutral:
+          aRootNode->mSkew=eLeft;
+          break;
+      } //switch
+    }//if
+  } //if
+  else { 
+    result=avlInsert(aRootNode->mRight,aNewNode,aComparitor);
+    if(eAVL_ok==result) {
+      switch(aRootNode->mSkew){
+        case eLeft:
+          aRootNode->mSkew=eNeutral;
+          result=eAVL_fail;
+          break;
+        case eRight:
+          avlRotateRight(aRootNode);
+          result=eAVL_fail;
+          break;
+        case eNeutral:
+          aRootNode->mSkew=eRight;
+          break;
+      } //switch
+    }
+  } //if
+  return result;
+}
+
+/** ------------------------------------------------
+ * 
+ * 
+ * @update gess 4/22/98
+ * @param  
+ * @return 
+ */ //----------------------------------------------
+static void 
+avlBalanceLeft(nsAVLNode*& aRootNode, PRBool& delOk){
+  nsAVLNode*  ptr2;
+  nsAVLNode*  ptr3;
+  eLean       balnc2;
+  eLean       balnc3;
+
+  switch(aRootNode->mSkew){
+    case eLeft:
+      ptr2=aRootNode->mLeft;
+      balnc2=ptr2->mSkew;
+      if(balnc2!=eRight) {
+        aRootNode->mLeft=ptr2->mRight;
+        ptr2->mRight=aRootNode;
+        if(balnc2==eNeutral){
+          aRootNode->mSkew=eLeft;
+          ptr2->mSkew=eRight;
+          delOk=PR_FALSE;
+        }
+        else{
+          aRootNode->mSkew=eNeutral;
+          ptr2->mSkew=eNeutral;
+        }
+        aRootNode=ptr2;
+      }
+      else{
+        ptr3=ptr2->mRight;
+        balnc3=ptr3->mSkew;
+        ptr2->mRight=ptr3->mLeft;
+        ptr3->mLeft=ptr2;
+        aRootNode->mLeft=ptr3->mRight;
+        ptr3->mRight=aRootNode;
+        if(balnc3==eRight) {
+          ptr2->mSkew=eLeft;
+        }
+        else {
+          ptr2->mSkew=eNeutral;
+        }
+        if(balnc3==eLeft) {
+          aRootNode->mSkew=eRight;
+        }
+        else {
+          aRootNode->mSkew=eNeutral;
+        }
+        aRootNode=ptr3;
+        ptr3->mSkew=eNeutral;
+      }
+      break;
+
+    case eRight:
+      aRootNode->mSkew=eNeutral;
+      break;
+    
+    case eNeutral:
+      aRootNode->mSkew=eLeft;
+      delOk=PR_FALSE;
+      break;
+  }//switch
+  return;
+}
+
+/** ------------------------------------------------
+ * 
+ * 
+ * @update gess 4/22/98
+ * @param  
+ * @return 
+ */ //----------------------------------------------
+static void 
+avlBalanceRight(nsAVLNode*& aRootNode, PRBool& delOk){
+  nsAVLNode*  ptr2;
+  nsAVLNode*  ptr3;
+  eLean       balnc2;
+  eLean       balnc3;
+
+  switch(aRootNode->mSkew){
+    case eLeft:
+      aRootNode->mSkew=eNeutral;
+      break;
+
+    case eRight:
+      ptr2=aRootNode->mRight;
+      balnc2=ptr2->mSkew;
+      if(balnc2!=eLeft) {
+        aRootNode->mRight=ptr2->mLeft;
+        ptr2->mLeft=aRootNode;
+        if(balnc2==eNeutral){
+          aRootNode->mSkew=eRight;
+          ptr2->mSkew=eLeft;
+          delOk=PR_FALSE;
+        }
+        else{
+          aRootNode->mSkew=eNeutral;
+          ptr2->mSkew=eNeutral;
+        }
+        aRootNode=ptr2;
+      }
+      else{
+        ptr3=ptr2->mLeft;
+        balnc3=ptr3->mSkew;
+        ptr2->mLeft=ptr3->mRight;
+        ptr3->mRight=ptr2;
+        aRootNode->mRight=ptr3->mLeft;
+        ptr3->mLeft=aRootNode;
+        if(balnc3==eLeft) {
+          ptr2->mSkew=eRight;
+        }
+        else {
+          ptr2->mSkew=eNeutral;
+        }
+        if(balnc3==eRight) {
+          aRootNode->mSkew=eLeft;
+        }
+        else {
+          aRootNode->mSkew=eNeutral;
+        }
+        aRootNode=ptr3;
+        ptr3->mSkew=eNeutral;
+      }
+      break;
+
+    case eNeutral:
+      aRootNode->mSkew=eRight;
+      delOk=PR_FALSE;
+      break;
+  }//switch
+  return;
+}
+
+/** ------------------------------------------------
+ * 
+ * 
+ * @update gess 4/22/98
+ * @param  
+ * @return 
+ */ //----------------------------------------------
+static eAVLStatus 
+avlRemoveChildren(nsAVLNode*& aRootNode,nsAVLNode*& anotherNode, PRBool& delOk){
+  eAVLStatus result=eAVL_ok;
+  
+  if(!anotherNode->mRight){
+    aRootNode->mValue=anotherNode->mValue; //swap
+    anotherNode=anotherNode->mLeft;
+    delOk=PR_TRUE;
+  }
+  else{
+    avlRemoveChildren(aRootNode,anotherNode->mRight,delOk);
+    if(delOk)
+      avlBalanceLeft(anotherNode,delOk);
+  }
+
+  return result;
+}
+
+
+/** ------------------------------------------------
+ * 
+ * 
+ * @update gess 4/22/98
+ * @param  
+ * @return 
+ */ //----------------------------------------------
+static eAVLStatus 
+avlRemove(nsAVLNode*& aRootNode, void* anItem, PRBool& delOk,
+          nsAVLNodeComparitor& aComparitor){
+  eAVLStatus result=eAVL_ok;
+
+  if(!aRootNode)
+    delOk=PR_FALSE;
+  else {
+    PRInt32 cmp=aComparitor(anItem,aRootNode->mValue);
+    if(cmp<0){
+      avlRemove(aRootNode->mLeft,anItem,delOk,aComparitor);
+      if(delOk)
+        avlBalanceRight(aRootNode,delOk);
+    }
+    else if(cmp>0){
+      avlRemove(aRootNode->mRight,anItem,delOk,aComparitor);
+      if(delOk)
+        avlBalanceLeft(aRootNode,delOk);
+    }
+    else{ //they match...
+      nsAVLNode* temp=aRootNode;
+      if(!aRootNode->mRight) {
+        aRootNode=aRootNode->mLeft;
+        delOk=PR_TRUE;
+        delete temp;
+      }
+      else if(!aRootNode->mLeft) {
+        aRootNode=aRootNode->mRight;
+        delOk=PR_TRUE;
+        delete temp;
+      }
+      else {
+        avlRemoveChildren(aRootNode,aRootNode->mLeft,delOk);
+        if(delOk)
+          avlBalanceRight(aRootNode,delOk);
+      }
+    }
+  }
+
+  return result;
+}
+
+/** ------------------------------------------------
+ * 
+ * 
+ * @update gess 4/22/98
+ * @param  
+ * @return 
+ */ //----------------------------------------------
+eAVLStatus 
+nsAVLTree::AddItem(void* anItem){
+  eAVLStatus result=eAVL_ok;
+
+  nsAVLNode* theNewNode=new nsAVLNode(anItem);
+  result=avlInsert(mRoot,theNewNode,mComparitor);
+  if(eAVL_duplicate!=result)
+    mCount++;
+  else {
+    delete theNewNode;
+  }
+  return result;
+}
+
+/** ------------------------------------------------
+ * 
+ * 
+ * @update gess 4/22/98
+ * @param  
+ * @return 
+ */ //----------------------------------------------
+void* nsAVLTree::FindItem(void* aValue) const{
+  nsAVLNode* result=mRoot;
+  PRInt32 count=0;
+  while(result) {
+    count++;
+    PRInt32 cmp=mComparitor(aValue,result->mValue);
+    if(0==cmp) {
+      //we matched...
+      break;
+    }
+    else if(0>cmp){
+      //theNode was greater...
+      result=result->mLeft;
+    }
+    else {
+      //aValue is greater...
+      result=result->mRight;
+    }
+  }
+  if(result) {
+    return result->mValue;
+  }
+  return nsnull;
+}
+
+
+/**
+ * 
+ * @update	gess12/30/98
+ * @param 
+ * @return
+ */
+eAVLStatus 
+nsAVLTree::RemoveItem(void* aValue){
+  PRBool delOk=PR_TRUE;
+  eAVLStatus result=avlRemove(mRoot,aValue,delOk,mComparitor);
+  if(eAVL_ok==result)
+    mCount--;
+  return result;
+} 
+
+/**
+ * 
+ * @update	gess9/11/98
+ * @param 
+ * @return
+ */
+static void 
+avlForEachDepthFirst(nsAVLNode* aNode, nsAVLNodeFunctor& aFunctor){
+  if(aNode) {
+    avlForEachDepthFirst(aNode->mLeft,aFunctor);
+    avlForEachDepthFirst(aNode->mRight,aFunctor);
+    aFunctor(aNode->mValue);
+  }
+}
+
+
+/**
+ * 
+ * @update	gess9/11/98
+ * @param 
+ * @return
+ */
+void 
+nsAVLTree::ForEachDepthFirst(nsAVLNodeFunctor& aFunctor) const{
+  ::avlForEachDepthFirst(mRoot,aFunctor);
+}
+
+/**
+ * 
+ * @update	gess9/11/98
+ * @param 
+ * @return
+ */
+static void 
+avlForEach(nsAVLNode* aNode, nsAVLNodeFunctor& aFunctor) {
+  if(aNode) {
+    avlForEach(aNode->mLeft,aFunctor);
+    aFunctor(aNode->mValue);
+    avlForEach(aNode->mRight,aFunctor);
+  }
+}
+
+
+/**
+ * 
+ * @update	gess9/11/98
+ * @param 
+ * @return
+ */
+void 
+nsAVLTree::ForEach(nsAVLNodeFunctor& aFunctor) const{
+  ::avlForEach(mRoot,aFunctor);
+}
+
+
+/**
+ * 
+ * @update	gess9/11/98
+ * @param 
+ * @return
+ */
+static void* 
+avlFirstThat(nsAVLNode* aNode, nsAVLNodeFunctor& aFunctor) {
+  void* result=nsnull;
+  if(aNode) {
+    result = avlFirstThat(aNode->mLeft,aFunctor);
+    if (result) {
+      return result;
+    }
+    result = aFunctor(aNode->mValue);
+    if (result) {
+      return result;
+    }
+    result = avlFirstThat(aNode->mRight,aFunctor);
+  }
+  return result;
+}
+
+/**
+ * 
+ * @update	gess9/11/98
+ * @param 
+ * @return
+ */
+void* 
+nsAVLTree::FirstThat(nsAVLNodeFunctor& aFunctor) const{
+  return ::avlFirstThat(mRoot,aFunctor);
+}
+

mozilla/parser/htmlparser/src/nsAVLTree.h

@@ -0,0 +1,78 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+#ifndef nsAVLTree_h___
+#define nsAVLTree_h___
+
+
+#include "nscore.h"
+
+
+enum eAVLStatus {eAVL_unknown,eAVL_ok,eAVL_fail,eAVL_duplicate};
+
+
+struct nsAVLNode;
+
+/**
+ * 
+ * @update	gess12/26/98
+ * @param anObject1 is the first object to be compared
+ * @param anObject2 is the second object to be compared
+ * @return -1,0,1 if object1 is less, equal, greater than object2
+ */
+class NS_COM nsAVLNodeComparitor {
+public:
+  virtual PRInt32 operator()(void* anItem1,void* anItem2)=0;
+}; 
+
+class NS_COM nsAVLNodeFunctor {
+public:
+  virtual void* operator()(void* anItem)=0;
+};
+
+class NS_COM nsAVLTree {
+public:
+              nsAVLTree(nsAVLNodeComparitor& aComparitor, nsAVLNodeFunctor* aDeallocator);
+              ~nsAVLTree(void);
+
+  PRBool      operator==(const nsAVLTree& aOther) const;
+  PRInt32     GetCount(void) const {return mCount;}
+
+              //main functions...
+  eAVLStatus  AddItem(void* anItem);
+  eAVLStatus  RemoveItem(void* anItem);
+  void*       FindItem(void* anItem) const;
+  void        ForEach(nsAVLNodeFunctor& aFunctor) const;
+  void        ForEachDepthFirst(nsAVLNodeFunctor& aFunctor) const;
+  void*       FirstThat(nsAVLNodeFunctor& aFunctor) const;
+
+protected: 
+
+  nsAVLNode*  mRoot;
+  PRInt32     mCount;
+  nsAVLNodeComparitor&  mComparitor;
+  nsAVLNodeFunctor*     mDeallocator;
+};
+
+
+#endif /* nsAVLTree_h___ */
+

mozilla/string/obsolete/nsStr.cpp

@@ -0,0 +1,923 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Original Author:
+ *   Rick Gessner <rickg@netscape.com>
+ *
+ * Contributor(s): 
+ *   Scott Collins <scc@mozilla.org>
+ */
+  
+/******************************************************************************************
+  MODULE NOTES:
+
+  This file contains the nsStr data structure.
+  This general purpose buffer management class is used as the basis for our strings.
+  It's benefits include:
+    1. An efficient set of library style functions for manipulating nsStrs
+    2. Support for 1 and 2 byte character strings (which can easily be increased to n)
+    3. Unicode awareness and interoperability.
+
+*******************************************************************************************/
+
+#include "nsStr.h"
+#include "bufferRoutines.h"
+#include <stdio.h>  //only used for printf
+#include "nsCRT.h"
+#include "nsDeque.h"
+ 
+//static const char* kCallFindChar =  "For better performance, call FindChar() for targets whose length==1.";
+//static const char* kCallRFindChar = "For better performance, call RFindChar() for targets whose length==1.";
+
+static const  PRUnichar gCommonEmptyBuffer[1] = {0};
+static PRBool gStringAcquiredMemory = PR_TRUE;
+
+/**
+ * This method initializes all the members of the nsStr structure 
+ *
+ * @update	gess10/30/98
+ * @param 
+ * @return
+ */
+void nsStr::Initialize(nsStr& aDest,eCharSize aCharSize) {
+  aDest.mStr=(char*)gCommonEmptyBuffer;
+  aDest.mLength=0;
+  aDest.mCapacity=0;
+  aDest.mCharSize=aCharSize;
+  aDest.mOwnsBuffer=0;
+}
+
+/**
+ * This method initializes all the members of the nsStr structure
+ * @update	gess10/30/98
+ * @param 
+ * @return
+ */
+void nsStr::Initialize(nsStr& aDest,char* aCString,PRUint32 aCapacity,PRUint32 aLength,eCharSize aCharSize,PRBool aOwnsBuffer){
+  aDest.mStr=(aCString) ? aCString : (char*)gCommonEmptyBuffer;
+  aDest.mLength=aLength;
+  aDest.mCapacity=aCapacity;
+  aDest.mCharSize=aCharSize;
+  aDest.mOwnsBuffer=aOwnsBuffer;
+}
+
+
+/**
+ * This member destroys the memory buffer owned by an nsStr object (if it actually owns it)
+ * @update	gess10/30/98
+ * @param 
+ * @return
+ */
+void nsStr::Destroy(nsStr& aDest) {
+  if((aDest.mStr) && (aDest.mStr!=(char*)gCommonEmptyBuffer)) {
+    Free(aDest);
+  }
+}
+
+
+/**
+ * This method gets called when the internal buffer needs
+ * to grow to a given size. The original contents are not preserved.
+ * @update  gess 3/30/98
+ * @param   aNewLength -- new capacity of string in charSize units
+ * @return  void
+ */
+PRBool nsStr::EnsureCapacity(nsStr& aString,PRUint32 aNewLength) {
+  PRBool result=PR_TRUE;
+  if(aNewLength>aString.mCapacity) {
+    result=Realloc(aString,aNewLength);
+    if(aString.mStr)
+      AddNullTerminator(aString);
+  }
+  return result;
+}
+
+/**
+ * This method gets called when the internal buffer needs
+ * to grow to a given size. The original contents ARE preserved.
+ * @update  gess 3/30/98
+ * @param   aNewLength -- new capacity of string in charSize units
+ * @return  void
+ */
+PRBool nsStr::GrowCapacity(nsStr& aDest,PRUint32 aNewLength) {
+  PRBool result=PR_TRUE;
+  if(aNewLength>aDest.mCapacity) {
+    nsStr theTempStr;
+    nsStr::Initialize(theTempStr,aDest.mCharSize);
+
+#ifndef NS_USE_OLD_STRING_ALLOCATION_STRATEGY
+      // the new strategy is, allocate exact size, double on grows
+    if ( aDest.mCapacity ) {
+      PRUint32 newCapacity = aDest.mCapacity;
+      while ( newCapacity < aNewLength )
+        newCapacity <<= 1;
+      aNewLength = newCapacity;
+    }
+#endif
+
+    result=EnsureCapacity(theTempStr,aNewLength);
+    if(result) {
+      if(aDest.mLength) {
+        StrAppend(theTempStr,aDest,0,aDest.mLength);        
+      } 
+      Free(aDest);
+      aDest.mStr = theTempStr.mStr;
+      theTempStr.mStr=0; //make sure to null this out so that you don't lose the buffer you just stole...
+      aDest.mLength=theTempStr.mLength;
+      aDest.mCapacity=theTempStr.mCapacity;
+      aDest.mOwnsBuffer=theTempStr.mOwnsBuffer;
+    }
+  }
+  return result;
+}
+
+/**
+ * Replaces the contents of aDest with aSource, up to aCount of chars.
+ * @update	gess10/30/98
+ * @param   aDest is the nsStr that gets changed.
+ * @param   aSource is where chars are copied from
+ * @param   aCount is the number of chars copied from aSource
+ */
+void nsStr::StrAssign(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount){
+  if(&aDest!=&aSource){
+    Truncate(aDest,0);
+    StrAppend(aDest,aSource,anOffset,aCount);
+  }
+}
+
+/**
+ * This method appends the given nsStr to this one. Note that we have to 
+ * pay attention to the underlying char-size of both structs.
+ * @update	gess10/30/98
+ * @param   aDest is the nsStr to be manipulated
+ * @param   aSource is where char are copied from
+ * @aCount  is the number of bytes to be copied 
+ */
+void nsStr::StrAppend(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount){
+  if(anOffset<aSource.mLength){
+    PRUint32 theRealLen=(aCount<0) ? aSource.mLength : MinInt(aCount,aSource.mLength);
+    PRUint32 theLength=(anOffset+theRealLen<aSource.mLength) ? theRealLen : (aSource.mLength-anOffset);
+    if(0<theLength){
+      
+      PRBool isBigEnough=PR_TRUE;
+      if(aDest.mLength+theLength > aDest.mCapacity) {
+        isBigEnough=GrowCapacity(aDest,aDest.mLength+theLength);
+      }
+
+      if(isBigEnough) {
+        //now append new chars, starting at offset
+        (*gCopyChars[aSource.mCharSize][aDest.mCharSize])(aDest.mStr,aDest.mLength,aSource.mStr,anOffset,theLength);
+
+        aDest.mLength+=theLength;
+        AddNullTerminator(aDest);
+        NSSTR_SEEN(aDest);
+      }
+    }
+  }
+}
+
+
+/**
+ * This method inserts up to "aCount" chars from a source nsStr into a dest nsStr.
+ * @update	gess10/30/98
+ * @param   aDest is the nsStr that gets changed
+ * @param   aDestOffset is where in aDest the insertion is to occur
+ * @param   aSource is where chars are copied from
+ * @param   aSrcOffset is where in aSource chars are copied from
+ * @param   aCount is the number of chars from aSource to be inserted into aDest
+ */
+void nsStr::StrInsert( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount){
+  //there are a few cases for insert:
+  //  1. You're inserting chars into an empty string (assign)
+  //  2. You're inserting onto the end of a string (append)
+  //  3. You're inserting onto the 1..n-1 pos of a string (the hard case).
+  if(0<aSource.mLength){
+    if(aDest.mLength){
+      if(aDestOffset<aDest.mLength){
+        PRInt32 theRealLen=(aCount<0) ? aSource.mLength : MinInt(aCount,aSource.mLength);
+        PRInt32 theLength=(aSrcOffset+theRealLen<aSource.mLength) ? theRealLen : (aSource.mLength-aSrcOffset);
+
+        if(aSrcOffset<aSource.mLength) {
+            //here's the only new case we have to handle. 
+            //chars are really being inserted into our buffer...
+
+          if(aDest.mLength+theLength > aDest.mCapacity) {
+            nsStr theTempStr;
+            nsStr::Initialize(theTempStr,aDest.mCharSize);
+
+            PRBool isBigEnough=EnsureCapacity(theTempStr,aDest.mLength+theLength);  //grow the temp buffer to the right size
+
+            if(isBigEnough) {
+              if(aDestOffset) {
+                StrAppend(theTempStr,aDest,0,aDestOffset); //first copy leftmost data...
+              } 
+              
+              StrAppend(theTempStr,aSource,0,aSource.mLength); //next copy inserted (new) data
+            
+              PRUint32 theRemains=aDest.mLength-aDestOffset;
+              if(theRemains) {
+                StrAppend(theTempStr,aDest,aDestOffset,theRemains); //next copy rightmost data
+              }
+
+              Free(aDest);
+              aDest.mStr = theTempStr.mStr;
+              theTempStr.mStr=0; //make sure to null this out so that you don't lose the buffer you just stole...
+              aDest.mCapacity=theTempStr.mCapacity;
+              aDest.mOwnsBuffer=theTempStr.mOwnsBuffer;
+            }
+
+          }
+
+          else {
+              //shift the chars right by theDelta...
+            (*gShiftChars[aDest.mCharSize][KSHIFTRIGHT])(aDest.mStr,aDest.mLength,aDestOffset,theLength);
+      
+            //now insert new chars, starting at offset
+            (*gCopyChars[aSource.mCharSize][aDest.mCharSize])(aDest.mStr,aDestOffset,aSource.mStr,aSrcOffset,theLength);
+          }
+
+            //finally, make sure to update the string length...
+          aDest.mLength+=theLength;
+          AddNullTerminator(aDest);
+          NSSTR_SEEN(aDest);
+        }//if
+        //else nothing to do!
+      }
+      else StrAppend(aDest,aSource,0,aCount);
+    }
+    else StrAppend(aDest,aSource,0,aCount);
+  }
+}
+
+
+/**
+ * This method deletes up to aCount chars from aDest
+ * @update	gess10/30/98
+ * @param   aDest is the nsStr to be manipulated
+ * @param   aDestOffset is where in aDest deletion is to occur
+ * @param   aCount is the number of chars to be deleted in aDest
+ */
+void nsStr::Delete(nsStr& aDest,PRUint32 aDestOffset,PRUint32 aCount){
+  if(aDestOffset<aDest.mLength){
+
+    PRUint32 theDelta=aDest.mLength-aDestOffset;
+    PRUint32 theLength=(theDelta<aCount) ? theDelta : aCount;
+
+    if(aDestOffset+theLength<aDest.mLength) {
+
+      //if you're here, it means we're cutting chars out of the middle of the string...
+      //so shift the chars left by theLength...
+      (*gShiftChars[aDest.mCharSize][KSHIFTLEFT])(aDest.mStr,aDest.mLength,aDestOffset,theLength);
+      aDest.mLength-=theLength;
+      AddNullTerminator(aDest);
+      NSSTR_SEEN(aDest);
+    }
+    else Truncate(aDest,aDestOffset);
+  }//if
+}
+
+/**
+ * This method truncates the given nsStr at given offset
+ * @update	gess10/30/98
+ * @param   aDest is the nsStr to be truncated
+ * @param   aDestOffset is where in aDest truncation is to occur
+ */
+void nsStr::Truncate(nsStr& aDest,PRUint32 aDestOffset){
+  if(aDest.mCapacity && aDestOffset<=aDest.mCapacity){
+    aDest.mLength=aDestOffset;
+    AddNullTerminator(aDest);
+    NSSTR_SEEN(aDest);
+  }
+}
+
+
+/**
+ * This method forces the given string to upper or lowercase
+ * @update	gess1/7/99
+ * @param   aDest is the string you're going to change
+ * @param   aToUpper: if TRUE, then we go uppercase, otherwise we go lowercase
+ * @return
+ */
+void nsStr::ChangeCase(nsStr& aDest,PRBool aToUpper) {
+  // somehow UnicharUtil return failed, fallback to the old ascii only code
+  gCaseConverters[aDest.mCharSize](aDest.mStr,aDest.mLength,aToUpper);
+}
+
+/**
+ * This method removes characters from the given set from this string.
+ * NOTE: aSet is a char*, and it's length is computed using strlen, which assumes null termination.
+ *
+ * @update	gess 11/7/99
+ * @param aDest
+ * @param aSet
+ * @param aEliminateLeading
+ * @param aEliminateTrailing
+ * @return nothing
+ */
+void nsStr::Trim(nsStr& aDest,const char* aSet,PRBool aEliminateLeading,PRBool aEliminateTrailing){
+
+  if((aDest.mLength>0) && aSet){
+    PRInt32 theIndex=-1;
+    PRInt32 theMax=aDest.mLength;
+    PRInt32 theSetLen=nsCRT::strlen(aSet);
+
+    if(aEliminateLeading) {
+      while(++theIndex<=theMax) {
+        PRUnichar theChar=GetCharAt(aDest,theIndex);
+        PRInt32 thePos=gFindChars[eOneByte](aSet,theSetLen,0,theChar,PR_FALSE,theSetLen);
+        if(kNotFound==thePos)
+          break;
+      }
+      if(0<theIndex) {
+        if(theIndex<theMax) {
+          Delete(aDest,0,theIndex);
+        }
+        else Truncate(aDest,0);
+      }
+    }
+
+    if(aEliminateTrailing) {
+      theIndex=aDest.mLength;
+      PRInt32 theNewLen=theIndex;
+      while(--theIndex>=0) {
+        PRUnichar theChar=GetCharAt(aDest,theIndex);  //read at end now...
+        PRInt32 thePos=gFindChars[eOneByte](aSet,theSetLen,0,theChar,PR_FALSE,theSetLen);
+        if(kNotFound<thePos) 
+          theNewLen=theIndex;
+        else break;
+      }
+      if(theNewLen<theMax) {
+        Truncate(aDest,theNewLen);
+      }
+    }
+
+  }
+}
+
+/**
+ * 
+ * @update	gess1/7/99
+ * @param 
+ * @return
+ */
+void nsStr::CompressSet(nsStr& aDest,const char* aSet,PRBool aEliminateLeading,PRBool aEliminateTrailing){
+  Trim(aDest,aSet,aEliminateLeading,aEliminateTrailing);
+  PRUint32 aNewLen=gCompressChars[aDest.mCharSize](aDest.mStr,aDest.mLength,aSet);
+  aDest.mLength=aNewLen;
+  NSSTR_SEEN(aDest);
+}
+
+
+/**
+ * 
+ * @update	gess1/7/99
+ * @param 
+ * @return
+ */
+void nsStr::StripChars(nsStr& aDest,const char* aSet){
+  if((0<aDest.mLength) && (aSet)) {
+    PRUint32 aNewLen=gStripChars[aDest.mCharSize](aDest.mStr,aDest.mLength,aSet);
+    aDest.mLength=aNewLen;
+    NSSTR_SEEN(aDest);
+  }
+}
+
+
+  /**************************************************************
+    Searching methods...
+   **************************************************************/
+
+
+/**
+ *  This searches aDest for a given substring
+ *  
+ *  @update  gess 2/04/00: added aCount argument to restrict search
+ *  @param   aDest string to search
+ *  @param   aTarget is the substring you're trying to find.
+ *  @param   aIgnorecase indicates case sensitivity of search
+ *  @param   anOffset tells us where to start the search
+ *  @param   aCount tells us how many iterations to make from offset; -1 means the full length of the string
+ *  @return  index in aDest where member of aSet occurs, or -1 if not found
+ */
+PRInt32 nsStr::FindSubstr(const nsStr& aDest,const nsStr& aTarget, PRBool aIgnoreCase,PRInt32 anOffset,PRInt32 aCount) {
+  PRInt32 theMaxPos = aDest.mLength-aTarget.mLength;  //this is the last pos that is feasible for starting the search, with given lengths...
+
+  if(0<=theMaxPos) {
+
+    if(anOffset<0)
+      anOffset=0;
+
+    if((0<aDest.mLength) && (anOffset<=theMaxPos) && (aTarget.mLength)) {
+
+      if(aCount<0)
+        aCount = MaxInt(theMaxPos,1);
+      
+      if(0<aCount) {
+
+        PRInt32     aDelta= (aDest.mCharSize == eOneByte) ? 1 : 2;
+        const char* root  = aDest.mStr; 
+        const char* left  = root+(anOffset*aDelta);
+        const char* last  = left+((aCount)*aDelta);
+        const char* max   = root+(theMaxPos*aDelta);
+        const char* right = (last<max) ? last : max;
+
+        while(left<=right){
+          PRInt32 cmp=(*gCompare[aDest.mCharSize][aTarget.mCharSize])(left,aTarget.mStr,aTarget.mLength,aIgnoreCase);
+          if(0==cmp) {
+            return (left-root)/aDelta;
+          }
+          left+=aDelta;
+        } //while
+
+      } //if 
+    }
+  } //if
+
+  return kNotFound;
+}
+
+
+/**
+ *  This searches aDest for a given character 
+ *  
+ *  @update  gess 2/04/00: added aCount argument to restrict search
+ *  @param   aDest string to search
+ *  @param   char is the character you're trying to find.
+ *  @param   aIgnorecase indicates case sensitivity of search
+ *  @param   anOffset tells us where to start the search
+ *  @param   aCount tell us how many chars to search from offset
+ *  @return  index in aDest where member of aSet occurs, or -1 if not found
+ */
+PRInt32 nsStr::FindChar(const nsStr& aDest,PRUnichar aChar, PRBool aIgnoreCase,PRInt32 anOffset,PRInt32 aCount) {
+  return gFindChars[aDest.mCharSize](aDest.mStr,aDest.mLength,anOffset,aChar,aIgnoreCase,aCount);
+}
+
+
+/**
+ *  This searches aDest for a character found in aSet. 
+ *  
+ *  @update  gess 3/25/98
+ *  @param   aDest string to search
+ *  @param   aSet contains a list of chars to be searched for
+ *  @param   aIgnorecase indicates case sensitivity of search
+ *  @param   anOffset tells us where to start the search
+ *  @return  index in aDest where member of aSet occurs, or -1 if not found
+ */
+PRInt32 nsStr::FindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnoreCase,PRInt32 anOffset) {
+  //NS_PRECONDITION(aSet.mLength!=1,kCallFindChar);
+
+  PRInt32 index=(0<=anOffset) ? anOffset-1 : -1;
+  PRInt32 thePos;
+
+    //Note that the search is inverted here. We're scanning aDest, one char at a time
+    //but doing the search against the given set. That's why we use 0 as the offset below.
+  if((0<aDest.mLength) && (0<aSet.mLength)){
+    while(++index<(PRInt32)aDest.mLength) {
+      PRUnichar theChar=GetCharAt(aDest,index);
+      thePos=gFindChars[aSet.mCharSize](aSet.mStr,aSet.mLength,0,theChar,aIgnoreCase,aSet.mLength);
+      if(kNotFound!=thePos)
+        return index;
+    } //while
+  }
+  return kNotFound;
+}
+
+  /**************************************************************
+    Reverse Searching methods...
+   **************************************************************/
+
+
+/**
+ *  This searches aDest (in reverse) for a given substring
+ *
+ *  @update  gess 2/18/00
+ *  @param   aDest string to search
+ *  @param   aTarget is the substring you're trying to find.
+ *  @param   aIgnorecase indicates case sensitivity of search
+ *  @param   anOffset tells us where to start the search (counting from left)
+ *  @param   aCount tell us how many iterations to perform from offset
+ *  @return  index in aDest where member of aSet occurs, or -1 if not found
+ */
+PRInt32 nsStr::RFindSubstr(const nsStr& aDest,const nsStr& aTarget,PRBool aIgnoreCase,PRInt32 anOffset,PRInt32 aCount) {
+  if(anOffset<0)
+    anOffset=(PRInt32)aDest.mLength-1;
+
+  if(aCount<0)
+    aCount = aDest.mLength;
+
+  if((0<aDest.mLength) && ((PRUint32)anOffset<aDest.mLength) && (aTarget.mLength)) {
+
+    if(0<aCount) {
+
+      PRInt32     aDelta    = (aDest.mCharSize == eOneByte) ? 1 : 2;
+      const char* root      = aDest.mStr;
+      const char* destLast  = root+(aDest.mLength*aDelta); //pts to last char in aDest (likely null)
+
+      const char* rightmost = root+(anOffset*aDelta);
+      const char* min       = rightmost-((aCount-1)*aDelta);
+
+      const char* leftmost  = (min<root) ? root: min;
+
+      while(leftmost<=rightmost) {
+          //don't forget to divide by delta in next text (bug found by rhp)...
+        if(aTarget.mLength<=PRUint32((destLast-rightmost)/aDelta)) {
+          PRInt32 result=(*gCompare[aDest.mCharSize][aTarget.mCharSize])(rightmost,aTarget.mStr,aTarget.mLength,aIgnoreCase);
+
+          if(0==result) {
+            return (rightmost-root)/aDelta;
+          }
+        } //if
+        rightmost-=aDelta;
+      } //while
+    }
+  }
+
+  return kNotFound;
+}
+
+
+
+/**
+ *  This searches aDest (in reverse) for a given character 
+ *  
+ *  @update  gess 2/04/00
+ *  @param   aDest string to search
+ *  @param   char is the character you're trying to find.
+ *  @param   aIgnorecase indicates case sensitivity of search
+ *  @param   anOffset tells us where to start the search; -1 means start at very end (mLength)
+ *  @param   aCount tell us how many iterations to perform from offset; -1 means use full length.
+ *  @return  index in aDest where member of aSet occurs, or -1 if not found
+ */
+PRInt32 nsStr::RFindChar(const nsStr& aDest,PRUnichar aChar, PRBool aIgnoreCase,PRInt32 anOffset,PRInt32 aCount) {
+  return gRFindChars[aDest.mCharSize](aDest.mStr,aDest.mLength,anOffset,aChar,aIgnoreCase,aCount);
+}
+
+
+/**
+ *  This searches aDest (in reverese) for a character found in aSet. 
+ *  
+ *  @update  gess 3/25/98
+ *  @param   aDest string to search
+ *  @param   aSet contains a list of chars to be searched for
+ *  @param   aIgnorecase indicates case sensitivity of search
+ *  @param   anOffset tells us where to start the search
+ *  @return  index in aDest where member of aSet occurs, or -1 if not found
+ */
+PRInt32 nsStr::RFindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnoreCase,PRInt32 anOffset) {
+  //NS_PRECONDITION(aSet.mLength!=1,kCallRFindChar);
+
+  PRInt32 index=(0<=anOffset) ? anOffset : aDest.mLength;
+  PRInt32 thePos;
+
+    //note that the search is inverted here. We're scanning aDest, one char at a time
+    //but doing the search against the given set. That's why we use 0 as the offset below.
+  if(0<aDest.mLength) {
+    while(--index>=0) {
+      PRUnichar theChar=GetCharAt(aDest,index);
+      thePos=gFindChars[aSet.mCharSize](aSet.mStr,aSet.mLength,0,theChar,aIgnoreCase,aSet.mLength);
+      if(kNotFound!=thePos)
+        return index;
+    } //while
+  }
+  return kNotFound;
+}
+
+/**
+ * Compare source and dest strings, up to an (optional max) number of chars
+ * @param   aDest is the first str to compare
+ * @param   aSource is the second str to compare
+ * @param   aCount -- if (-1), then we use length of longer string; if (0<aCount) then it gives the max # of chars to compare
+ * @param   aIgnorecase tells us whether to search with case sensitivity
+ * @return  aDest<aSource=-1;aDest==aSource==0;aDest>aSource=1
+ */
+PRInt32 nsStr::StrCompare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase) {
+  PRInt32 result=0;
+
+  if(aCount) {
+    PRInt32 minlen=(aSource.mLength<aDest.mLength) ? aSource.mLength : aDest.mLength;
+
+    if(0==minlen) {
+      if ((aDest.mLength == 0) && (aSource.mLength == 0))
+        return 0;
+      if (aDest.mLength == 0)
+        return -1;
+      return 1;
+    }
+
+    PRInt32 theCount = (aCount<0) ? minlen: MinInt(aCount,minlen);
+    result=(*gCompare[aDest.mCharSize][aSource.mCharSize])(aDest.mStr,aSource.mStr,theCount,aIgnoreCase);
+
+    if (0==result) {
+      if(-1==aCount) {
+
+          //Since the caller didn't give us a length to test, and minlen characters matched,
+          //we have to assume that the longer string is greater.
+
+        if (aDest.mLength != aSource.mLength) {
+          //we think they match, but we've only compared minlen characters. 
+          //if the string lengths are different, then they don't really match.
+          result = (aDest.mLength<aSource.mLength) ? -1 : 1;
+        }
+      } //if
+    }
+
+  }
+  return result;
+}
+
+/**
+ * Overwrites the contents of dest at offset with contents of aSource
+ * 
+ * @param   aDest is the first str to compare
+ * @param   aSource is the second str to compare
+ * @param   aDestOffset is the offset within aDest where source should be copied
+ * @return  error code
+ */
+void nsStr::Overwrite(nsStr& aDest,const nsStr& aSource,PRInt32 aDestOffset) {
+  if(aDest.mLength && aSource.mLength) {
+    if((aDest.mLength-aDestOffset)>=aSource.mLength) {
+      //if you're here, then both dest and source have valid lengths
+      //and there's enough room in dest (at offset) to contain source.
+      (*gCopyChars[aSource.mCharSize][aDest.mCharSize])(aDest.mStr,aDestOffset,aSource.mStr,0,aSource.mLength);      
+    }
+  }
+}
+
+//----------------------------------------------------------------------------------------
+
+PRBool nsStr::Alloc(nsStr& aDest,PRUint32 aCount) {
+
+  static int mAllocCount=0;
+  mAllocCount++;
+
+#ifdef NS_USE_OLD_STRING_ALLOCATION_STRATEGY
+  //we're given the acount value in charunits; now scale up to next multiple.
+  PRUint32	theNewCapacity=kDefaultStringSize;
+  while(theNewCapacity<aCount){ 
+		theNewCapacity<<=1;
+  }
+
+  aDest.mCapacity=theNewCapacity++;
+  PRUint32 theSize=(theNewCapacity<<aDest.mCharSize);
+  aDest.mStr = (char*)nsMemory::Alloc(theSize);
+#else
+    // the new strategy is, allocate exact size, double on grows
+  aDest.mCapacity = aCount;
+  aDest.mStr = (char*)nsMemory::Alloc((aCount+1)<<aDest.mCharSize);
+#endif
+
+  if(aDest.mStr) {
+    aDest.mOwnsBuffer=1;
+    gStringAcquiredMemory=PR_TRUE;
+  }
+  else gStringAcquiredMemory=PR_FALSE;
+  return gStringAcquiredMemory;
+}
+
+PRBool nsStr::Free(nsStr& aDest){
+  if(aDest.mStr){
+    if(aDest.mOwnsBuffer){
+      nsMemory::Free(aDest.mStr);
+    }
+    aDest.mStr=0;
+    aDest.mOwnsBuffer=0;
+    return PR_TRUE;
+  }
+  return PR_FALSE;
+}
+
+PRBool nsStr::Realloc(nsStr& aDest,PRUint32 aCount){
+
+  nsStr temp;
+  memcpy(&temp,&aDest,sizeof(aDest));
+
+  PRBool result=Alloc(temp,aCount);
+  if(result) {
+    Free(aDest);
+    aDest.mStr=temp.mStr;
+    aDest.mCapacity=temp.mCapacity;
+    aDest.mOwnsBuffer=temp.mOwnsBuffer;
+  }
+  return result;
+}
+
+/**
+ * Retrieve last memory error
+ *
+ * @update  gess 10/11/99
+ * @return  memory error (usually returns PR_TRUE)
+ */
+PRBool nsStr::DidAcquireMemory(void) {
+  return gStringAcquiredMemory;
+}
+
+//----------------------------------------------------------------------------------------
+
+CBufDescriptor::CBufDescriptor(char* aString,PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength) { 
+  mBuffer=aString;
+  mCharSize=eOneByte;
+  mStackBased=aStackBased;
+  mIsConst=PR_FALSE;
+  mLength=mCapacity=0;
+  if(aString && aCapacity>1) {
+    mCapacity=aCapacity-1;
+    mLength=(-1==aLength) ? strlen(aString) : aLength;
+    if(mLength>PRInt32(mCapacity))
+      mLength=mCapacity;
+  }
+}
+
+CBufDescriptor::CBufDescriptor(const char* aString,PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength) { 
+  mBuffer=(char*)aString;
+  mCharSize=eOneByte;
+  mStackBased=aStackBased;
+  mIsConst=PR_TRUE;
+  mLength=mCapacity=0;
+  if(aString && aCapacity>1) {
+    mCapacity=aCapacity-1;
+    mLength=(-1==aLength) ? strlen(aString) : aLength;
+    if(mLength>PRInt32(mCapacity))
+      mLength=mCapacity;
+  }
+}
+
+
+CBufDescriptor::CBufDescriptor(PRUnichar* aString,PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength) { 
+  mBuffer=(char*)aString;
+  mCharSize=eTwoByte;
+  mStackBased=aStackBased;
+  mLength=mCapacity=0;
+  mIsConst=PR_FALSE;
+  if(aString && aCapacity>1) {
+    mCapacity=aCapacity-1;
+    mLength=(-1==aLength) ? nsCRT::strlen(aString) : aLength;
+    if(mLength>PRInt32(mCapacity))
+      mLength=mCapacity;
+  }
+}
+
+CBufDescriptor::CBufDescriptor(const PRUnichar* aString,PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength) { 
+  mBuffer=(char*)aString;
+  mCharSize=eTwoByte;
+  mStackBased=aStackBased;
+  mLength=mCapacity=0;
+  mIsConst=PR_TRUE;
+  if(aString && aCapacity>1) {
+    mCapacity=aCapacity-1;
+    mLength=(-1==aLength) ? nsCRT::strlen(aString) : aLength;
+    if(mLength>PRInt32(mCapacity))
+      mLength=mCapacity;
+  }
+}
+
+//----------------------------------------------------------------------------------------
+
+PRUint32
+nsStr::HashCode(const nsStr& aDest)
+{
+	if (aDest.mCharSize == eTwoByte)
+    return nsCRT::HashCode(aDest.mUStr);
+  else 
+    return nsCRT::HashCode(aDest.mStr);
+}
+
+#ifdef NS_STR_STATS
+
+#include <ctype.h>
+
+#ifdef XP_MAC
+#define isascii(c)      ((unsigned)(c) < 0x80)
+#endif
+
+void
+nsStr::Print(const nsStr& aDest, FILE* out, PRBool truncate)
+{
+  PRInt32 printLen = (PRInt32)aDest.mLength;
+
+  if (aDest.mCharSize == eOneByte) {
+    const char* chars = aDest.mStr;
+    while (printLen-- && (!truncate || *chars != '\n')) {
+      fputc(*chars++, out);
+    }
+  }
+  else {
+    const PRUnichar* chars = aDest.mUStr;
+    while (printLen-- && (!truncate || *chars != '\n')) {
+      if (isascii(*chars))
+        fputc((char)(*chars++), out);
+      else
+        fputc('-', out);
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// String Usage Statistics Routines
+
+static PLHashTable* gStringInfo = nsnull;
+PRLock* gStringInfoLock = nsnull;
+PRBool gNoStringInfo = PR_FALSE;
+
+nsStringInfo::nsStringInfo(nsStr& str)
+  : mCount(0)
+{
+  nsStr::Initialize(mStr, str.mCharSize);
+  nsStr::StrAssign(mStr, str, 0, -1);
+//  nsStr::Print(mStr, stdout);
+//  fputc('\n', stdout);
+}
+
+PR_EXTERN(PRHashNumber)
+nsStr_Hash(const void* key)
+{
+  nsStr* str = (nsStr*)key;
+  return nsStr::HashCode(*str);
+}
+
+PR_EXTERN(PRIntn)
+nsStr_Compare(const void *v1, const void *v2)
+{
+  nsStr* str1 = (nsStr*)v1;
+  nsStr* str2 = (nsStr*)v2;
+  return nsStr::StrCompare(*str1, *str2, -1, PR_FALSE) == 0;
+}
+
+nsStringInfo*
+nsStringInfo::GetInfo(nsStr& str)
+{
+  if (gStringInfo == nsnull) {
+    gStringInfo = PL_NewHashTable(1024,
+                                  nsStr_Hash,
+                                  nsStr_Compare,
+                                  PL_CompareValues,
+                                  NULL, NULL);
+    gStringInfoLock = PR_NewLock();
+  }
+  PR_Lock(gStringInfoLock);
+  nsStringInfo* info =
+    (nsStringInfo*)PL_HashTableLookup(gStringInfo, &str);
+  if (info == NULL) {
+    gNoStringInfo = PR_TRUE;
+    info = new nsStringInfo(str);
+    if (info) {
+      PLHashEntry* e = PL_HashTableAdd(gStringInfo, &info->mStr, info);
+      if (e == NULL) {
+        delete info;
+        info = NULL;
+      }
+    }
+    gNoStringInfo = PR_FALSE;
+  }
+  PR_Unlock(gStringInfoLock);
+  return info;
+}
+
+void
+nsStringInfo::Seen(nsStr& str)
+{
+  if (!gNoStringInfo) {
+    nsStringInfo* info = GetInfo(str);
+    info->mCount++;
+  }
+}
+
+void
+nsStringInfo::Report(FILE* out)
+{
+  if (gStringInfo) {
+    fprintf(out, "\n== String Stats\n");
+    PL_HashTableEnumerateEntries(gStringInfo, nsStringInfo::ReportEntry, out);
+  }
+}
+
+PRIntn
+nsStringInfo::ReportEntry(PLHashEntry *he, PRIntn i, void *arg)
+{
+  nsStringInfo* entry = (nsStringInfo*)he->value;
+  FILE* out = (FILE*)arg;
+  
+  fprintf(out, "%d ==> (%d) ", entry->mCount, entry->mStr.mLength);
+  nsStr::Print(entry->mStr, out, PR_TRUE);
+  fputc('\n', out);
+  return HT_ENUMERATE_NEXT;
+}
+
+#endif // NS_STR_STATS
+
+////////////////////////////////////////////////////////////////////////////////

mozilla/string/obsolete/nsStr.h

@@ -0,0 +1,523 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ *   Rick Gessner <rickg@netscape.com> (original author)
+ *   Scott Collins <scc@mozilla.org>
+ */
+
+/***********************************************************************
+  MODULE NOTES:
+
+    1. There are two philosophies to building string classes:
+        A. Hide the underlying buffer & offer API's allow indirect iteration
+        B. Reveal underlying buffer, risk corruption, but gain performance
+        
+       We chose the option B for performance reasons. 
+
+    2  Our internal buffer always holds capacity+1 bytes.
+
+    The nsStr struct is a simple structure (no methods) that contains
+    the necessary info to be described as a string. This simple struct
+    is manipulated by the static methods provided in this class. 
+    (Which effectively makes this a library that works on structs).
+
+    There are also object-based versions called nsString and nsAutoString
+    which use nsStr but makes it look at feel like an object. 
+
+ ***********************************************************************/
+
+/***********************************************************************
+  ASSUMPTIONS:
+
+    1. nsStrings and nsAutoString are always null terminated. However,
+       since it maintains a length byte, you can store NULL's inside
+       the string. Just be careful passing such buffers to 3rd party
+       API's that assume that NULL always terminate the buffer.
+
+    2. nsCStrings can be upsampled into nsString without data loss
+
+    3. Char searching is faster than string searching. Use char interfaces
+       if your needs will allow it.
+
+    4. It's easy to use the stack for nsAutostring buffer storage (fast too!).
+       See the CBufDescriptor class in this file.
+
+    5. If you don't provide the optional count argument to Append() and Insert(),
+       the method will assume that the given buffer is terminated by the first
+       NULL it encounters.
+
+    6. Downsampling from nsString to nsCString can be lossy -- avoid it if possible!
+
+    7. Calls to ToNewCString() and ToNewUnicode() should be matched with calls to nsMemory::Free().
+
+ ***********************************************************************/
+
+
+/**********************************************************************************
+  
+ AND NOW FOR SOME GENERAL DOCUMENTATION ON STRING USAGE...
+
+    The fundamental datatype in the string library is nsStr. It's a structure that
+    provides the buffer storage and meta-info. It also provides a C-style library
+    of functions for direct manipulation (for those of you who prefer K&R to Bjarne). 
+
+    Here's a diagram of the class hierarchy: 
+
+      nsStr
+        |___nsString
+        |      |
+        |      ------nsAutoString
+        |
+        |___nsCString
+               |
+               ------nsCAutoString
+
+    Why so many string classes? The 4 variants give you the control you need to 
+    determine the best class for your purpose. There are 2 dimensions to this 
+    flexibility: 1) stack vs. heap; and 2) 1-byte chars vs. 2-byte chars.
+
+    Note: While nsAutoString and nsCAutoString begin life using stack-based storage,
+          they may not stay that way. Like all nsString classes, autostrings will
+          automatically grow to contain the data you provide. When autostrings
+          grow beyond their intrinsic buffer, they switch to heap based allocations.
+          (We avoid alloca to avoid considerable platform difficulties; see the 
+           GNU documentation for more details).
+
+    I should also briefly mention that all the string classes use a "memory agent" 
+    object to perform memory operations. This class proxies the standard nsMemory
+    for actual memory calls, but knows the structure of nsStr making heap operations
+    more localized.
+    
+
+  CHOOSING A STRING CLASS:
+
+    In order to choose a string class for you purpose, use this handy table:
+
+                        heap-based    stack-based
+                    -----------------------------------
+        ascii data  |   nsCString     nsCAutoString   |
+                    |----------------------------------
+      unicode data  |    nsString      nsAutoString   |
+                    ----------------------------------- 
+    
+  
+    Note: The i18n folks will stenuously object if we get too carried away with the
+          use of nsCString's that pass interface boundaries. Try to limit your
+          use of these to external interfaces that demand them, or for your own
+          private purposes in cases where they'll never be seen by humans. 
+
+    
+  --- FAQ ---
+
+    Q. When should I use nsCString instead of nsString?
+
+    A. You should really try to stick with nsString, so that we stay as unicode
+       compliant as possible. But there are cases where an interface you use requires
+       a char*. In such cases, it's fair to use nsCString. 
+
+    Q. I know that my string is going to be a certain size. Can I pre-size my nsString?
+
+    A. Yup, here's how:
+
+         {
+           nsString mBuffer;
+           mBuffer.SetCapacity(aReasonableSize);
+         }
+
+    Q. Should nsAutoString or nsCAutoString ever live on the heap?  
+
+    A. That would be counterproductive. The point of nsAutoStrings is to preallocate your
+       buffers, and to auto-destroy the string when it goes out of scope. 
+
+    Q. I already have a char*. Can I use the nsString functionality on that buffer?
+
+    A. Yes you can -- by using an intermediate class called CBufDescriptor.
+       The CBufDescriptor class is used to tell nsString about an external buffer (heap or stack) to use
+       instead of it's own internal buffers. Here's an example:
+         
+         {
+           char theBuffer[256];
+           CBufDescritor theBufDecriptor( theBuffer, PR_TRUE, sizeof(theBuffer), 0);
+           nsCAutoString s3( theBufDescriptor );
+           s3="HELLO, my name is inigo montoya, you killed my father, prepare to die!.";
+         }
+
+         The assignment statment to s3 will cause the given string to be written to your
+         stack-based buffer via the normal nsString/nsCString interfaces. Cool, huh?  
+         Note however that just like any other nsStringXXX use, if you write more data 
+         than will fit in the buffer, a visit to the heap manager will be in order. 
+     
+
+    Q. What is the simplest way to get from a char* to PRUnichar*?
+    
+    A. The simplest way is by construction (or assignment): 
+
+        {
+          char* theBuf = "hello there";
+          nsAutoString foo(theBuf);
+        }
+
+       If you don't want the char* to be copied into the nsAutoString, the use a 
+       CBufDescriptor instead.
+
+
+ **********************************************************************************/
+
+
+#ifndef _nsStr
+#define _nsStr
+
+#include "nscore.h"
+#include "nsMemory.h"
+#include <string.h>
+#include <stdio.h>
+#include "plhash.h"
+
+//----------------------------------------------------------------------------------------
+
+enum  eCharSize {eOneByte=0,eTwoByte=1};
+#define kDefaultCharSize eTwoByte
+#define kRadix10        (10)
+#define kRadix16        (16)
+#define kAutoDetect     (100)
+#define kRadixUnknown   (kAutoDetect+1)
+#define IGNORE_CASE     (PR_TRUE)
+
+const   PRInt32 kDefaultStringSize = 64;
+const   PRInt32 kNotFound = -1;
+
+
+//----------------------------------------------------------------------------------------
+
+class NS_COM CBufDescriptor {
+public:
+  CBufDescriptor(char* aString,           PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength=-1);
+  CBufDescriptor(const char* aString,     PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength=-1);
+  CBufDescriptor(PRUnichar* aString,      PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength=-1);
+  CBufDescriptor(const PRUnichar* aString,PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength=-1);
+
+  char*     mBuffer;
+  eCharSize mCharSize;
+  PRUint32  mCapacity;
+  PRInt32   mLength;
+  PRBool    mStackBased;
+  PRBool    mIsConst;
+};
+
+//----------------------------------------------------------------------------------------
+
+
+struct NS_COM nsStr {  
+
+  nsStr() {
+    MOZ_COUNT_CTOR(nsStr);
+  }
+
+  ~nsStr() {
+    MOZ_COUNT_DTOR(nsStr);
+  }
+
+ /**
+  * This method initializes an nsStr for use
+  *
+  * @update	gess 01/04/99
+  * @param  aString is the nsStr to be initialized
+  * @param  aCharSize tells us the requested char size (1 or 2 bytes)
+  */
+  static void Initialize(nsStr& aDest,eCharSize aCharSize);
+
+ /**
+  * This method initializes an nsStr for use
+  *
+  * @update	gess 01/04/99
+  * @param  aString is the nsStr to be initialized
+  * @param  aCharSize tells us the requested char size (1 or 2 bytes)
+  */
+  static void Initialize(nsStr& aDest,char* aCString,PRUint32 aCapacity,PRUint32 aLength,eCharSize aCharSize,PRBool aOwnsBuffer);
+
+ /**
+  * This method destroys the given nsStr, and *MAY* 
+  * deallocate it's memory depending on the setting
+  * of the internal mOwnsBUffer flag.
+  *
+  * @update	gess 01/04/99
+  * @param  aString is the nsStr to be manipulated
+  * @param  anAgent is the allocator to be used to the nsStr
+  */
+  static void Destroy(nsStr& aDest); 
+
+ /**
+  * These methods are where memory allocation/reallocation occur. 
+  *
+  * @update	gess 01/04/99
+  * @param  aString is the nsStr to be manipulated
+  * @param  anAgent is the allocator to be used on the nsStr
+  * @return  
+  */
+  static PRBool EnsureCapacity(nsStr& aString,PRUint32 aNewLength);
+  static PRBool GrowCapacity(nsStr& aString,PRUint32 aNewLength);
+
+ /**
+  * These methods are used to append content to the given nsStr
+  *
+  * @update	gess 01/04/99
+  * @param  aDest is the nsStr to be appended to
+  * @param  aSource is the buffer to be copied from
+  * @param  anOffset tells us where in source to start copying
+  * @param  aCount tells us the (max) # of chars to copy
+  * @param  anAgent is the allocator to be used for alloc/free operations
+  */
+  static void StrAppend(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount);
+
+ /**
+  * These methods are used to assign contents of a source string to dest string
+  *
+  * @update	gess 01/04/99
+  * @param  aDest is the nsStr to be appended to
+  * @param  aSource is the buffer to be copied from
+  * @param  anOffset tells us where in source to start copying
+  * @param  aCount tells us the (max) # of chars to copy
+  * @param  anAgent is the allocator to be used for alloc/free operations
+  */
+  static void StrAssign(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount);
+
+ /**
+  * These methods are used to insert content from source string to the dest nsStr
+  *
+  * @update	gess 01/04/99
+  * @param  aDest is the nsStr to be appended to
+  * @param  aDestOffset tells us where in dest to start insertion
+  * @param  aSource is the buffer to be copied from
+  * @param  aSrcOffset tells us where in source to start copying
+  * @param  aCount tells us the (max) # of chars to insert
+  * @param  anAgent is the allocator to be used for alloc/free operations
+  */
+  static void StrInsert( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount);
+
+ /**
+  * This method deletes chars from the given str. 
+  * The given allocator may choose to resize the str as well.
+  *
+  * @update	gess 01/04/99
+  * @param  aDest is the nsStr to be deleted from
+  * @param  aDestOffset tells us where in dest to start deleting
+  * @param  aCount tells us the (max) # of chars to delete
+  * @param  anAgent is the allocator to be used for alloc/free operations
+  */
+  static void Delete(nsStr& aDest,PRUint32 aDestOffset,PRUint32 aCount);
+
+ /**
+  * This method is used to truncate the given string.
+  * The given allocator may choose to resize the str as well (but it's not likely).
+  *
+  * @update	gess 01/04/99
+  * @param  aDest is the nsStr to be appended to
+  * @param  aDestOffset tells us where in dest to start insertion
+  * @param  aSource is the buffer to be copied from
+  * @param  aSrcOffset tells us where in source to start copying
+  * @param  anAgent is the allocator to be used for alloc/free operations
+  */
+  static void Truncate(nsStr& aDest,PRUint32 aDestOffset);
+
+ /**
+  * This method is used to perform a case conversion on the given string
+  *
+  * @update	gess 01/04/99
+  * @param  aDest is the nsStr to be case shifted
+  * @param  toUpper tells us to go upper vs. lower
+  */
+  static void ChangeCase(nsStr& aDest,PRBool aToUpper);
+
+
+  /**
+   * This method trims chars (given in aSet) from the edges of given buffer 
+   *
+   * @update	gess 01/04/99
+   * @param   aDest is the buffer to be manipulated
+   * @param   aSet tells us which chars to remove from given buffer
+   * @param   aEliminateLeading tells us whether to strip chars from the start of the buffer
+   * @param   aEliminateTrailing tells us whether to strip chars from the start of the buffer
+   */
+  static void Trim(nsStr& aDest,const char* aSet,PRBool aEliminateLeading,PRBool aEliminateTrailing);
+  
+  /**
+   * This method compresses duplicate runs of a given char from the given buffer 
+   *
+   * @update	gess 01/04/99
+   * @param   aDest is the buffer to be manipulated
+   * @param   aSet tells us which chars to compress from given buffer
+   * @param   aChar is the replacement char
+   * @param   aEliminateLeading tells us whether to strip chars from the start of the buffer
+   * @param   aEliminateTrailing tells us whether to strip chars from the start of the buffer
+   */
+  static void CompressSet(nsStr& aDest,const char* aSet,PRBool aEliminateLeading,PRBool aEliminateTrailing);
+
+  /**
+   * This method removes all occurances of chars in given set from aDest 
+   *
+   * @update	gess 01/04/99
+   * @param   aDest is the buffer to be manipulated
+   * @param   aSet tells us which chars to compress from given buffer
+   * @param   aChar is the replacement char
+   * @param   aEliminateLeading tells us whether to strip chars from the start of the buffer
+   * @param   aEliminateTrailing tells us whether to strip chars from the start of the buffer
+   */
+  static void StripChars(nsStr& aDest,const char* aSet);
+
+  /**
+   * This method compares the data bewteen two nsStr's 
+   *
+   * @update	gess 01/04/99
+   * @param   aStr1 is the first buffer to be compared
+   * @param   aStr2 is the 2nd buffer to be compared
+   * @param   aCount is the number of chars to compare
+   * @param   aIgnorecase tells us whether to use a case-sensitive comparison
+   * @return  -1,0,1 depending on <,==,>
+   */
+  static PRInt32  StrCompare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase);
+
+ /**
+  * These methods scan the given string for 1 or more chars in a given direction
+  *
+  * @update	gess 01/04/99
+  * @param  aDest is the nsStr to be searched to
+  * @param  aSource (or aChar) is the substr we're looking to find
+  * @param  aIgnoreCase tells us whether to search in a case-sensitive manner
+  * @param  anOffset tells us where in the dest string to start searching
+  * @return the index of the source (substr) in dest, or -1 (kNotFound) if not found.
+  */
+  static PRInt32 FindSubstr(const nsStr& aDest,const nsStr& aSource, PRBool aIgnoreCase,PRInt32 anOffset,PRInt32 aCount);
+  static PRInt32 FindChar(const nsStr& aDest,PRUnichar aChar, PRBool aIgnoreCase,PRInt32 anOffset,PRInt32 aCount);
+  static PRInt32 FindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnoreCase,PRInt32 anOffset);
+
+  static PRInt32 RFindSubstr(const nsStr& aDest,const nsStr& aSource, PRBool aIgnoreCase,PRInt32 anOffset,PRInt32 aCount);
+  static PRInt32 RFindChar(const nsStr& aDest,PRUnichar aChar, PRBool aIgnoreCase,PRInt32 anOffset,PRInt32 aCount);
+  static PRInt32 RFindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnoreCase,PRInt32 anOffset);
+
+  static void    Overwrite(nsStr& aDest,const nsStr& aSource,PRInt32 anOffset);
+
+  static PRBool   DidAcquireMemory(void);
+
+  /**
+   * Returns a hash code for the string for use in a PLHashTable.
+   */
+  static PRUint32 HashCode(const nsStr& aDest);
+
+#ifdef NS_STR_STATS
+  /**
+   * Prints an nsStr. If truncate is true, the string is only printed up to 
+   * the first newline. (Note: The current implementation doesn't handle
+   * non-ascii unicode characters.)
+   */
+  static void Print(const nsStr& aDest, FILE* out, PRBool truncate = PR_FALSE);
+#endif
+
+  PRUint32        mLength;
+  PRUint32        mCapacity;
+  eCharSize       mCharSize;
+  PRBool          mOwnsBuffer;
+
+  union { 
+    char*         mStr;
+    PRUnichar*    mUStr;
+  };
+
+private:
+  static PRBool Alloc(nsStr& aString,PRUint32 aCount);
+  static PRBool Realloc(nsStr& aString,PRUint32 aCount);
+  static PRBool Free(nsStr& aString);
+
+};
+
+
+
+
+/**************************************************************
+  A couple of tiny helper methods used in the string classes.
+ **************************************************************/
+
+inline PRInt32 MinInt(PRInt32 anInt1,PRInt32 anInt2){
+  return (anInt1<anInt2) ? anInt1 : anInt2;
+}
+
+inline PRInt32 MaxInt(PRInt32 anInt1,PRInt32 anInt2){
+  return (anInt1<anInt2) ? anInt2 : anInt1;
+}
+
+inline void AddNullTerminator(nsStr& aDest) {
+  if(eTwoByte==aDest.mCharSize) 
+    aDest.mUStr[aDest.mLength]=0;
+  else aDest.mStr[aDest.mLength]=0;
+}
+
+/**
+ * Deprecated: don't use |Recycle|, just call |nsMemory::Free| directly
+ *
+ * Return the given buffer to the heap manager. Calls allocator::Free()
+ * @return string length
+ */
+inline void Recycle( char* aBuffer) { nsMemory::Free(aBuffer); }
+inline void Recycle( PRUnichar* aBuffer) { nsMemory::Free(aBuffer); }
+
+/**
+* This method is used to access a given char in the given string
+*
+* @update	gess 01/04/99
+* @param  aDest is the nsStr to be appended to
+* @param  anIndex tells us where in dest to get the char from
+* @return the given char, or 0 if anIndex is out of range
+*/
+inline PRUnichar GetCharAt(const nsStr& aDest,PRUint32 anIndex){
+  if(anIndex<aDest.mLength)  {
+    return (eTwoByte==aDest.mCharSize) ? aDest.mUStr[anIndex] : (PRUnichar)aDest.mStr[anIndex];
+  }//if
+  return 0;
+}
+
+
+#ifdef NS_STR_STATS
+
+class nsStringInfo {
+public:
+  nsStringInfo(nsStr& str);
+  ~nsStringInfo() {}
+
+  static nsStringInfo* GetInfo(nsStr& str);
+
+  static void Seen(nsStr& str);
+
+  static void Report(FILE* out = stdout);
+  
+  static PRIntn ReportEntry(PLHashEntry *he, PRIntn i, void *arg);
+
+protected:
+  nsStr         mStr;
+  PRUint32      mCount;
+};
+
+#define NSSTR_SEEN(str) nsStringInfo::Seen(str)
+
+#else // !NS_STR_STATS
+
+#define NSSTR_SEEN(str) /* nothing */
+
+#endif // !NS_STR_STATS
+
+#endif // _nsStr

mozilla/string/obsolete/nsString.h

@@ -0,0 +1,629 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ *   Rick Gessner <rickg@netscape.com> (original author)
+ *   Scott Collins <scc@mozilla.org>
+ */
+
+
+/***********************************************************************
+  MODULE NOTES:
+
+  See nsStr.h for a more general description of string classes.
+
+  This version of the nsString class offers many improvements over the
+  original version:
+    1. Wide and narrow chars
+    2. Allocators
+    3. Much smarter autostrings
+    4. Subsumable strings
+ ***********************************************************************/
+
+#ifndef _nsCString_
+#define _nsCString_
+
+#include "nsString2.h"
+#include "prtypes.h"
+#include "nscore.h"
+#include <stdio.h>
+#include "nsStr.h"
+#include "nsIAtom.h"
+
+#include "nsAWritableString.h"
+
+
+class NS_COM nsSubsumeCStr;
+
+class NS_COM nsCString :
+  public nsAWritableCString,
+  public nsStr {
+
+protected:
+  virtual const void* Implementation() const { return "nsCString"; }
+  virtual const char* GetReadableFragment( nsReadableFragment<char>&, nsFragmentRequest, PRUint32 ) const;
+  virtual char* GetWritableFragment( nsWritableFragment<char>&, nsFragmentRequest, PRUint32 );
+
+public: 
+  /**
+   * Default constructor. 
+   */
+  nsCString();
+
+  /**
+   * This is our copy constructor 
+   * @param   reference to another nsCString
+   */
+  nsCString(const nsCString& aString);   
+
+  explicit nsCString( const nsAReadableCString& );
+
+  explicit nsCString(const char*);
+  nsCString(const char*, PRInt32);
+
+  /**
+   * This constructor takes a subsumestr
+   * @param   reference to subsumestr
+   */
+  explicit nsCString(nsSubsumeCStr& aSubsumeStr);
+
+  /**
+   * Destructor
+   * 
+   */
+  virtual ~nsCString();    
+
+  /**
+   * Retrieve the length of this string
+   * @return string length
+   */
+  virtual PRUint32 Length() const { return mLength; }
+
+  /**
+   * Retrieve the size of this string
+   * @return string length
+   */
+  virtual void SizeOf(nsISizeOfHandler* aHandler, PRUint32* aResult) const;
+
+
+  /**
+   * Call this method if you want to force a different string capacity
+   * @update  gess7/30/98
+   * @param   aLength -- contains new length for mStr
+   * @return
+   */
+  void SetLength(PRUint32 aLength);
+
+  /**
+   * Sets the new length of the string.
+   * @param   aLength is new string length.
+   * @return  nada
+   */
+  void SetCapacity(PRUint32 aLength);
+
+  /**
+   * This method truncates this string to given length.
+   *
+   * @param   anIndex -- new length of string
+   * @return  nada
+   */
+  void Truncate(PRUint32 anIndex=0) {
+    NS_ASSERTION(anIndex<=mLength, "Can't use |Truncate()| to make a string longer.");
+    if ( anIndex < mLength )
+      SetLength(anIndex);
+  }
+
+  /**********************************************************************
+    Accessor methods...
+   *********************************************************************/
+
+
+   /**
+     * Retrieve const ptr to internal buffer; DO NOT TRY TO FREE IT!
+     */
+  const char* GetBuffer(void) const;
+
+  PRBool SetCharAt(PRUnichar aChar,PRUint32 anIndex);
+
+  /**********************************************************************
+    Lexomorphic transforms...
+   *********************************************************************/
+
+  /**
+   * Converts chars in this to lowercase
+   * @update  gess 7/27/98
+   */
+  void ToLowerCase();
+
+
+  /**
+   * Converts chars in this to lowercase, and
+   * stores them in aOut
+   * @update  gess 7/27/98
+   * @param   aOut is a string to contain result
+   */
+  void ToLowerCase(nsCString& aString) const;
+
+  /**
+   * Converts chars in this to uppercase
+   * @update  gess 7/27/98
+   */
+  void ToUpperCase();
+
+  /**
+   * Converts chars in this to lowercase, and
+   * stores them in a given output string
+   * @update  gess 7/27/98
+   * @param   aOut is a string to contain result
+   */
+  void ToUpperCase(nsCString& aString) const;
+
+
+  /**
+   *  This method is used to remove all occurances of the
+   *  characters found in aSet from this string.
+   *  
+   *  @param  aSet -- characters to be cut from this
+   *  @return *this 
+   */
+  void StripChars(const char* aSet);
+  void StripChar(PRUnichar aChar,PRInt32 anOffset=0);
+  void StripChar(char aChar,PRInt32 anOffset=0) { StripChar((PRUnichar) (unsigned char)aChar,anOffset); }
+
+  /**
+   *  This method strips whitespace throughout the string
+   *  
+   *  @return  this
+   */
+  void StripWhitespace();
+
+  /**
+   *  swaps occurence of 1 string for another
+   *  
+   *  @return  this
+   */
+  void ReplaceChar(PRUnichar aOldChar,PRUnichar aNewChar);
+  void ReplaceChar(const char* aSet,PRUnichar aNewChar);
+
+  void ReplaceSubstring(const nsCString& aTarget,const nsCString& aNewValue);
+  void ReplaceSubstring(const char* aTarget,const char* aNewValue);
+
+  PRInt32 CountChar(PRUnichar aChar);
+
+  /**
+   *  This method trims characters found in aTrimSet from
+   *  either end of the underlying string.
+   *  
+   *  @param   aTrimSet -- contains chars to be trimmed from
+   *           both ends
+   *  @param   aEliminateLeading
+   *  @param   aEliminateTrailing
+   *  @param   aIgnoreQuotes
+   *  @return  this
+   */
+  void Trim(const char* aSet,PRBool aEliminateLeading=PR_TRUE,PRBool aEliminateTrailing=PR_TRUE,PRBool aIgnoreQuotes=PR_FALSE);
+
+  /**
+   *  This method strips whitespace from string.
+   *  You can control whether whitespace is yanked from
+   *  start and end of string as well.
+   *  
+   *  @param   aEliminateLeading controls stripping of leading ws
+   *  @param   aEliminateTrailing controls stripping of trailing ws
+   *  @return  this
+   */
+  void CompressSet(const char* aSet, PRUnichar aChar,PRBool aEliminateLeading=PR_TRUE,PRBool aEliminateTrailing=PR_TRUE);
+
+  /**
+   *  This method strips whitespace from string.
+   *  You can control whether whitespace is yanked from
+   *  start and end of string as well.
+   *  
+   *  @param   aEliminateLeading controls stripping of leading ws
+   *  @param   aEliminateTrailing controls stripping of trailing ws
+   *  @return  this
+   */
+  void CompressWhitespace( PRBool aEliminateLeading=PR_TRUE,PRBool aEliminateTrailing=PR_TRUE);
+
+  /**********************************************************************
+    string conversion methods...
+   *********************************************************************/
+//#ifndef STANDALONE_STRING_TESTS
+  operator char*() {return mStr;}
+  operator const char*() const {return (const char*)mStr;}
+//#endif
+
+  /**
+   * This method constructs a new nsCString that is a clone
+   * of this string.
+   * 
+   */
+  nsCString* ToNewString() const;
+
+  /**
+   * Creates an ISOLatin1 clone of this string
+   * Note that calls to this method should be matched with calls to Recycle().
+   * @return  ptr to new isolatin1 string
+   */
+  char* ToNewCString() const;
+
+  /**
+   * Creates a unicode clone of this string
+   * Note that calls to this method should be matched with calls to Recycle().
+   * @return  ptr to new unicode string
+   */
+  PRUnichar* ToNewUnicode() const;
+
+  /**
+   * Copies data from internal buffer onto given char* buffer
+   * NOTE: This only copies as many chars as will fit in given buffer (clips)
+   * @param aBuf is the buffer where data is stored
+   * @param aBuflength is the max # of chars to move to buffer
+   * @return ptr to given buffer
+   */
+  char* ToCString(char* aBuf,PRUint32 aBufLength,PRUint32 anOffset=0) const;
+
+  /**
+   * Perform string to float conversion.
+   * @param   aErrorCode will contain error if one occurs
+   * @return  float rep of string value
+   */
+  float ToFloat(PRInt32* aErrorCode) const;
+
+
+  /**
+   * Perform string to int conversion.
+   * @param   aErrorCode will contain error if one occurs
+   * @param   aRadix tells us which radix to assume; kAutoDetect tells us to determine the radix for you.
+   * @return  int rep of string value, and possible (out) error code
+   */
+  PRInt32   ToInteger(PRInt32* aErrorCode,PRUint32 aRadix=kRadix10) const;
+
+
+  /**********************************************************************
+    String manipulation methods...                
+   *********************************************************************/
+
+  /**
+   * assign given string to this string
+   * @param   aStr: buffer to be assigned to this 
+   * @param   aCount is the length of the given str (or -1) if you want me to determine its length
+   *  NOTE:    IFF you pass -1 as aCount, then your buffer must be null terminated.
+   *
+   * @return  this
+   */
+
+  nsCString& operator=( const nsCString& aString )                  { Assign(aString); return *this; }
+  nsCString& operator=( const nsAReadableCString& aReadable )       { Assign(aReadable); return *this; }
+  nsCString& operator=( const nsPromiseReadable<char>& aReadable )  { Assign(aReadable); return *this; }
+  nsCString& operator=( const char* aPtr )                          { Assign(aPtr); return *this; }
+  nsCString& operator=( char aChar )                                { Assign(aChar); return *this; }
+
+  void AssignWithConversion(const PRUnichar*,PRInt32=-1);
+  void AssignWithConversion( const nsString& aString );
+  void AssignWithConversion( const nsAReadableString& aString );
+  void AssignWithConversion(PRUnichar);
+
+  /*
+   *  Appends n characters from given string to this,
+   *  
+   *  @param   aString is the source to be appended to this
+   *  @param   aCount -- number of chars to copy; -1 tells us to compute the strlen for you
+   *  NOTE:    IFF you pass -1 as aCount, then your buffer must be null terminated.
+   *
+   *  @return  number of chars copied
+   */
+
+  void AppendWithConversion(const nsString&, PRInt32=-1);
+  void AppendWithConversion(PRUnichar aChar);
+  void AppendWithConversion( const nsAReadableString& aString );
+  void AppendWithConversion(const PRUnichar*, PRInt32=-1);
+  // Why no |AppendWithConversion(const PRUnichar*, PRInt32)|? --- now I know, because implicit construction hid the need for this routine
+  void AppendInt(PRInt32 aInteger,PRInt32 aRadix=10); //radix=8,10 or 16
+  void AppendFloat( double aFloat );
+
+  virtual void do_AppendFromReadable( const nsAReadableCString& );
+  /*
+   *  Copies n characters from this string to given string,
+   *  starting at the leftmost offset.
+   *  
+   *  
+   *  @param   aCopy -- Receiving string
+   *  @param   aCount -- number of chars to copy
+   *  @return  number of chars copied
+   */
+  PRUint32 Left(nsCString& aCopy,PRInt32 aCount) const;
+
+  /*
+   *  Copies n characters from this string to given string,
+   *  starting at the given offset.
+   *  
+   *  
+   *  @param   aCopy -- Receiving string
+   *  @param   aCount -- number of chars to copy
+   *  @param   anOffset -- position where copying begins
+   *  @return  number of chars copied
+   */
+  PRUint32 Mid(nsCString& aCopy,PRUint32 anOffset,PRInt32 aCount) const;
+
+  /*
+   *  Copies n characters from this string to given string,
+   *  starting at rightmost char.
+   *  
+   *  
+   *  @param  aCopy -- Receiving string
+   *  @param  aCount -- number of chars to copy
+   *  @return number of chars copied
+   */
+  PRUint32 Right(nsCString& aCopy,PRInt32 aCount) const;
+
+  void InsertWithConversion(PRUnichar aChar,PRUint32 anOffset);
+  // Why no |InsertWithConversion(PRUnichar*)|?
+
+  virtual void do_InsertFromReadable( const nsAReadableCString&, PRUint32 );
+
+
+  /**********************************************************************
+    Searching methods...                
+   *********************************************************************/
+ 
+
+  /**
+   *  Search for given substring within this string
+   *  
+   *  @param   aString is substring to be sought in this
+   *  @param   aIgnoreCase selects case sensitivity
+   *  @param   anOffset tells us where in this strig to start searching
+   *  @param   aCount tells us how many iterations to make starting at the given offset
+   *  @return  offset in string, or -1 (kNotFound)
+   */
+  PRInt32 Find(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=0,PRInt32 aCount=-1) const;
+  PRInt32 Find(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=0,PRInt32 aCount=-1) const;
+  PRInt32 Find(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=0,PRInt32 aCount=-1) const;
+
+  /**
+   *  Search for given char within this string
+   *  
+   *  @param   aString is substring to be sought in this
+   *  @param   anOffset tells us where in this strig to start searching
+   *  @param   aIgnoreCase selects case sensitivity
+   *  @param   aCount tells us how many iterations to make starting at the given offset
+   *  @return  find pos in string, or -1 (kNotFound)
+   */
+  PRInt32 FindChar(PRUnichar aChar,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=0,PRInt32 aCount=-1) const;
+
+  /**
+   * This method searches this string for the first character
+   * found in the given charset
+   * @param aString contains set of chars to be found
+   * @param anOffset tells us where to start searching in this
+   * @return -1 if not found, else the offset in this
+   */
+  PRInt32 FindCharInSet(const char* aString,PRInt32 anOffset=0) const;
+  PRInt32 FindCharInSet(const PRUnichar* aString,PRInt32 anOffset=0) const;
+  PRInt32 FindCharInSet(const nsStr& aString,PRInt32 anOffset=0) const;
+
+
+  /**
+   * This methods scans the string backwards, looking for the given string
+   * @param   aString is substring to be sought in this
+   * @param   aIgnoreCase tells us whether or not to do caseless compare
+   * @param   aCount tells us how many iterations to make starting at the given offset
+   * @return  offset in string, or -1 (kNotFound)
+   */
+  PRInt32 RFind(const char* aCString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1,PRInt32 aCount=-1) const;
+  PRInt32 RFind(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1,PRInt32 aCount=-1) const;
+  PRInt32 RFind(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1,PRInt32 aCount=-1) const;
+
+
+  /**
+   *  Search for given char within this string
+   *  
+   *  @param   aString is substring to be sought in this
+   *  @param   anOffset tells us where in this strig to start searching
+   *  @param   aIgnoreCase selects case sensitivity
+   *  @return  find pos in string, or -1 (kNotFound)
+   */
+  PRInt32 RFindChar(PRUnichar aChar,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1,PRInt32 aCount=-1) const;
+
+  /**
+   * This method searches this string for the last character
+   * found in the given string
+   * @param aString contains set of chars to be found
+   * @param anOffset tells us where to start searching in this
+   * @return -1 if not found, else the offset in this
+   */
+  PRInt32 RFindCharInSet(const char* aString,PRInt32 anOffset=-1) const;
+  PRInt32 RFindCharInSet(const PRUnichar* aString,PRInt32 anOffset=-1) const;
+  PRInt32 RFindCharInSet(const nsStr& aString,PRInt32 anOffset=-1) const;
+
+
+
+  /**********************************************************************
+    Comparison methods...                
+   *********************************************************************/
+
+  /**
+   * Compares a given string type to this string. 
+   * @update  gess 7/27/98
+   * @param   S is the string to be compared
+   * @param   aIgnoreCase tells us how to treat case
+   * @param   aCount tells us how many chars to compare
+   * @return  -1,0,1
+   */
+  PRInt32 CompareWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
+  PRInt32 CompareWithConversion(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
+
+  PRBool  EqualsWithConversion(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
+  PRBool  EqualsWithConversion(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
+  PRBool  EqualsWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
+
+  PRBool  EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const;
+  PRBool  EqualsIgnoreCase(const PRUnichar* aString,PRInt32 aCount=-1) const;
+
+
+  void    DebugDump(void) const;
+
+
+  static  void        Recycle(nsCString* aString);
+  static  nsCString*  CreateString(void);
+
+private:
+    // NOT TO BE IMPLEMENTED
+    //  these signatures help clients not accidentally call the wrong thing helped by C++ automatic integral promotion
+  void operator=( PRUnichar );
+  void AssignWithConversion( char );
+  void AssignWithConversion( const char*, PRInt32=-1 );
+  void AppendWithConversion( char );
+  void InsertWithConversion( char, PRUint32 );
+};
+
+// NS_DEF_STRING_COMPARISON_OPERATORS(nsCString, char)
+NS_DEF_DERIVED_STRING_OPERATOR_PLUS(nsCString, char)
+
+extern NS_COM int fputs(const nsCString& aString, FILE* out);
+//ostream& operator<<(ostream& aStream,const nsCString& aString);
+//virtual void  DebugDump(ostream& aStream) const;
+
+
+/**************************************************************
+  Here comes the AutoString class which uses internal memory
+  (typically found on the stack) for its default buffer.
+  If the buffer needs to grow, it gets reallocated on the heap.
+ **************************************************************/
+
+class NS_COM nsCAutoString : public nsCString {
+public: 
+
+    virtual ~nsCAutoString();
+
+    nsCAutoString();
+    explicit nsCAutoString(const nsCString& );
+    explicit nsCAutoString(const nsAReadableCString& aString);
+    explicit nsCAutoString(const char* aString);
+    nsCAutoString(const char* aString,PRInt32 aLength);
+    explicit nsCAutoString(const CBufDescriptor& aBuffer);
+
+#if defined(AIX) || defined(XP_OS2_VACPP)
+    explicit nsCAutoString(const nsSubsumeCStr& aSubsumeStr);  // AIX and VAC++ require a const
+#else
+    explicit nsCAutoString(nsSubsumeCStr& aSubsumeStr);
+#endif // AIX || XP_OS2_VACPP
+
+
+    nsCAutoString& operator=( const nsCAutoString& aString )              { Assign(aString); return *this; }
+  private:
+    void operator=( PRUnichar ); // NOT TO BE IMPLEMENTED
+  public:
+    nsCAutoString& operator=( const nsAReadableCString& aReadable )       { Assign(aReadable); return *this; }
+    nsCAutoString& operator=( const nsPromiseReadable<char>& aReadable )  { Assign(aReadable); return *this; }
+    nsCAutoString& operator=( const char* aPtr )                          { Assign(aPtr); return *this; }
+    nsCAutoString& operator=( char aChar )                                { Assign(aChar); return *this; }
+
+    /**
+     * Retrieve the size of this string
+     * @return string length
+     */
+    virtual void SizeOf(nsISizeOfHandler* aHandler, PRUint32* aResult) const;
+    
+    char mBuffer[kDefaultStringSize];
+};
+
+NS_DEF_DERIVED_STRING_OPERATOR_PLUS(nsCAutoString, char)
+
+/**
+ * A helper class that converts a UCS2 string to UTF8
+ */
+class NS_COM NS_ConvertUCS2toUTF8
+      : public nsCAutoString
+    /*
+      ...
+    */
+  {
+    public:
+      explicit
+      NS_ConvertUCS2toUTF8( const PRUnichar* aString )
+        {
+          Append( aString, ~PRUint32(0) /* MAXINT */);
+        }
+
+      NS_ConvertUCS2toUTF8( const PRUnichar* aString, PRUint32 aLength )
+        {
+          Append( aString, aLength );
+        }
+
+      explicit
+      NS_ConvertUCS2toUTF8( PRUnichar aChar )
+        {
+          Append( &aChar, 1 );
+        }
+
+      explicit NS_ConvertUCS2toUTF8( const nsAReadableString& aString );
+
+      const char* get() const
+        {
+          return mStr;
+        }
+
+      operator const char*() const  // to be deprecated, prefer |get()|
+        {
+          return get();
+        }
+
+    protected:
+      void Append( const PRUnichar* aString, PRUint32 aLength );
+
+    private:
+        // NOT TO BE IMPLEMENTED
+      NS_ConvertUCS2toUTF8( char );
+  };
+
+
+/***************************************************************
+  The subsumestr class is very unusual. 
+  It differs from a normal string in that it doesn't use normal
+  copy semantics when another string is assign to this. 
+  Instead, it "steals" the contents of the source string.
+
+  This is very handy for returning nsString classes as part of
+  an operator+(...) for example, in that it cuts down the number
+  of copy operations that must occur. 
+
+  You should probably not use this class unless you really know
+  what you're doing.
+ ***************************************************************/
+class NS_COM nsSubsumeCStr : public nsCString {
+public:
+  explicit nsSubsumeCStr(nsStr& aString);
+  nsSubsumeCStr(PRUnichar* aString,PRBool assumeOwnership,PRInt32 aLength=-1);
+  nsSubsumeCStr(char* aString,PRBool assumeOwnership,PRInt32 aLength=-1);
+
+  nsSubsumeCStr& operator=( const nsSubsumeCStr& aString )              { Assign(aString); return *this; }
+  nsSubsumeCStr& operator=( const nsAReadableCString& aReadable )       { Assign(aReadable); return *this; }
+  nsSubsumeCStr& operator=( const nsPromiseReadable<char>& aReadable )  { Assign(aReadable); return *this; }
+  nsSubsumeCStr& operator=( const char* aPtr )                          { Assign(aPtr); return *this; }
+  nsSubsumeCStr& operator=( char aChar )                                { Assign(aChar); return *this; }
+private:
+  void operator=( PRUnichar ); // NOT TO BE IMPLEMENTED
+};
+
+
+#endif
+
+

mozilla/string/obsolete/nsString2.h

@@ -0,0 +1,743 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ *   Rick Gessner <rickg@netscape.com> (original author)
+ *   Scott Collins <scc@mozilla.org>
+ */
+
+
+
+/***********************************************************************
+  MODULE NOTES:
+
+  See nsStr.h for a more general description of string classes.
+
+  This version of the nsString class offers many improvements over the
+  original version:
+    1. Wide and narrow chars
+    2. Allocators
+    3. Much smarter autostrings
+    4. Subsumable strings
+ ***********************************************************************/
+
+#ifndef _nsString_
+#define _nsString_
+
+#include "prtypes.h"
+#include "nscore.h"
+#include <stdio.h>
+#include "nsString.h"
+#include "nsIAtom.h"
+#include "nsStr.h"
+#include "nsCRT.h"
+
+#include "nsAWritableString.h"
+
+#ifdef STANDALONE_MI_STRING_TESTS
+  class nsAReadableString { public: virtual ~nsAReadableString() { } };
+  class nsAWritableString : public nsAReadableString { public: virtual ~nsAWritableString() { } };
+#endif
+
+class nsISizeOfHandler;
+
+
+#define nsString2     nsString
+#define nsAutoString2 nsAutoString
+
+class NS_COM nsSubsumeStr;
+
+class NS_COM nsString :
+  public nsAWritableString,
+  public nsStr {
+
+protected:
+  virtual const void* Implementation() const { return "nsString"; }
+  virtual const PRUnichar* GetReadableFragment( nsReadableFragment<PRUnichar>&, nsFragmentRequest, PRUint32 ) const;
+  virtual PRUnichar* GetWritableFragment( nsWritableFragment<PRUnichar>&, nsFragmentRequest, PRUint32 );
+
+
+public:
+  /**
+   * Default constructor. 
+   */
+  nsString();
+
+  /**
+   * This is our copy constructor 
+   * @param   reference to another nsString
+   */
+  nsString(const nsString& aString);   
+
+  explicit nsString(const nsAReadableString&);
+
+  explicit nsString(const PRUnichar*);
+  nsString(const PRUnichar*, PRInt32);
+
+
+  /**
+   * This constructor takes a subsumestr
+   * @param   reference to subsumestr
+   */
+#if defined(AIX) || defined(XP_OS2_VACPP)
+  explicit nsString(const nsSubsumeStr& aSubsumeStr);   // AIX and VAC++ require a const here
+#else
+  explicit nsString(nsSubsumeStr& aSubsumeStr);   
+#endif
+
+  /**
+   * Destructor
+   * 
+   */
+  virtual ~nsString();    
+
+  /**
+   * Retrieve the length of this string
+   * @return string length
+   */
+  virtual PRUint32 Length() const { return mLength; }
+
+  /**
+   * Retrieve the size of this string
+   * @return string length
+   */
+  virtual void SizeOf(nsISizeOfHandler* aHandler, PRUint32* aResult) const;
+
+
+  /**
+   * Call this method if you want to force a different string length
+   * @update  gess7/30/98
+   * @param   aLength -- contains new length for mStr
+   * @return
+   */
+  void SetLength(PRUint32 aLength);
+
+  /**
+   * Sets the new length of the string.
+   * @param   aLength is new string length.
+   * @return  nada
+   */
+  void SetCapacity(PRUint32 aLength);
+
+
+  /**
+   * This method truncates this string to given length.
+   *
+   * @param   anIndex -- new length of string
+   * @return  nada
+   */
+  void Truncate(PRUint32 anIndex=0) {
+    NS_ASSERTION(anIndex<=mLength, "Can't use |Truncate()| to make a string longer.");
+    if ( anIndex < mLength )
+      SetLength(anIndex);
+  }
+
+
+  /**
+   *  Determine whether or not the characters in this
+   *  string are in store as 1 or 2 byte (unicode) strings.
+   *  
+   *  @return  TRUE if ordered.
+   */
+  PRBool IsUnicode(void) const {
+    PRBool result=PRBool(mCharSize==eTwoByte);
+    return result;
+  }
+
+  /**********************************************************************
+    Getters/Setters...
+   *********************************************************************/
+
+   /**
+     * Retrieve const ptr to internal buffer; DO NOT TRY TO FREE IT!
+     */
+  const char* GetBuffer(void) const;
+  const PRUnichar* GetUnicode(void) const;
+
+   /**
+     * Set nth character.
+     */
+  PRBool SetCharAt(PRUnichar aChar,PRUint32 anIndex);
+
+
+
+  /**********************************************************************
+    Lexomorphic transforms...
+   *********************************************************************/
+
+
+  /**
+   * Converts chars in this to lowercase
+   * @update  gess 7/27/98
+   */
+  void ToLowerCase();
+
+
+  /**
+   * Converts chars in this to lowercase, and
+   * stores them in aOut
+   * @update  gess 7/27/98
+   * @param   aOut is a string to contain result
+   */
+  void ToLowerCase(nsString& aString) const;
+
+  /**
+   * Converts chars in this to uppercase
+   * @update  gess 7/27/98
+   */
+  void ToUpperCase();
+
+  /**
+   * Converts chars in this to lowercase, and
+   * stores them in a given output string
+   * @update  gess 7/27/98
+   * @param   aOut is a string to contain result
+   */
+  void ToUpperCase(nsString& aString) const;
+
+
+  /**
+   *  This method is used to remove all occurances of the
+   *  characters found in aSet from this string.
+   *  
+   *  @param  aSet -- characters to be cut from this
+   *  @return *this 
+   */
+  void StripChars( const char* aSet );
+  void StripChar( PRUnichar aChar, PRInt32 anOffset=0 );
+  void StripChar( char aChar, PRInt32 anOffset=0 )       { StripChar((PRUnichar) (unsigned char)aChar,anOffset); }
+  void StripChar( PRInt32 anInt, PRInt32 anOffset=0 )    { StripChar((PRUnichar)anInt,anOffset); }
+
+  /**
+   *  This method strips whitespace throughout the string
+   *  
+   *  @return  this
+   */
+  void StripWhitespace();
+
+  /**
+   *  swaps occurence of 1 string for another
+   *  
+   *  @return  this
+   */
+  void ReplaceChar( PRUnichar anOldChar, PRUnichar aNewChar );
+  void ReplaceChar( const char* aSet, PRUnichar aNewChar );
+
+  void ReplaceSubstring( const nsString& aTarget, const nsString& aNewValue );
+  void ReplaceSubstring( const PRUnichar* aTarget, const PRUnichar* aNewValue );
+
+  PRInt32 CountChar( PRUnichar aChar );
+
+  /**
+   *  This method trims characters found in aTrimSet from
+   *  either end of the underlying string.
+   *  
+   *  @param   aTrimSet -- contains chars to be trimmed from
+   *           both ends
+   *  @param   aEliminateLeading
+   *  @param   aEliminateTrailing
+   *  @param   aIgnoreQuotes
+   *  @return  this
+   */
+  void Trim(const char* aSet,PRBool aEliminateLeading=PR_TRUE,PRBool aEliminateTrailing=PR_TRUE,PRBool aIgnoreQuotes=PR_FALSE);
+
+  /**
+   *  This method strips whitespace from string.
+   *  You can control whether whitespace is yanked from
+   *  start and end of string as well.
+   *  
+   *  @param   aEliminateLeading controls stripping of leading ws
+   *  @param   aEliminateTrailing controls stripping of trailing ws
+   *  @return  this
+   */
+  void CompressSet(const char* aSet, PRUnichar aChar,PRBool aEliminateLeading=PR_TRUE,PRBool aEliminateTrailing=PR_TRUE);
+
+  /**
+   *  This method strips whitespace from string.
+   *  You can control whether whitespace is yanked from
+   *  start and end of string as well.
+   *  
+   *  @param   aEliminateLeading controls stripping of leading ws
+   *  @param   aEliminateTrailing controls stripping of trailing ws
+   *  @return  this
+   */
+  void CompressWhitespace( PRBool aEliminateLeading=PR_TRUE,PRBool aEliminateTrailing=PR_TRUE);
+
+  /**********************************************************************
+    string conversion methods...
+   *********************************************************************/
+
+  /**
+   * This method constructs a new nsString is a clone of this string.
+   * 
+   */
+  nsString* ToNewString() const;
+
+  /**
+   * Creates an ISOLatin1 clone of this string
+   * Note that calls to this method should be matched with calls to Recycle().
+   * @return  ptr to new isolatin1 string
+   */
+  char* ToNewCString() const;
+
+  /**
+   * Creates an UTF8 clone of this string
+   * Note that calls to this method should be matched with calls to Recycle().
+   * @return  ptr to new null-terminated UTF8 string
+   */
+  char* ToNewUTF8String() const;
+
+  /**
+   * Creates a unicode clone of this string
+   * Note that calls to this method should be matched with calls to Recycle().
+   * @return  ptr to new unicode string
+   */
+  PRUnichar* ToNewUnicode() const;
+
+  /**
+   * Copies data from internal buffer onto given char* buffer
+   * NOTE: This only copies as many chars as will fit in given buffer (clips)
+   * @param aBuf is the buffer where data is stored
+   * @param aBuflength is the max # of chars to move to buffer
+   * @return ptr to given buffer
+   */
+  char* ToCString(char* aBuf,PRUint32 aBufLength,PRUint32 anOffset=0) const;
+
+  /**
+   * Perform string to float conversion.
+   * @param   aErrorCode will contain error if one occurs
+   * @return  float rep of string value
+   */
+  float ToFloat(PRInt32* aErrorCode) const;
+
+  /**
+   * Perform string to int conversion.
+   * @param   aErrorCode will contain error if one occurs
+   * @param   aRadix tells us which radix to assume; kAutoDetect tells us to determine the radix for you.
+   * @return  int rep of string value, and possible (out) error code
+   */
+  PRInt32   ToInteger(PRInt32* aErrorCode,PRUint32 aRadix=kRadix10) const;
+
+
+  /**********************************************************************
+    String manipulation methods...                
+   *********************************************************************/
+
+  /**
+   * assign given string to this string
+   * @param   aStr: buffer to be assigned to this 
+   * @param   aCount is the length of the given str (or -1) if you want me to determine its length
+   *  NOTE:   IFF you pass -1 as aCount, then your buffer must be null terminated.
+
+   * @return  this
+   */
+
+  nsString& operator=( const nsString& aString )                              { Assign(aString); return *this; }
+  nsString& operator=( const nsAReadableString& aReadable )                   { Assign(aReadable); return *this; }
+  nsString& operator=( const nsPromiseReadable<PRUnichar>& aReadable )        { Assign(aReadable); return *this; }
+  nsString& operator=( const PRUnichar* aPtr )                                { Assign(aPtr); return *this; }
+  nsString& operator=( PRUnichar aChar )                                      { Assign(aChar); return *this; }
+
+  void AssignWithConversion(char);
+  void AssignWithConversion(const char*);
+  void AssignWithConversion(const char*, PRInt32);
+
+
+  /*
+   *  Appends n characters from given string to this,
+   *  This version computes the length of your given string
+   *  
+   *  @param   aString is the source to be appended to this
+   *  @return  number of chars copied
+   */
+
+  void AppendInt(PRInt32, PRInt32=10); //radix=8,10 or 16
+  void AppendFloat(double);
+  void AppendWithConversion(const char*, PRInt32=-1);
+  void AppendWithConversion(char);
+
+  virtual void do_AppendFromElement( PRUnichar );
+
+             
+  /*
+   *  Copies n characters from this string to given string,
+   *  starting at the leftmost offset.
+   *  
+   *  
+   *  @param   aCopy -- Receiving string
+   *  @param   aCount -- number of chars to copy
+   *  @return  number of chars copied
+   */
+  PRUint32 Left(nsString& aCopy,PRInt32 aCount) const;
+
+  /*
+   *  Copies n characters from this string to given string,
+   *  starting at the given offset.
+   *  
+   *  
+   *  @param   aCopy -- Receiving string
+   *  @param   aCount -- number of chars to copy
+   *  @param   anOffset -- position where copying begins
+   *  @return  number of chars copied
+   */
+  PRUint32 Mid(nsString& aCopy,PRUint32 anOffset,PRInt32 aCount) const;
+
+  /*
+   *  Copies n characters from this string to given string,
+   *  starting at rightmost char.
+   *  
+   *  
+   *  @param  aCopy -- Receiving string
+   *  @param  aCount -- number of chars to copy
+   *  @return number of chars copied
+   */
+  PRUint32 Right(nsString& aCopy,PRInt32 aCount) const;
+
+
+//void InsertWithConversion(char);
+  void InsertWithConversion(const char*, PRUint32, PRInt32=-1);
+
+
+  /**********************************************************************
+    Searching methods...                
+   *********************************************************************/
+ 
+  /**
+   *  Search for given substring within this string
+   *  
+   *  @param   aString is substring to be sought in this
+   *  @param   aIgnoreCase selects case sensitivity
+   *  @param   anOffset tells us where in this strig to start searching
+   *  @param   aCount tells us how many iterations to make starting at the given offset
+   *  @return  offset in string, or -1 (kNotFound)
+   */
+  PRInt32 Find(const nsString& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=0,PRInt32 aCount=-1) const;
+  PRInt32 Find(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=0,PRInt32 aCount=-1) const;
+  PRInt32 Find(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=0,PRInt32 aCount=-1) const;
+  PRInt32 Find(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=0,PRInt32 aCount=-1) const;
+
+
+  /**
+   *  Search for given char within this string
+   *  
+   *  @param   aString is substring to be sought in this
+   *  @param   anOffset tells us where in this strig to start searching
+   *  @param   aIgnoreCase selects case sensitivity
+   *  @param   aCount tells us how many iterations to make starting at the given offset
+   *  @return  find pos in string, or -1 (kNotFound)
+   */
+  //PRInt32 Find(PRUnichar aChar,PRInt32 offset=-1,PRBool aIgnoreCase=PR_FALSE) const;
+  PRInt32 FindChar(PRUnichar aChar,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=0,PRInt32 aCount=-1) const;
+
+  /**
+   * This method searches this string for the first character
+   * found in the given charset
+   * @param aString contains set of chars to be found
+   * @param anOffset tells us where to start searching in this
+   * @return -1 if not found, else the offset in this
+   */
+  PRInt32 FindCharInSet(const char* aString,PRInt32 anOffset=0) const;
+  PRInt32 FindCharInSet(const PRUnichar* aString,PRInt32 anOffset=0) const;
+  PRInt32 FindCharInSet(const nsStr& aString,PRInt32 anOffset=0) const;
+
+
+  /**
+   * This methods scans the string backwards, looking for the given string
+   * @param   aString is substring to be sought in this
+   * @param   aIgnoreCase tells us whether or not to do caseless compare
+   * @param   anOffset tells us where in this strig to start searching (counting from left)
+   * @param   aCount tells us how many iterations to make starting at the given offset
+   * @return  offset in string, or -1 (kNotFound)
+   */
+  PRInt32 RFind(const char* aCString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1,PRInt32 aCount=-1) const;
+  PRInt32 RFind(const nsString& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1,PRInt32 aCount=-1) const;
+  PRInt32 RFind(const nsStr& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1,PRInt32 aCount=-1) const;
+  PRInt32 RFind(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1,PRInt32 aCount=-1) const;
+
+
+  /**
+   *  Search for given char within this string
+   *  
+   *  @param   aString is substring to be sought in this
+   *  @param   anOffset tells us where in this strig to start searching (counting from left)
+   *  @param   aIgnoreCase selects case sensitivity
+   *  @param   aCount tells us how many iterations to make starting at the given offset
+   *  @return  find pos in string, or -1 (kNotFound)
+   */
+  //PRInt32 RFind(PRUnichar aChar,PRInt32 offset=-1,PRBool aIgnoreCase=PR_FALSE) const;
+  PRInt32 RFindChar(PRUnichar aChar,PRBool aIgnoreCase=PR_FALSE,PRInt32 anOffset=-1,PRInt32 aCount=-1) const;
+
+  /**
+   * This method searches this string for the last character
+   * found in the given string
+   * @param aString contains set of chars to be found
+   *  @param   anOffset tells us where in this strig to start searching (counting from left)
+   * @return -1 if not found, else the offset in this
+   */
+  PRInt32 RFindCharInSet(const char* aString,PRInt32 anOffset=-1) const;
+  PRInt32 RFindCharInSet(const PRUnichar* aString,PRInt32 anOffset=-1) const;
+  PRInt32 RFindCharInSet(const nsStr& aString,PRInt32 anOffset=-1) const;
+
+
+  /**********************************************************************
+    Comparison methods...                
+   *********************************************************************/
+
+  /**
+   * Compares a given string type to this string. 
+   * @update  gess 7/27/98
+   * @param   S is the string to be compared
+   * @param   aIgnoreCase tells us how to treat case
+   * @param   aCount tells us how many chars to compare
+   * @return  -1,0,1
+   */
+
+  PRInt32 CompareWithConversion(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
+  PRInt32 CompareWithConversion(const nsString& aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
+  PRInt32 CompareWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
+
+  PRBool  EqualsWithConversion(const nsString &aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
+  PRBool  EqualsWithConversion(const char* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
+  PRBool  EqualsWithConversion(const PRUnichar* aString,PRBool aIgnoreCase=PR_FALSE,PRInt32 aCount=-1) const;
+  PRBool  EqualsAtom(/*FIX: const */nsIAtom* anAtom,PRBool aIgnoreCase) const;   
+
+  PRBool  EqualsIgnoreCase(const nsString& aString) const;
+  PRBool  EqualsIgnoreCase(const char* aString,PRInt32 aCount=-1) const;
+  PRBool  EqualsIgnoreCase(/*FIX: const */nsIAtom *aAtom) const;
+
+
+  /**
+   *  Determine if given buffer is plain ascii
+   *  
+   *  @param   aBuffer -- if null, then we test *this, otherwise we test given buffer
+   *  @return  TRUE if is all ascii chars or if strlen==0
+   */
+  PRBool IsASCII(const PRUnichar* aBuffer=0);
+
+  void    DebugDump(void) const;
+
+  /**
+   *  Determine if given char is a valid space character
+   *  
+   *  @param   aChar is character to be tested
+   *  @return  TRUE if is valid space char
+   */
+  static  PRBool IsSpace(PRUnichar ch);
+
+  /**
+   *  Determine if given char in valid alpha range
+   *  
+   *  @param   aChar is character to be tested
+   *  @return  TRUE if in alpha range
+   */
+  static  PRBool IsAlpha(PRUnichar ch);
+
+  /**
+   *  Determine if given char is valid digit
+   *  
+   *  @param   aChar is character to be tested
+   *  @return  TRUE if char is a valid digit
+   */
+  static  PRBool IsDigit(PRUnichar ch);
+
+  static  void        Recycle(nsString* aString);
+  static  nsString*  CreateString(void);
+
+private:
+    // NOT TO BE IMPLEMENTED
+    //  these signatures help clients not accidentally call the wrong thing helped by C++ automatic integral promotion
+  void operator=( char );
+  void AssignWithConversion( PRUnichar );
+  void AssignWithConversion( const PRUnichar*, PRInt32=-1 );
+  void AppendWithConversion( PRUnichar );
+  void AppendWithConversion( const PRUnichar*, PRInt32=-1 );
+  void InsertWithConversion( const PRUnichar*, PRUint32, PRInt32=-1 );
+};
+
+// NS_DEF_STRING_COMPARISON_OPERATORS(nsString, PRUnichar)
+NS_DEF_DERIVED_STRING_OPERATOR_PLUS(nsString, PRUnichar)
+
+extern NS_COM int fputs(const nsString& aString, FILE* out);
+//ostream& operator<<(ostream& aStream,const nsString& aString);
+//virtual void  DebugDump(ostream& aStream) const;
+
+/**************************************************************
+  Here comes the AutoString class which uses internal memory
+  (typically found on the stack) for its default buffer.
+  If the buffer needs to grow, it gets reallocated on the heap.
+ **************************************************************/
+
+class NS_COM nsAutoString : public nsString {
+public: 
+
+    virtual ~nsAutoString();
+    nsAutoString();
+    nsAutoString(const nsAutoString& aString);
+    explicit nsAutoString(const nsAReadableString& aString);
+    explicit nsAutoString(const nsString& aString);
+    explicit nsAutoString(const PRUnichar* aString);
+    nsAutoString(const PRUnichar* aString,PRInt32 aLength);
+    explicit nsAutoString(PRUnichar aChar);
+    explicit nsAutoString(const CBufDescriptor& aBuffer);    
+
+#if defined(AIX) || defined(XP_OS2_VACPP)
+    explicit nsAutoString(const nsSubsumeStr& aSubsumeStr);  // AIX and VAC++ requires a const
+#else
+    explicit nsAutoString(nsSubsumeStr& aSubsumeStr);
+#endif // AIX || XP_OS2_VACPP
+
+
+    nsAutoString& operator=( const nsAutoString& aString )                          { Assign(aString); return *this; }
+  private:
+    void operator=( char ); // NOT TO BE IMPLEMENTED
+  public:
+    nsAutoString& operator=( const nsAReadableString& aReadable )                   { Assign(aReadable); return *this; }
+    nsAutoString& operator=( const nsPromiseReadable<PRUnichar>& aReadable )        { Assign(aReadable); return *this; }
+    nsAutoString& operator=( const PRUnichar* aPtr )                                { Assign(aPtr); return *this; }
+    nsAutoString& operator=( PRUnichar aChar )                                      { Assign(aChar); return *this; }
+
+    /**
+     * Retrieve the size of this string
+     * @return string length
+     */
+    virtual void SizeOf(nsISizeOfHandler* aHandler, PRUint32* aResult) const;
+    
+    char mBuffer[kDefaultStringSize<<eTwoByte];
+};
+
+NS_DEF_DERIVED_STRING_OPERATOR_PLUS(nsAutoString, PRUnichar)
+
+class NS_COM NS_ConvertASCIItoUCS2
+      : public nsAutoString
+    /*
+      ...
+    */
+  {
+    public:
+      explicit NS_ConvertASCIItoUCS2( const char* );
+      NS_ConvertASCIItoUCS2( const char*, PRUint32 );
+      explicit NS_ConvertASCIItoUCS2( char );
+
+      const PRUnichar* get() const { return GetUnicode(); }
+
+      operator const PRUnichar*() const
+        {
+          return GetUnicode();
+        }
+
+      operator nsLiteralString() const
+        {
+          return nsLiteralString(mUStr, mLength);
+        }
+
+    private:
+        // NOT TO BE IMPLEMENTED
+      NS_ConvertASCIItoUCS2( PRUnichar );
+  };
+
+#define NS_ConvertToString NS_ConvertASCIItoUCS2
+
+#if 0
+inline
+nsAutoString
+NS_ConvertToString( const char* aCString )
+  {
+    nsAutoString result;
+    result.AssignWithConversion(aCString);
+    return result;
+  }
+
+inline
+nsAutoString
+NS_ConvertToString( const char* aCString, PRUint32 aLength )
+  {
+    nsAutoString result;
+    result.AssignWithConversion(aCString, aLength);
+    return result;
+  }
+#endif
+
+
+class NS_COM NS_ConvertUTF8toUCS2
+      : public nsAutoString
+  {
+    public:
+      explicit
+      NS_ConvertUTF8toUCS2( const char* aCString )
+        {
+          Init( aCString, ~PRUint32(0) /* MAXINT */ );
+        }
+
+      NS_ConvertUTF8toUCS2( const char* aCString, PRUint32 aLength )
+        {
+          Init( aCString, aLength );
+        }
+
+      explicit
+      NS_ConvertUTF8toUCS2( char aChar )
+        {
+          Init( &aChar, 1 );
+        }
+
+      operator const PRUnichar*() const
+        {
+          return GetUnicode();
+        }
+
+    protected:
+      void Init( const char* aCString, PRUint32 aLength );
+
+    private:
+      NS_ConvertUTF8toUCS2( PRUnichar );
+  };
+
+/***************************************************************
+  The subsumestr class is very unusual. 
+  It differs from a normal string in that it doesn't use normal
+  copy semantics when another string is assign to this. 
+  Instead, it "steals" the contents of the source string.
+
+  This is very handy for returning nsString classes as part of
+  an operator+(...) for example, in that it cuts down the number
+  of copy operations that must occur. 
+
+  You should probably not use this class unless you really know
+  what you're doing.
+ ***************************************************************/
+class NS_COM nsSubsumeStr : public nsString {
+public:
+  nsSubsumeStr();
+  explicit nsSubsumeStr(nsStr& aString);
+  nsSubsumeStr(PRUnichar* aString,PRBool assumeOwnership,PRInt32 aLength=-1);
+  nsSubsumeStr(char* aString,PRBool assumeOwnership,PRInt32 aLength=-1);
+  int Subsume(PRUnichar* aString,PRBool assumeOwnership,PRInt32 aLength=-1);
+
+  nsSubsumeStr& operator=( const nsSubsumeStr& aReadable )                        { Assign(aReadable); return *this; }
+  nsSubsumeStr& operator=( const nsAReadableString& aReadable )                   { Assign(aReadable); return *this; }
+  nsSubsumeStr& operator=( const nsPromiseReadable<PRUnichar>& aReadable )        { Assign(aReadable); return *this; }
+  nsSubsumeStr& operator=( const PRUnichar* aPtr )                                { Assign(aPtr); return *this; }
+  nsSubsumeStr& operator=( PRUnichar aChar )                                      { Assign(aChar); return *this; }
+private:
+  void operator=( char ); // NOT TO BE IMPLEMENTED
+};
+
+
+#endif
+
+

mozilla/string/obsolete/nsXPIDLString.cpp

@@ -0,0 +1,163 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+#include "nsDebug.h"
+#include "nsMemory.h"
+#include "nsXPIDLString.h"
+#include "plstr.h"
+
+// If the allocator changes, fix it here.
+#define XPIDL_STRING_ALLOC(__len)  ((PRUnichar*) nsMemory::Alloc((__len) * sizeof(PRUnichar)))
+#define XPIDL_CSTRING_ALLOC(__len) ((char*) nsMemory::Alloc((__len) * sizeof(char)))
+#define XPIDL_FREE(__ptr)          (nsMemory::Free(__ptr))
+
+////////////////////////////////////////////////////////////////////////
+// nsXPIDLString
+
+nsXPIDLString::~nsXPIDLString()
+{
+    if (mBufOwner && mBuf)
+        XPIDL_FREE(mBuf);
+}
+
+
+PRUnichar*
+nsXPIDLString::Copy(const PRUnichar* aString)
+{
+    NS_ASSERTION(aString, "null ptr");
+    if (! aString)
+        return 0;
+
+    PRInt32 len = 0;
+
+    {
+        const PRUnichar* p = aString;
+        while (*p++)
+            len++;
+    }
+
+    PRUnichar* result = XPIDL_STRING_ALLOC(len + 1);
+    if (result) {
+        PRUnichar* q = result;
+        while (*aString) {
+            *q = *aString;
+            q++;
+            aString++;
+        }
+        *q = '\0';
+    }
+    return result;
+}
+
+
+PRUnichar**
+nsXPIDLString::StartAssignmentByValue()
+{
+    if (mBufOwner && mBuf)
+        XPIDL_FREE(mBuf);
+
+    mBuf = 0;
+    mBufOwner = PR_TRUE;
+    return &mBuf;
+}
+
+
+const PRUnichar**
+nsXPIDLString::StartAssignmentByReference()
+{
+    if (mBufOwner && mBuf)
+        XPIDL_FREE(mBuf);
+
+    mBuf = 0;
+    mBufOwner = PR_FALSE;
+    return (const PRUnichar**) &mBuf;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// nsXPIDLCString
+
+nsXPIDLCString::~nsXPIDLCString()
+{
+    if (mBufOwner && mBuf)
+        XPIDL_FREE(mBuf);
+}
+
+
+nsXPIDLCString& nsXPIDLCString::operator =(const char* aCString)
+{
+    if (mBufOwner && mBuf)
+        XPIDL_FREE(mBuf);
+	
+    if (aCString) {
+        mBuf = Copy(aCString);
+        mBufOwner = PR_TRUE;
+    }
+    else {
+        mBuf = 0;
+        mBufOwner = PR_FALSE;
+    }
+    
+    return *this;
+}
+
+
+char*
+nsXPIDLCString::Copy(const char* aCString)
+{
+    NS_ASSERTION(aCString, "null ptr");
+    if (! aCString)
+        return 0;
+
+    PRInt32 len = PL_strlen(aCString);
+    char* result = XPIDL_CSTRING_ALLOC(len + 1);
+    if (result)
+        PL_strcpy(result, aCString);
+
+    return result;
+}
+
+
+char**
+nsXPIDLCString::StartAssignmentByValue()
+{
+    if (mBufOwner && mBuf)
+        XPIDL_FREE(mBuf);
+
+    mBuf = 0;
+    mBufOwner = PR_TRUE;
+    return &mBuf;
+}
+
+
+const char**
+nsXPIDLCString::StartAssignmentByReference()
+{
+    if (mBufOwner && mBuf)
+        XPIDL_FREE(mBuf);
+
+    mBuf = 0;
+    mBufOwner = PR_FALSE;
+    return (const char**) &mBuf;
+}
+
+

mozilla/string/obsolete/nsXPIDLString.h

@@ -0,0 +1,382 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+
+/*
+
+  A set of string wrapper classes that ease transition to use of XPIDL
+  interfaces. nsXPIDLString and nsXPIDLCString are to XPIDL `wstring'
+  and `string' out params as nsCOMPtr is to generic XPCOM interface
+  pointers. They help you deal with object ownership.
+
+  Consider the following interface:
+
+    interface nsIFoo {
+      attribute string Bar;
+    };
+
+  This will generate the following C++ header file:
+
+    class nsIFoo {
+      NS_IMETHOD SetBar(const PRUnichar* aValue);
+      NS_IMETHOD GetBar(PRUnichar* *aValue);
+    };
+
+  The GetBar() method will allocate a copy of the nsIFoo object's
+  "bar" attribute, and leave you to deal with freeing it:
+
+    nsIFoo* aFoo; // assume we get this somehow
+    PRUnichar* bar;
+    aFoo->GetFoo(&bar);
+    // Use bar here...
+    printf("bar is %s!\n", bar);
+    nsMemory::Free(bar);
+
+  This makes your life harder, because you need to convolute your code
+  to ensure that you don't leak `bar'.
+
+  Enter nsXPIDLString, which manages the ownership of the allocated
+  string, and automatically destroys it when the nsXPIDLString goes
+  out of scope:
+
+    nsIFoo* aFoo;
+    nsXPIDLString bar;
+    aFoo->GetFoo( getter_Copies(bar) );
+    // Use bar here...
+    printf("bar is %s!\n", (const char*) bar);
+    // no need to remember to nsMemory::Free().
+
+  Like nsCOMPtr, nsXPIDLString uses some syntactic sugar to make it
+  painfully clear exactly what the code expects. You need to wrap an
+  nsXPIDLString object with either `getter_Copies()' or
+  `getter_Shares()' before passing it to a getter: these tell the
+  nsXPIDLString how ownership is being handled.
+
+  In the case of `getter_Copies()', the callee is allocating a copy
+  (which is usually the case). In the case of `getter_Shares()', the
+  callee is returning a const reference to `the real deal' (this can
+  be done using the [shared] attribute in XPIDL).
+
+ */
+
+#ifndef nsXPIDLString_h__
+#define nsXPIDLString_h__
+
+#include "nscore.h"
+#include "nsCom.h"
+#include "prtypes.h"
+
+#ifndef __PRUNICHAR__
+#define __PRUNICHAR__
+typedef PRUint16 PRUnichar;
+#endif /* __PRUNICHAR__ */
+
+////////////////////////////////////////////////////////////////////////
+// nsXPIDLString
+//
+//   A wrapper for Unicode strings. With the |getter_Copies()| and
+//   |getter_Shares()| helper functions, this can be used instead of
+//   the "naked" |PRUnichar*| interface for |wstring| parameters in
+//   XPIDL interfaces.
+//
+
+class NS_COM nsXPIDLString {
+private:
+    PRUnichar* mBuf;
+    PRBool     mBufOwner;
+
+    PRUnichar** StartAssignmentByValue();
+    const PRUnichar** StartAssignmentByReference();
+
+public:
+    /**
+     * Construct a new, uninitialized wrapper for a Unicode string.
+     */
+    nsXPIDLString() : mBuf(0), mBufOwner(PR_FALSE) {}
+
+    virtual ~nsXPIDLString();
+
+    /**
+     * Return a reference to the immutable Unicode string.
+     */
+    operator const PRUnichar*() const { return get(); }
+
+    /**
+     * Return a reference to the immutable Unicode string.
+     */
+    const PRUnichar* get() const { return mBuf; }
+
+    /**
+     * Make a copy of the Unicode string. Use this function in the
+     * callee to ensure that the correct memory allocator is used.
+     */
+    static PRUnichar* Copy(const PRUnichar* aString);
+
+    // A helper class for assignment-by-value. This class is an
+    // implementation detail and should not be considered part of the
+    // public interface.
+    class NS_COM GetterCopies {
+    private:
+        nsXPIDLString& mXPIDLString;
+
+    public:
+        GetterCopies(nsXPIDLString& aXPIDLString)
+            : mXPIDLString(aXPIDLString) {}
+
+        operator PRUnichar**() {
+            return mXPIDLString.StartAssignmentByValue();
+        }
+
+        friend GetterCopies getter_Copies(nsXPIDLString& aXPIDLString);
+    };
+
+    friend class GetterCopies;
+
+    // A helper class for assignment-by-reference. This class is an
+    // implementation detail and should not be considered part of the
+    // public interface.
+    class NS_COM GetterShares {
+    private:
+        nsXPIDLString& mXPIDLString;
+
+    public:
+        GetterShares(nsXPIDLString& aXPIDLString)
+            : mXPIDLString(aXPIDLString) {}
+
+        operator const PRUnichar**() {
+            return mXPIDLString.StartAssignmentByReference();
+        }
+
+        friend GetterShares getter_Shares(nsXPIDLString& aXPIDLString);
+    };
+
+    friend class GetterShares;
+
+private:
+    // not to be implemented
+    nsXPIDLString(nsXPIDLString& /* aXPIDLString */) {}
+    void operator=(nsXPIDLString& /* aXPIDLString */) {}
+};
+
+
+/**
+ * Use this function to "wrap" the nsXPIDLString object that is to
+ * receive an |out| value.
+ */
+inline nsXPIDLString::GetterCopies
+getter_Copies(nsXPIDLString& aXPIDLString)
+{
+    return nsXPIDLString::GetterCopies(aXPIDLString);
+}
+
+/**
+ * Use this function to "wrap" the nsXPIDLString object that is to
+ * receive a |[shared] out| value.
+ */
+inline nsXPIDLString::GetterShares
+getter_Shares(nsXPIDLString& aXPIDLString)
+{
+    return nsXPIDLString::GetterShares(aXPIDLString);
+}
+
+
+// XXX THESE ARE NOT strcmp()! DON'T TRY TO USE THEM AS SUCH!
+inline
+PRBool
+operator==(const PRUnichar* lhs, const nsXPIDLString& rhs)
+{
+    return lhs == NS_STATIC_CAST(const PRUnichar*, rhs);
+}
+
+inline
+PRBool
+operator==(const nsXPIDLString& lhs, const PRUnichar* rhs)
+{
+    return NS_STATIC_CAST(const PRUnichar*, lhs) == rhs;
+}
+
+
+#ifdef HAVE_CPP_TROUBLE_COMPARING_TO_ZERO
+
+inline
+PRBool
+operator==(int lhs, const nsXPIDLString& rhs)
+{
+    return NS_REINTERPRET_CAST(PRUnichar*, lhs) == NS_STATIC_CAST(const PRUnichar*, rhs);
+}
+
+inline
+PRBool
+operator==(const nsXPIDLString& lhs, int rhs)
+{
+    return NS_STATIC_CAST(const PRUnichar*, lhs) == NS_REINTERPRET_CAST(PRUnichar*, rhs);
+}
+
+#endif
+
+////////////////////////////////////////////////////////////////////////
+// nsXPIDLCString
+//
+//   A wrapper for Unicode strings. With the |getter_Copies()| and
+//   |getter_Shares()| helper functions, this can be used instead of
+//   the "naked" |char*| interface for |string| parameters in XPIDL
+//   interfaces.
+//
+
+class NS_COM nsXPIDLCString {
+private:
+    char*  mBuf;
+    PRBool mBufOwner;
+
+    char** StartAssignmentByValue();
+    const char** StartAssignmentByReference();
+
+public:
+    /**
+     * Construct a new, uninitialized wrapper for a single-byte string.
+     */
+    nsXPIDLCString() : mBuf(0), mBufOwner(PR_FALSE) {}
+
+    virtual ~nsXPIDLCString();
+
+    /**
+     * Assign a single-byte string to this wrapper. Copies
+     * and owns the result.
+     */
+    nsXPIDLCString& operator=(const char* aString);
+
+    /**
+     * Return a reference to the immutable single-byte string.
+     */
+    operator const char*() const { return get(); }
+
+    /**
+     * Return a reference to the immutable single-byte string.
+     */
+    const char* get() const { return mBuf; }
+
+    /**
+     * Make a copy of the single-byte string. Use this function in the
+     * callee to ensure that the correct memory allocator is used.
+     */
+    static char* Copy(const char* aString);
+
+    // A helper class for assignment-by-value. This class is an
+    // implementation detail and should not be considered part of the
+    // public interface.
+    class NS_COM GetterCopies {
+    private:
+        nsXPIDLCString& mXPIDLString;
+
+    public:
+        GetterCopies(nsXPIDLCString& aXPIDLString)
+            : mXPIDLString(aXPIDLString) {}
+
+        operator char**() {
+            return mXPIDLString.StartAssignmentByValue();
+        }
+
+        friend GetterCopies getter_Copies(nsXPIDLCString& aXPIDLString);
+    };
+
+    friend class GetterCopies;
+
+    // A helper class for assignment-by-reference. This class is an
+    // implementation detail and should not be considered part of the
+    // public interface.
+    class NS_COM GetterShares {
+    private:
+        nsXPIDLCString& mXPIDLString;
+
+    public:
+        GetterShares(nsXPIDLCString& aXPIDLString)
+            : mXPIDLString(aXPIDLString) {}
+
+        operator const char**() {
+            return mXPIDLString.StartAssignmentByReference();
+        }
+
+        friend GetterShares getter_Shares(nsXPIDLCString& aXPIDLString);
+    };
+
+    friend class GetterShares;
+
+private:
+    // not to be implemented
+    nsXPIDLCString(nsXPIDLCString& /* aXPIDLString */) {}
+    void operator=(nsXPIDLCString& /* aXPIDLCString */) {}
+};
+
+/**
+ * Use this function to "wrap" the nsXPIDLCString object that is to
+ * receive an |out| value.
+ */
+inline nsXPIDLCString::GetterCopies
+getter_Copies(nsXPIDLCString& aXPIDLString)
+{
+    return nsXPIDLCString::GetterCopies(aXPIDLString);
+}
+
+
+/**
+ * Use this function to "wrap" the nsXPIDLCString object that is to
+ * receive a |[shared] out| value.
+ */
+inline nsXPIDLCString::GetterShares
+getter_Shares(nsXPIDLCString& aXPIDLString)
+{
+    return nsXPIDLCString::GetterShares(aXPIDLString);
+}
+
+// XXX THESE ARE NOT strcmp()! DON'T TRY TO USE THEM AS SUCH!
+inline
+PRBool
+operator==(const char* lhs, const nsXPIDLCString& rhs)
+{
+    return lhs == NS_STATIC_CAST(const char*, rhs);
+}
+
+inline
+PRBool
+operator==(const nsXPIDLCString& lhs, const char* rhs)
+{
+    return NS_STATIC_CAST(const char*, lhs) == rhs;
+}
+
+#ifdef HAVE_CPP_TROUBLE_COMPARING_TO_ZERO
+
+inline
+PRBool
+operator==(int lhs, const nsXPIDLCString& rhs)
+{
+    return NS_REINTERPRET_CAST(char*, lhs) == NS_STATIC_CAST(const char*, rhs);
+}
+
+inline
+PRBool
+operator==(const nsXPIDLCString& lhs, int rhs)
+{
+    return NS_STATIC_CAST(const char*, lhs) == NS_REINTERPRET_CAST(char*, rhs);
+}
+
+#endif
+
+#endif // nsXPIDLString_h__

mozilla/string/public/nsAWritableString.h

@@ -0,0 +1,882 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 2000 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *   Scott Collins <scc@mozilla.org> (original author)
+ */
+
+#ifndef nsAWritableString_h___
+#define nsAWritableString_h___
+
+  // See also...
+#ifndef nsAReadableString_h___
+#include "nsAReadableString.h"
+#endif
+
+
+template <class CharT>
+struct nsWritableFragment
+  {
+    CharT*    mStart;
+    CharT*    mEnd;
+    void*     mFragmentIdentifier;
+
+    nsWritableFragment()
+        : mStart(0), mEnd(0), mFragmentIdentifier(0)
+      {
+        // nothing else to do here
+      }
+  };
+
+template <class CharT> class basic_nsAWritableString;
+
+template <class CharT>
+class nsWritingIterator
+//  : public bidirectional_iterator_tag
+  {
+    public:
+      typedef ptrdiff_t                   difference_type;
+      typedef CharT                       value_type;
+      typedef CharT*                      pointer;
+      typedef CharT&                      reference;
+//    typedef bidirectional_iterator_tag  iterator_category;
+
+    private:
+      friend class basic_nsAWritableString<CharT>;
+
+      nsWritableFragment<CharT>       mFragment;
+      CharT*                          mPosition;
+      basic_nsAWritableString<CharT>* mOwningString;
+
+      nsWritingIterator( nsWritableFragment<CharT>& aFragment,
+                         CharT* aStartingPosition,
+                         basic_nsAWritableString<CharT>& aOwningString )
+          : mFragment(aFragment),
+            mPosition(aStartingPosition),
+            mOwningString(&aOwningString)
+        {
+          // nothing else to do here
+        }
+
+    public:
+      nsWritingIterator() { }
+      // nsWritingIterator( const nsWritingIterator<CharT>& );                    // auto-generated copy-constructor OK
+      // nsWritingIterator<CharT>& operator=( const nsWritingIterator<CharT>& );  // auto-generated copy-assignment operator OK
+
+      inline void normalize_forward();
+      inline void normalize_backward();
+
+      pointer
+      get() const
+        {
+          return mPosition;
+        }
+      
+      reference
+      operator*() const
+        {
+          return *get();
+        }
+
+#if 0
+        // An iterator really deserves this, but some compilers (notably IBM VisualAge for OS/2)
+        //  don't like this when |CharT| is a type without members.
+      pointer
+      operator->() const
+        {
+          return get();
+        }
+#endif
+
+      nsWritingIterator<CharT>&
+      operator++()
+        {
+          ++mPosition;
+          normalize_forward();
+          return *this;
+        }
+
+      nsWritingIterator<CharT>
+      operator++( int )
+        {
+          nsWritingIterator<CharT> result(*this);
+          ++mPosition;
+          normalize_forward();
+          return result;
+        }
+
+      nsWritingIterator<CharT>&
+      operator--()
+        {
+          normalize_backward();
+          --mPosition;
+          return *this;
+        }
+
+      nsWritingIterator<CharT>
+      operator--( int )
+        {
+          nsWritingIterator<CharT> result(*this);
+          normalize_backward();
+          --mPosition;
+          return result;
+        }
+
+      const nsWritableFragment<CharT>&
+      fragment() const
+        {
+          return mFragment;
+        }
+
+      difference_type
+      size_forward() const
+        {
+          return mFragment.mEnd - mPosition;
+        }
+
+      difference_type
+      size_backward() const
+        {
+          return mPosition - mFragment.mStart;
+        }
+
+      nsWritingIterator<CharT>&
+      advance( difference_type n )
+        {
+          while ( n > 0 )
+            {
+              difference_type one_hop = NS_MIN(n, size_forward());
+
+              NS_ASSERTION(one_hop>0, "Infinite loop: can't advance a writing iterator beyond the end of a string");
+                // perhaps I should |break| if |!one_hop|?
+
+              mPosition += one_hop;
+              normalize_forward();
+              n -= one_hop;
+            }
+
+          while ( n < 0 )
+            {
+              normalize_backward();
+              difference_type one_hop = NS_MAX(n, -size_backward());
+
+              NS_ASSERTION(one_hop<0, "Infinite loop: can't advance (backward) a writing iterator beyond the end of a string");
+                // perhaps I should |break| if |!one_hop|?
+
+              mPosition += one_hop;
+              n -= one_hop;
+            }
+
+          return *this;
+        }
+
+        /**
+         * Really don't want to call these two operations |+=| and |-=|.
+         * Would prefer a single function, e.g., |advance|, which doesn't imply a constant time operation.
+         *
+         * We'll get rid of these as soon as we can.
+         */
+      nsWritingIterator<CharT>&
+      operator+=( difference_type n ) // deprecated
+        {
+          return advance(n);
+        }
+
+      nsWritingIterator<CharT>&
+      operator-=( difference_type n ) // deprecated
+        {
+          return advance(-n);
+        }
+
+      PRUint32
+      write( const value_type* s, PRUint32 n )
+        {
+          NS_ASSERTION(size_forward() > 0, "You can't |write| into an |nsWritingIterator| with no space!");
+
+          n = NS_MIN(n, PRUint32(size_forward()));
+          nsCharTraits<value_type>::move(mPosition, s, n);
+          advance( difference_type(n) );
+          return n;
+        }
+  };
+
+#if 0
+template <class CharT>
+nsWritingIterator<CharT>&
+nsWritingIterator<CharT>::advance( difference_type n )
+  {
+    while ( n > 0 )
+      {
+        difference_type one_hop = NS_MIN(n, size_forward());
+
+        NS_ASSERTION(one_hop>0, "Infinite loop: can't advance a writing iterator beyond the end of a string");
+          // perhaps I should |break| if |!one_hop|?
+
+        mPosition += one_hop;
+        normalize_forward();
+        n -= one_hop;
+      }
+
+    while ( n < 0 )
+      {
+        normalize_backward();
+        difference_type one_hop = NS_MAX(n, -size_backward());
+
+        NS_ASSERTION(one_hop<0, "Infinite loop: can't advance (backward) a writing iterator beyond the end of a string");
+          // perhaps I should |break| if |!one_hop|?
+
+        mPosition += one_hop;
+        n -= one_hop;
+      }
+
+    return *this;
+  }
+#endif
+
+/*
+  This file defines the abstract interfaces |nsAWritableString| and
+  |nsAWritableCString|.
+
+  |nsAWritableString| is a string of |PRUnichar|s.  |nsAWritableCString| (note the
+  'C') is a string of |char|s.
+*/
+
+template <class CharT>
+class basic_nsAWritableString
+      : public basic_nsAReadableString<CharT>
+    /*
+      ...
+    */
+  {
+    // friend class nsWritingIterator<CharT>;
+
+    public:
+      typedef CharT                     char_type;
+      typedef PRUint32                  size_type;
+      typedef PRUint32                  index_type;
+
+      typedef nsWritingIterator<CharT>  iterator;
+
+      // basic_nsAWritableString();                                         // auto-generated default constructor OK (we're abstract anyway)
+      // basic_nsAWritableString( const basic_nsAWritableString<CharT>& );  // auto-generated copy-constructor OK (again, only because we're abstract)
+      // ~basic_nsAWritableString();                                        // auto-generated destructor OK
+      // see below for copy-assignment operator
+
+      virtual CharT* GetWritableFragment( nsWritableFragment<CharT>&, nsFragmentRequest, PRUint32 = 0 ) = 0;
+
+        /**
+         * Note: measure -- should the |BeginWriting| and |EndWriting| be |inline|?
+         */
+      nsWritingIterator<CharT>&
+      BeginWriting( nsWritingIterator<CharT>& aResult )
+        {
+          aResult.mOwningString = this;
+          GetWritableFragment(aResult.mFragment, kFirstFragment);
+          aResult.mPosition = aResult.mFragment.mStart;
+          aResult.normalize_forward();
+          return aResult;
+        }
+
+        // deprecated
+      nsWritingIterator<CharT>
+      BeginWriting()
+        {
+          nsWritingIterator<CharT> result;
+          return BeginWriting(result); // copies (since I return a value, not a reference)
+        }
+
+
+      nsWritingIterator<CharT>&
+      EndWriting( nsWritingIterator<CharT>& aResult )
+        {
+          aResult.mOwningString = this;
+          GetWritableFragment(aResult.mFragment, kLastFragment);
+          aResult.mPosition = aResult.mFragment.mEnd;
+          // must not |normalize_backward| as that would likely invalidate tests like |while ( first != last )|
+          return aResult;
+        }
+
+        // deprecated
+      nsWritingIterator<CharT>
+      EndWriting()
+        {
+          nsWritingIterator<CharT> result;
+          return EndWriting(result); // copies (since I return a value, not a reference)
+        }
+
+
+        /**
+         * |SetCapacity| is not required to do anything; however, it can be used
+         * as a hint to the implementation to reduce allocations.
+         * |SetCapacity(0)| is a suggestion to discard all associated storage.
+         */
+      virtual void SetCapacity( PRUint32 ) { }
+
+        /**
+         * |SetLength| is used in two ways:
+         *   1) to |Cut| a suffix of the string;
+         *   2) to prepare to |Append| or move characters around.
+         *
+         * External callers are not allowed to use |SetLength| is this latter capacity.
+         * Should this really be a public operation?
+         * Additionally, your implementation of |SetLength| need not satisfy (2) if and only if you
+         * override the |do_...| routines to not need this facility.
+         *
+         * This distinction makes me think the two different uses should be split into
+         * two distinct functions.
+         */
+      virtual void SetLength( PRUint32 ) = 0;
+
+
+      void
+      Truncate( PRUint32 aNewLength=0 )
+        {
+          NS_ASSERTION(aNewLength<=this->Length(), "Can't use |Truncate()| to make a string longer.");
+
+          if ( aNewLength < this->Length() )
+            SetLength(aNewLength);
+        }
+
+
+      // PRBool SetCharAt( char_type, index_type ) = 0;
+
+
+
+      // void ToLowerCase();
+      // void ToUpperCase();
+
+      // void StripChars( const CharT* aSet );
+      // void StripChar( ... );
+      // void StripWhitespace();
+      // void ReplaceChar( ... );
+      // void ReplaceSubstring( ... );
+      // void Trim( ... );
+      // void CompressSet( ... );
+      // void CompressWhitespace( ... );
+
+
+
+        //
+        // |Assign()|, |operator=()|
+        //
+
+      void Assign( const basic_nsAReadableString<CharT>& aReadable )                                { AssignFromReadable(aReadable); }
+      void Assign( const nsPromiseReadable<CharT>& aReadable )                                      { AssignFromPromise(aReadable); }
+      void Assign( const CharT* aPtr )                                                              { aPtr ? do_AssignFromElementPtr(aPtr) : SetLength(0); }
+      void Assign( const CharT* aPtr, PRUint32 aLength )                                            { do_AssignFromElementPtrLength(aPtr, aLength); }
+      void Assign( CharT aChar )                                                                    { do_AssignFromElement(aChar); }
+
+        // copy-assignment operator.  I must define my own if I don't want the compiler to make me one
+      basic_nsAWritableString<CharT>& operator=( const basic_nsAWritableString<CharT>& aWritable )  { Assign(aWritable); return *this; }
+
+      basic_nsAWritableString<CharT>& operator=( const basic_nsAReadableString<CharT>& aReadable )  { Assign(aReadable); return *this; }
+      basic_nsAWritableString<CharT>& operator=( const nsPromiseReadable<CharT>& aReadable )        { Assign(aReadable); return *this; }
+      basic_nsAWritableString<CharT>& operator=( const CharT* aPtr )                                { Assign(aPtr); return *this; }
+      basic_nsAWritableString<CharT>& operator=( CharT aChar )                                      { Assign(aChar); return *this; }
+
+
+
+        //
+        // |Append()|, |operator+=()|
+        //
+
+      void Append( const basic_nsAReadableString<CharT>& aReadable )                                { AppendFromReadable(aReadable); }
+      void Append( const nsPromiseReadable<CharT>& aReadable )                                      { AppendFromPromise(aReadable); }
+      void Append( const CharT* aPtr )                                                              { if (aPtr) do_AppendFromElementPtr(aPtr); }
+      void Append( const CharT* aPtr, PRUint32 aLength )                                            { do_AppendFromElementPtrLength(aPtr, aLength); }
+      void Append( CharT aChar )                                                                    { do_AppendFromElement(aChar); }
+
+      basic_nsAWritableString<CharT>& operator+=( const basic_nsAReadableString<CharT>& aReadable ) { Append(aReadable); return *this; }
+      basic_nsAWritableString<CharT>& operator+=( const nsPromiseReadable<CharT>& aReadable )       { Append(aReadable); return *this; }
+      basic_nsAWritableString<CharT>& operator+=( const CharT* aPtr )                               { Append(aPtr); return *this; }
+      basic_nsAWritableString<CharT>& operator+=( CharT aChar )                                     { Append(aChar); return *this; }
+
+
+
+        /**
+         * The following index based routines need to be recast with iterators.
+         */
+
+        //
+        // |Insert()|
+        //  Note: I would really like to move the |atPosition| parameter to the front of the argument list
+        //
+
+      void Insert( const basic_nsAReadableString<CharT>& aReadable, PRUint32 atPosition )                               { InsertFromReadable(aReadable, atPosition); }
+      void Insert( const nsPromiseReadable<CharT>& aReadable, PRUint32 atPosition )                                     { InsertFromPromise(aReadable, atPosition); }
+      void Insert( const CharT* aPtr, PRUint32 atPosition )                                                             { if (aPtr) do_InsertFromElementPtr(aPtr, atPosition); }
+      void Insert( const CharT* aPtr, PRUint32 atPosition, PRUint32 aLength )                                           { do_InsertFromElementPtrLength(aPtr, atPosition, aLength); }
+      void Insert( CharT aChar, PRUint32 atPosition )                                                                   { do_InsertFromElement(aChar, atPosition); }
+
+
+
+      virtual void Cut( PRUint32 cutStart, PRUint32 cutLength );
+
+
+
+      void Replace( PRUint32 cutStart, PRUint32 cutLength, const basic_nsAReadableString<CharT>& aReadable )            { ReplaceFromReadable(cutStart, cutLength, aReadable); }
+      void Replace( PRUint32 cutStart, PRUint32 cutLength, const nsPromiseReadable<CharT>& aReadable )                  { ReplaceFromPromise(cutStart, cutLength, aReadable); }
+
+    private:
+      typedef typename nsCharTraits<CharT>::incompatible_char_type incompatible_char_type;
+
+        // NOT TO BE IMPLEMENTED
+      void operator=  ( incompatible_char_type );
+      void Assign     ( incompatible_char_type );
+      void operator+= ( incompatible_char_type );
+      void Append     ( incompatible_char_type );
+      void Insert     ( incompatible_char_type, PRUint32 );
+      
+
+    protected:
+              void AssignFromReadable( const basic_nsAReadableString<CharT>& );
+              void AssignFromPromise( const basic_nsAReadableString<CharT>& );
+      virtual void do_AssignFromReadable( const basic_nsAReadableString<CharT>& );
+      virtual void do_AssignFromElementPtr( const CharT* );
+      virtual void do_AssignFromElementPtrLength( const CharT*, PRUint32 );
+      virtual void do_AssignFromElement( CharT );
+
+              void AppendFromReadable( const basic_nsAReadableString<CharT>& );
+              void AppendFromPromise( const basic_nsAReadableString<CharT>& );
+      virtual void do_AppendFromReadable( const basic_nsAReadableString<CharT>& );
+      virtual void do_AppendFromElementPtr( const CharT* );
+      virtual void do_AppendFromElementPtrLength( const CharT*, PRUint32 );
+      virtual void do_AppendFromElement( CharT );
+
+              void InsertFromReadable( const basic_nsAReadableString<CharT>&, PRUint32 );
+              void InsertFromPromise( const basic_nsAReadableString<CharT>&, PRUint32 );
+      virtual void do_InsertFromReadable( const basic_nsAReadableString<CharT>&, PRUint32 );
+      virtual void do_InsertFromElementPtr( const CharT*, PRUint32 );
+      virtual void do_InsertFromElementPtrLength( const CharT*, PRUint32, PRUint32 );
+      virtual void do_InsertFromElement( CharT, PRUint32 );
+
+              void ReplaceFromReadable( PRUint32, PRUint32, const basic_nsAReadableString<CharT>& );
+              void ReplaceFromPromise( PRUint32, PRUint32, const basic_nsAReadableString<CharT>& );
+      virtual void do_ReplaceFromReadable( PRUint32, PRUint32, const basic_nsAReadableString<CharT>& );
+  };
+
+
+
+  //
+  // |nsWritingIterator|s
+  //
+
+template <class CharT>
+inline
+void
+nsWritingIterator<CharT>::normalize_forward()
+  {
+    while ( mPosition == mFragment.mEnd
+         && mOwningString->GetWritableFragment(mFragment, kNextFragment) )
+      mPosition = mFragment.mStart;
+  }
+
+template <class CharT>
+inline
+void
+nsWritingIterator<CharT>::normalize_backward()
+  {
+    while ( mPosition == mFragment.mStart
+         && mOwningString->GetWritableFragment(mFragment, kPrevFragment) )
+      mPosition = mFragment.mEnd;
+  }
+
+template <class CharT>
+inline
+PRBool
+operator==( const nsWritingIterator<CharT>& lhs, const nsWritingIterator<CharT>& rhs )
+  {
+    return lhs.get() == rhs.get();
+  }
+
+template <class CharT>
+inline
+PRBool
+operator!=( const nsWritingIterator<CharT>& lhs, const nsWritingIterator<CharT>& rhs )
+  {
+    return lhs.get() != rhs.get();
+  }
+
+
+
+  //
+  // |Assign()|
+  //
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::AssignFromReadable( const basic_nsAReadableString<CharT>& rhs )
+  {
+    if ( NS_STATIC_CAST(const basic_nsAReadableString<CharT>*, this) != &rhs )
+      do_AssignFromReadable(rhs);
+    // else, self-assign is a no-op
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::AssignFromPromise( const basic_nsAReadableString<CharT>& aReadable )
+    /*
+      ...this function is only called when a promise that somehow references |this| is assigned _into_ |this|.
+      E.g.,
+      
+        ... writable& w ...
+        ... readable& r ...
+        
+        w = r + w;
+
+      In this example, you can see that unless the characters promised by |w| in |r+w| are resolved before
+      anything starts getting copied into |w|, there will be trouble.  They will be overritten by the contents
+      of |r| before being retrieved to be appended.
+
+      We could have a really tricky solution where we tell the promise to resolve _just_ the data promised
+      by |this|, but this should be a rare case, since clients with more local knowledge will know that, e.g.,
+      in the case above, |Insert| could have special behavior with significantly better performance.  Since
+      it's a rare case anyway, we should just do the simplest thing that could possibly work, resolve the
+      entire promise.  If we measure and this turns out to show up on performance radar, we then have the
+      option to fix either the callers or this mechanism.
+    */
+  {
+    if ( !aReadable.Promises(*this) )
+      do_AssignFromReadable(aReadable);
+    else
+      {
+        PRUint32 length = aReadable.Length();
+        CharT* buffer = new CharT[length];
+        if ( buffer )
+          {
+            // Note: not exception safe.  We need something to manage temporary buffers like this
+
+            nsReadingIterator<CharT> fromBegin, fromEnd;
+            CharT* toBegin = buffer;
+            copy_string(aReadable.BeginReading(fromBegin), aReadable.EndReading(fromEnd), toBegin);
+            do_AssignFromElementPtrLength(buffer, length);
+            delete buffer;
+          }
+        // else assert?
+      }
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::do_AssignFromReadable( const basic_nsAReadableString<CharT>& aReadable )
+  {
+    SetLength(0);
+    SetLength(aReadable.Length());
+      // first setting the length to |0| avoids copying characters only to be overwritten later
+      //  in the case where the implementation decides to re-allocate
+
+    nsReadingIterator<CharT> fromBegin, fromEnd;
+    nsWritingIterator<CharT> toBegin;
+    copy_string(aReadable.BeginReading(fromBegin), aReadable.EndReading(fromEnd), BeginWriting(toBegin));
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::do_AssignFromElementPtr( const CharT* aPtr )
+  {
+    do_AssignFromReadable(basic_nsLiteralString<CharT>(aPtr));
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::do_AssignFromElementPtrLength( const CharT* aPtr, PRUint32 aLength )
+  {
+    do_AssignFromReadable(basic_nsLiteralString<CharT>(aPtr, aLength));
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::do_AssignFromElement( CharT aChar )
+  {
+    do_AssignFromReadable(basic_nsLiteralChar<CharT>(aChar));
+  }
+
+
+
+  //
+  // |Append()|
+  //
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::AppendFromReadable( const basic_nsAReadableString<CharT>& aReadable )
+  {
+    if ( NS_STATIC_CAST(const basic_nsAReadableString<CharT>*, this) != &aReadable )
+      do_AppendFromReadable(aReadable);
+    else
+      AppendFromPromise(aReadable);
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::AppendFromPromise( const basic_nsAReadableString<CharT>& aReadable )
+  {
+    if ( !aReadable.Promises(*this) )
+      do_AppendFromReadable(aReadable);
+    else
+      {
+        PRUint32 length = aReadable.Length();
+        CharT* buffer = new CharT[length];
+        if ( buffer )
+          {
+            nsReadingIterator<CharT> fromBegin, fromEnd;
+            CharT* toBegin = buffer;
+            copy_string(aReadable.BeginReading(fromBegin), aReadable.EndReading(fromEnd), toBegin);
+            do_AppendFromElementPtrLength(buffer, length);
+            delete buffer;
+          }
+        // else assert?
+      }
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::do_AppendFromReadable( const basic_nsAReadableString<CharT>& aReadable )
+  {
+    PRUint32 oldLength = this->Length();
+    SetLength(oldLength + aReadable.Length());
+
+    nsReadingIterator<CharT> fromBegin, fromEnd;
+    nsWritingIterator<CharT> toBegin;
+    copy_string(aReadable.BeginReading(fromBegin), aReadable.EndReading(fromEnd), BeginWriting(toBegin).advance( PRInt32(oldLength) ) );
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::do_AppendFromElementPtr( const CharT* aChar )
+  {
+    do_AppendFromReadable(basic_nsLiteralString<CharT>(aChar));
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::do_AppendFromElementPtrLength( const CharT* aChar, PRUint32 aLength )
+  {
+    do_AppendFromReadable(basic_nsLiteralString<CharT>(aChar, aLength));
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::do_AppendFromElement( CharT aChar )
+  {
+    do_AppendFromReadable(basic_nsLiteralChar<CharT>(aChar));
+  }
+
+
+
+  //
+  // |Insert()|
+  //
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::InsertFromReadable( const basic_nsAReadableString<CharT>& aReadable, PRUint32 atPosition )
+  {
+    if ( NS_STATIC_CAST(const basic_nsAReadableString<CharT>*, this) != &aReadable )
+      do_InsertFromReadable(aReadable, atPosition);
+    else
+      InsertFromPromise(aReadable, atPosition);
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::InsertFromPromise( const basic_nsAReadableString<CharT>& aReadable, PRUint32 atPosition )
+  {
+    if ( !aReadable.Promises(*this) )
+      do_InsertFromReadable(aReadable, atPosition);
+    else
+      {
+        PRUint32 length = aReadable.Length();
+        CharT* buffer = new CharT[length];
+        if ( buffer )
+          {
+            nsReadingIterator<CharT> fromBegin, fromEnd;
+            CharT* toBegin = buffer;
+            copy_string(aReadable.BeginReading(fromBegin), aReadable.EndReading(fromEnd), toBegin);
+            do_InsertFromElementPtrLength(buffer, atPosition, length);
+            delete buffer;
+          }
+        // else assert
+      }
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::do_InsertFromReadable( const basic_nsAReadableString<CharT>& aReadable, PRUint32 atPosition )
+  {
+    PRUint32 oldLength = this->Length();
+    SetLength(oldLength + aReadable.Length());
+
+    nsReadingIterator<CharT> fromBegin, fromEnd;
+    nsWritingIterator<CharT> toBegin;
+    if ( atPosition < oldLength )
+      copy_string_backward(this->BeginReading(fromBegin).advance(PRInt32(atPosition)), this->BeginReading(fromEnd).advance(PRInt32(oldLength)), EndWriting(toBegin));
+    else
+      atPosition = oldLength;
+    copy_string(aReadable.BeginReading(fromBegin), aReadable.EndReading(fromEnd), BeginWriting(toBegin).advance(PRInt32(atPosition)));
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::do_InsertFromElementPtr( const CharT* aPtr, PRUint32 atPosition )
+  {
+    do_InsertFromReadable(basic_nsLiteralString<CharT>(aPtr), atPosition);
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::do_InsertFromElementPtrLength( const CharT* aPtr, PRUint32 atPosition, PRUint32 aLength )
+  {
+    do_InsertFromReadable(basic_nsLiteralString<CharT>(aPtr, aLength), atPosition);
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::do_InsertFromElement( CharT aChar, PRUint32 atPosition )
+  {
+    do_InsertFromReadable(basic_nsLiteralChar<CharT>(aChar), atPosition);
+  }
+
+
+
+  //
+  // |Cut()|
+  //
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::Cut( PRUint32 cutStart, PRUint32 cutLength )
+  {
+    PRUint32 myLength = this->Length();
+    cutLength = NS_MIN(cutLength, myLength-cutStart);
+    PRUint32 cutEnd = cutStart + cutLength;
+
+    nsReadingIterator<CharT> fromBegin, fromEnd;
+    nsWritingIterator<CharT> toBegin;
+    if ( cutEnd < myLength )
+      copy_string(this->BeginReading(fromBegin).advance(PRInt32(cutEnd)), this->EndReading(fromEnd), BeginWriting(toBegin).advance(PRInt32(cutStart)));
+    SetLength(myLength-cutLength);
+  }
+
+
+
+  //
+  // |Replace()|
+  //
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::ReplaceFromReadable( PRUint32 cutStart, PRUint32 cutLength, const basic_nsAReadableString<CharT>& aReplacement )
+  {
+    if ( NS_STATIC_CAST(const basic_nsAReadableString<CharT>*, this) != &aReplacement )
+      do_ReplaceFromReadable(cutStart, cutLength, aReplacement);
+    else
+      ReplaceFromPromise(cutStart, cutLength, aReplacement);
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::ReplaceFromPromise( PRUint32 cutStart, PRUint32 cutLength, const basic_nsAReadableString<CharT>& aReadable )
+  {
+    if ( !aReadable.Promises(*this) )
+      do_ReplaceFromReadable(cutStart, cutLength, aReadable);
+    else
+      {
+        PRUint32 length = aReadable.Length();
+        CharT* buffer = new CharT[length];
+        if ( buffer )
+          {
+            nsReadingIterator<CharT> fromBegin, fromEnd;
+            CharT* toBegin = buffer;
+            copy_string(aReadable.BeginReading(fromBegin), aReadable.EndReading(fromEnd), toBegin);
+            do_ReplaceFromReadable(cutStart, cutLength, basic_nsLiteralString<CharT>(buffer, length));
+            delete buffer;
+          }
+        // else assert?
+      }
+  }
+
+template <class CharT>
+void
+basic_nsAWritableString<CharT>::do_ReplaceFromReadable( PRUint32 cutStart, PRUint32 cutLength, const basic_nsAReadableString<CharT>& aReplacement )
+  {
+    PRUint32 oldLength = this->Length();
+
+    cutStart = NS_MIN(cutStart, oldLength);
+    cutLength = NS_MIN(cutLength, oldLength-cutStart);
+    PRUint32 cutEnd = cutStart + cutLength;
+
+    PRUint32 replacementLength = aReplacement.Length();
+    PRUint32 replacementEnd = cutStart + replacementLength;
+
+    PRUint32 newLength = oldLength - cutLength + replacementLength;
+
+    nsReadingIterator<CharT> fromBegin, fromEnd;
+    nsWritingIterator<CharT> toBegin;
+    if ( cutLength > replacementLength )
+      copy_string(this->BeginReading(fromBegin).advance(PRInt32(cutEnd)), this->EndReading(fromEnd), BeginWriting(toBegin).advance(PRInt32(replacementEnd)));
+    SetLength(newLength);
+    if ( cutLength < replacementLength )
+      copy_string_backward(this->BeginReading(fromBegin).advance(PRInt32(cutEnd)), this->BeginReading(fromEnd).advance(PRInt32(oldLength)), BeginWriting(toBegin).advance(PRInt32(replacementEnd)));
+
+    copy_string(aReplacement.BeginReading(fromBegin), aReplacement.EndReading(fromEnd), BeginWriting(toBegin).advance(PRInt32(cutStart)));
+  }
+
+
+template <class CharT>
+PRUint32
+basic_nsAReadableString<CharT>::Mid( basic_nsAWritableString<CharT>& aResult, PRUint32 aStartPos, PRUint32 aLengthToCopy ) const
+  {
+      // If we're just assigning our entire self, give |aResult| the opportunity to share
+    if ( aStartPos == 0 && aLengthToCopy >= Length() )
+      aResult = *this;
+    else
+      aResult = Substring(*this, aStartPos, aLengthToCopy);
+
+    return aResult.Length();
+  }
+
+template <class CharT>
+inline
+PRUint32
+basic_nsAReadableString<CharT>::Left( basic_nsAWritableString<CharT>& aResult, PRUint32 aLengthToCopy ) const
+  {
+    return Mid(aResult, 0, aLengthToCopy);
+  }
+
+template <class CharT>
+PRUint32
+basic_nsAReadableString<CharT>::Right( basic_nsAWritableString<CharT>& aResult, PRUint32 aLengthToCopy ) const
+  {
+    PRUint32 myLength = Length();
+    aLengthToCopy = NS_MIN(myLength, aLengthToCopy);
+    return Mid(aResult, myLength-aLengthToCopy, aLengthToCopy);
+  }
+
+
+
+
+  //
+  // Types
+  //
+
+typedef basic_nsAWritableString<PRUnichar>  nsAWritableString;
+typedef basic_nsAWritableString<char>       nsAWritableCString;
+
+#endif // !defined(nsAWritableString_h___)

mozilla/string/public/nsAlgorithm.h

@@ -0,0 +1,113 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *   Scott Collins <scc@mozilla.org> (original author)
+ *
+ */
+
+#ifndef nsAlgorithm_h___
+#define nsAlgorithm_h___
+
+#ifndef nsCharTraits_h___
+#include "nsCharTraits.h"
+  // for |nsCharSourceTraits|, |nsCharSinkTraits|
+#endif
+
+#ifndef prtypes_h___
+#include "prtypes.h"
+  // for |PRUint32|...
+#endif
+
+template <class T>
+inline
+const T&
+NS_MIN( const T& a, const T& b )
+  {
+    return b < a ? b : a;
+  }
+
+template <class T>
+inline
+const T&
+NS_MAX( const T& a, const T& b )
+  {
+    return a > b ? a : b;
+  }
+
+template <class InputIterator, class T>
+inline
+PRUint32
+NS_COUNT( InputIterator& first, const InputIterator& last, const T& value )
+  {
+    PRUint32 result = 0;
+    for ( ; first != last; ++first )
+      if ( *first == value )
+        ++result;
+    return result;
+  }
+
+template <class InputIterator, class OutputIterator>
+inline
+OutputIterator&
+copy_string( InputIterator& first, const InputIterator& last, OutputIterator& result )
+  {
+    typedef nsCharSourceTraits<InputIterator> source_traits;
+    typedef nsCharSinkTraits<OutputIterator>  sink_traits;
+
+    while ( first != last )
+      {
+        PRInt32 count_copied = PRInt32(sink_traits::write(result, source_traits::read(first), source_traits::readable_distance(first, last)));
+        NS_ASSERTION(count_copied > 0, "|copy_string| will never terminate");
+        source_traits::advance(first, count_copied);
+      }
+
+    return result;
+  }
+
+template <class InputIterator, class OutputIterator>
+OutputIterator&
+copy_string_backward( const InputIterator& first, InputIterator& last, OutputIterator& result )
+  {
+    while ( first != last )
+      {
+        last.normalize_backward();
+        result.normalize_backward();
+        PRUint32 lengthToCopy = PRUint32( NS_MIN(last.size_backward(), result.size_backward()) );
+        if ( first.fragment().mStart == last.fragment().mStart )
+          lengthToCopy = NS_MIN(lengthToCopy, PRUint32(last.get() - first.get()));
+
+        NS_ASSERTION(lengthToCopy, "|copy_string_backward| will never terminate");
+
+#ifdef _MSC_VER
+        // XXX Visual C++ can't stomach 'typename' where it rightfully should
+        nsCharTraits<OutputIterator::value_type>::move(result.get()-lengthToCopy, last.get()-lengthToCopy, lengthToCopy);
+#else
+        nsCharTraits<typename OutputIterator::value_type>::move(result.get()-lengthToCopy, last.get()-lengthToCopy, lengthToCopy);
+#endif
+
+        last.advance( -PRInt32(lengthToCopy) );
+        result.advance( -PRInt32(lengthToCopy) );
+      }
+
+    return result;
+  }
+
+
+#endif // !defined(nsAlgorithm_h___)

mozilla/string/public/nsBufferHandle.h

@@ -0,0 +1,181 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla strings.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 2000 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *   Scott Collins <scc@mozilla.org> (original author)
+ *
+ */
+
+#ifndef nsBufferHandle_h___
+#define nsBufferHandle_h___
+
+#include <stddef.h>
+  // for |ptrdiff_t|
+
+#include "prtypes.h"
+  // for |PRBool|
+
+#include "nsDebug.h"
+  // for |NS_ASSERTION|
+
+#include "nsMemory.h"
+  // for |nsMemory::Free|
+
+  /**
+   *
+   */
+template <class CharT>
+class nsBufferHandle
+  {
+    public:
+      nsBufferHandle( CharT* aDataStart, CharT* aDataEnd ) : mDataStart(aDataStart), mDataEnd(aDataEnd) { }
+
+      void          DataStart( CharT* aNewDataStart )       { mDataStart = aNewDataStart; }
+      CharT*        DataStart()                             { return mDataStart; }
+      const CharT*  DataStart() const                       { return mDataStart; }
+
+      void          DataEnd( CharT* aNewDataEnd )           { mDataEnd = aNewDataEnd; }
+      CharT*        DataEnd()                               { return mDataEnd; }
+      const CharT*  DataEnd() const                         { return mDataEnd; }
+
+//    void          DataLength( ptrdiff_t aNewDataLength )  { mDataEnd = mDataStart+aNewDataLength; }
+      ptrdiff_t     DataLength() const                      { return mDataEnd - mDataStart; }
+
+    protected:
+      CharT*  mDataStart;
+      CharT*  mDataEnd;
+  };
+
+
+
+  /**
+   *
+   */
+template <class CharT>
+class nsSharedBufferHandle
+    : public nsBufferHandle<CharT>
+  {
+    protected:
+      enum
+        {
+          kIsShared                       = 1<<31,
+          kIsSingleAllocationWithBuffer   = 1<<30,
+          kIsStorageDefinedSeparately     = 1<<29,
+
+          kFlagsMask                      = kIsShared | kIsSingleAllocationWithBuffer | kIsStorageDefinedSeparately,
+          kRefCountMask                   = ~kFlagsMask
+        };
+
+    public:
+      nsSharedBufferHandle( CharT* aDataStart, CharT* aDataEnd )
+          : nsBufferHandle<CharT>(aDataStart, aDataEnd)
+        {
+          mFlags |= kIsShared;
+        }
+
+      ~nsSharedBufferHandle();
+
+      void
+      AcquireReference() const
+        {
+          nsSharedBufferHandle<CharT>* mutable_this = NS_CONST_CAST(nsSharedBufferHandle<CharT>*, this);
+          mutable_this->set_refcount( get_refcount()+1 );
+        }
+
+      void
+      ReleaseReference() const
+        {
+          nsSharedBufferHandle<CharT>* mutable_this = NS_CONST_CAST(nsSharedBufferHandle<CharT>*, this);
+          if ( !mutable_this->set_refcount( get_refcount()-1 ) )
+            delete mutable_this;
+        }
+
+      PRBool
+      IsReferenced() const
+        {
+          return get_refcount() != 0;
+        }
+
+    protected:
+      PRUint32  mFlags;
+
+      PRUint32
+      get_refcount() const
+        {
+          return mFlags & kRefCountMask;
+        }
+
+      PRUint32
+      set_refcount( PRUint32 aNewRefCount )
+        {
+          NS_ASSERTION(aNewRefCount <= kRefCountMask, "aNewRefCount <= kRefCountMask");
+
+          mFlags = (mFlags & kFlagsMask) | aNewRefCount;
+          return aNewRefCount;
+        }
+  };
+
+
+  // need a name for this
+template <class CharT>
+class nsFlexBufferHandle
+    : public nsSharedBufferHandle<CharT>
+  {
+    public:
+      nsFlexBufferHandle( CharT* aDataStart, CharT* aDataEnd, CharT* aStorageStart, CharT* aStorageEnd )
+          : nsSharedBufferHandle<CharT>(aDataStart, aDataEnd),
+            mStorageStart(aStorageStart),
+            mStorageEnd(aStorageEnd)
+        {
+          this->mFlags |= this->kIsStorageDefinedSeparately;
+        }
+
+      void          StorageStart( CharT* aNewStorageStart )       { mStorageStart = aNewStorageStart; }
+      CharT*        StorageStart()                                { return mStorageStart; }
+      const CharT*  StorageStart() const                          { return mStorageStart; }
+
+      void          StorageEnd( CharT* aNewStorageEnd )           { mStorageEnd = aNewStorageEnd; }
+      CharT*        StorageEnd()                                  { return mStorageEnd; }
+      const CharT*  StorageEnd() const                            { return mStorageEnd; }
+
+//    void          StorageLength( ptrdiff_t aNewStorageLength )  { mStorageEnd = mStorageStart+aNewStorageLength; }
+      ptrdiff_t     StorageLength() const                         { return mStorageEnd - mStorageStart; }
+
+    protected:
+      CharT*  mStorageStart;
+      CharT*  mStorageEnd;
+  };
+
+template <class CharT>
+nsSharedBufferHandle<CharT>::~nsSharedBufferHandle()
+    // really don't want this to be |inline|
+  {
+    NS_ASSERTION(!IsReferenced(), "!IsReferenced()");
+
+    if ( !(mFlags & kIsSingleAllocationWithBuffer) )
+      {
+        CharT* string_storage = this->mDataStart;
+        if ( mFlags & kIsStorageDefinedSeparately )
+          string_storage = NS_REINTERPRET_CAST(nsFlexBufferHandle<CharT>*, this)->StorageStart();
+        nsMemory::Free(string_storage);
+      }
+  }
+
+
+#endif // !defined(nsBufferHandle_h___)

mozilla/string/public/nsCharTraits.h

@@ -0,0 +1,703 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 2000 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *   Scott Collins <scc@mozilla.org> (original author)
+ */
+
+#ifndef nsCharTraits_h___
+#define nsCharTraits_h___
+
+#include <ctype.h>
+  // for |EOF|, |WEOF|
+
+#include <string.h>
+  // for |memcpy|, et al
+
+#ifndef nscore_h___
+#include "nscore.h"
+  // for |PRUnichar|
+#endif
+
+
+#ifdef HAVE_CPP_BOOL
+  typedef bool nsCharTraits_bool;
+#else
+  typedef PRBool nsCharTraits_bool;
+#endif
+
+template <class CharT>
+struct nsCharTraits
+  {
+    typedef CharT char_type;
+    typedef char  incompatible_char_type;
+
+    static
+    void
+    assign( char_type& lhs, const char_type& rhs )
+      {
+        lhs = rhs;
+      }
+
+
+      // integer representation of characters:
+
+    typedef int int_type;
+
+    static
+    char_type
+    to_char_type( const int_type& c )
+      {
+        return char_type(c);
+      }
+
+    static
+    int_type
+    to_int_type( const char_type& c )
+      {
+        return int_type(c);
+      }
+
+    static
+    nsCharTraits_bool
+    eq_int_type( const int_type& lhs, const int_type& rhs )
+      {
+        return lhs == rhs;
+      }
+
+
+      // |char_type| comparisons:
+
+    static
+    nsCharTraits_bool
+    eq( const char_type& lhs, const char_type& rhs )
+      {
+        return lhs == rhs;
+      }
+
+    static
+    nsCharTraits_bool
+    lt( const char_type& lhs, const char_type& rhs )
+      {
+        return lhs < rhs;
+      }
+
+
+      // operations on s[n] arrays:
+
+    static
+    char_type*
+    copy( char_type* s1, const char_type* s2, size_t n )
+      {
+        char_type* result = s1;
+        while ( n-- )
+          assign(*s1++, *s2++);
+        return result;
+      }
+
+    static
+    char_type*
+    move( char_type* s1, const char_type* s2, size_t n )
+      {
+        char_type* result = s1;
+
+        if ( n )
+          {
+            if ( s2 > s1 )
+              copy(s1, s2, n);
+            else
+              {
+                s1 += n;
+                s2 += n;
+                while ( n-- )
+                  assign(*--s1, *--s2);
+              }
+          }
+        
+        return result;
+      }
+
+    static
+    char_type*
+    assign( char_type* s, size_t n, const char_type& c )
+      {
+        char_type* result = s;
+        while ( n-- )
+          assign(*s++, c);
+        return result;
+      }
+
+    static
+    int
+    compare( const char_type* s1, const char_type* s2, size_t n )
+      {
+        for ( ; n--; ++s1, ++s2 )
+          {
+            if ( lt(*s1, *s2) )
+              return -1;
+            if ( lt(*s2, *s1) )
+              return 1;
+          }
+
+        return 0;
+      }
+
+    static
+    size_t
+    length( const char_type* s )
+      {
+        size_t result = 0;
+        while ( !eq(*s++, CharT(0)) )
+          ++result;
+        return result;
+      }
+
+    static
+    const char_type*
+    find( const char_type* s, size_t n, const char_type& c )
+      {
+        while ( n-- )
+          {
+            if ( eq(*s, c) )
+              return s;
+            ++s;
+          }
+
+        return 0;
+      }
+
+#if 0
+      // I/O related:
+
+    typedef streamoff off_type;
+    typedef streampos pos_type;
+    typedef mbstate_t state_type;
+
+    static
+    int_type
+    eof()
+      {
+        return EOF;
+      }
+
+    static
+    int_type
+    not_eof( const int_type& c )
+      {
+        return eq_int_type(c, eof()) ? ~eof() : c;
+      }
+
+    // static state_type get_state( pos_type );
+#endif
+  };
+
+NS_SPECIALIZE_TEMPLATE
+struct nsCharTraits<char>
+  {
+    typedef char      char_type;
+    typedef PRUnichar incompatible_char_type;
+
+    static
+    void
+    assign( char& lhs, char rhs )
+      {
+        lhs = rhs;
+      }
+
+
+      // integer representation of characters:
+
+    typedef int int_type;
+
+    static
+    char
+    to_char_type( int c )
+      {
+        return char(c);
+      }
+
+    static
+    int
+    to_int_type( char c )
+      {
+        return int( NS_STATIC_CAST(unsigned char, c) );
+      }
+
+    static
+    nsCharTraits_bool
+    eq_int_type( int lhs, int rhs )
+      {
+        return lhs == rhs;
+      }
+
+
+      // |char_type| comparisons:
+
+    static
+    nsCharTraits_bool
+    eq( char lhs, char rhs )
+      {
+        return lhs == rhs;
+      }
+
+    static
+    nsCharTraits_bool
+    lt( char lhs, char rhs )
+      {
+        return lhs < rhs;
+      }
+
+
+      // operations on s[n] arrays:
+
+    static
+    char*
+    move( char* s1, const char* s2, size_t n )
+      {
+        return NS_STATIC_CAST(char*, memmove(s1, s2, n));
+      }
+
+    static
+    char*
+    copy( char* s1, const char* s2, size_t n )
+      {
+        return NS_STATIC_CAST(char*, memcpy(s1, s2, n));
+      }
+
+    static
+    char*
+    assign( char* s, size_t n, char c )
+      {
+        return NS_STATIC_CAST(char*, memset(s, to_int_type(c), n));
+      }
+
+    static
+    int
+    compare( const char* s1, const char* s2, size_t n )
+      {
+        return memcmp(s1, s2, n);
+      }
+
+    static
+    size_t
+    length( const char* s )
+      {
+        return strlen(s);
+      }
+
+    static
+    const char*
+    find( const char* s, size_t n, char c )
+      {
+        return NS_REINTERPRET_CAST(const char*, memchr(s, to_int_type(c), n));
+      }
+
+#if 0
+      // I/O related:
+
+    typedef streamoff off_type;
+    typedef streampos pos_type;
+    typedef mbstate_t state_type;
+
+    static
+    int_type
+    eof()
+      {
+        return EOF;
+      }
+
+    static
+    int
+    not_eof( int c )
+      {
+        return c==eof() ? ~eof() : c;
+      }
+
+    // static state_type get_state( pos_type );
+#endif
+  };
+
+#if 0
+NS_SPECIALIZE_TEMPLATE
+struct nsCharTraits<wchar_t>
+  {
+    typedef wchar_t char_type;
+
+    static
+    void
+    assign( wchar_t& lhs, wchar_t rhs )
+      {
+        lhs = rhs;
+      }
+
+
+      // integer representation of characters:
+
+    typedef wint_t int_type;
+
+    static
+    wchar_t
+    to_char_type( int_type c )
+      {
+        return wchar_t(c);
+      }
+
+    static
+    int_type
+    to_int_type( wchar_t c )
+      {
+        return int_type(c);
+      }
+
+    static
+    nsCharTraits_bool
+    eq_int_type( int_type lhs, int_type rhs )
+      {
+        return lhs == rhs;
+      }
+
+
+      // |char_type| comparisons:
+
+    static
+    nsCharTraits_bool
+    eq( wchar_t lhs, wchar_t rhs )
+      {
+        return lhs == rhs;
+      }
+
+    static
+    nsCharTraits_bool
+    lt( wchar_t lhs, wchar_t rhs )
+      {
+        return lhs < rhs;
+      }
+
+
+      // operations on s[n] arrays:
+
+    static
+    wchar_t*
+    move( wchar_t* s1, const wchar_t* s2, size_t n )
+      {
+        return NS_STATIC_CAST(wchar_t*, wmemmove(s1, s2, n));
+      }
+
+    static
+    wchar_t*
+    copy( wchar_t* s1, const wchar_t* s2, size_t n )
+      {
+        return NS_STATIC_CAST(wchar_t*, wmemcpy(s1, s2, n));
+      }
+
+    static
+    wchar_t*
+    assign( wchar_t* s, size_t n, wchar_t c )
+      {
+        return NS_STATIC_CAST(wchar_t*, wmemset(s, to_int_type(c), n));
+      }
+
+    static
+    int
+    compare( const wchar_t* s1, const wchar_t* s2, size_t n )
+      {
+        return wmemcmp(s1, s2, n);
+      }
+
+    static
+    size_t
+    length( const wchar_t* s )
+      {
+        return wcslen(s);
+      }
+
+    static
+    const wchar_t*
+    find( const wchar_t* s, size_t n, wchar_t c )
+      {
+        return NS_REINTERPRET_CAST(const wchar_t*, wmemchr(s, to_int_type(c), n));
+      }
+
+#if 0
+      // I/O related:
+
+    typedef streamoff off_type;
+    typedef streampos pos_type;
+    typedef mbstate_t state_type;
+
+    static
+    int_type
+    eof()
+      {
+        return WEOF;
+      }
+
+    static
+    int_type
+    not_eof( int_type c )
+      {
+        return c==eof() ? ~eof() : c;
+      }
+
+    // static state_type get_state( pos_type );
+#endif
+  };
+#endif
+
+
+template <class InputIterator>
+struct nsCharSourceTraits
+  {
+    typedef typename InputIterator::difference_type difference_type;
+
+#if 0
+    static
+    PRUint32
+    distance( const InputIterator& first, const InputIterator& last )
+      {
+        // ...
+      }
+#endif
+
+    static
+    PRUint32
+    readable_distance( const InputIterator& iter )
+      {
+        return iter.size_forward();
+      }
+
+    static
+    PRUint32
+    readable_distance( const InputIterator& first, const InputIterator& last )
+      {
+        return PRUint32(SameFragment(first, last) ? last.get()-first.get() : first.size_forward());
+      }
+
+    static
+    const typename InputIterator::value_type*
+    read( const InputIterator& iter )
+      {
+        return iter.get();
+      }
+
+    static
+    void
+    advance( InputIterator& s, difference_type n )
+      {
+        s.advance(n);
+      }
+  };
+
+#ifdef HAVE_CPP_PARTIAL_SPECIALIZATION
+
+template <class CharT>
+struct nsCharSourceTraits<CharT*>
+  {
+    typedef ptrdiff_t difference_type;
+
+#if 0
+    static
+    PRUint32
+    distance( CharT* first, CharT* last )
+      {
+        return PRUint32(last-first);
+      }
+#endif
+
+    static
+    PRUint32
+    readable_distance( CharT* s )
+      {
+        return PRUint32(nsCharTraits<CharT>::length(s));
+//      return numeric_limits<PRUint32>::max();
+      }
+
+    static
+    PRUint32
+    readable_distance( CharT* first, CharT* last )
+      {
+        return PRUint32(last-first);
+      }
+
+    static
+    const CharT*
+    read( CharT* s )
+      {
+        return s;
+      }
+
+    static
+    void
+    advance( CharT*& s, difference_type n )
+      {
+        s += n;
+      }
+  };
+
+#else
+
+NS_SPECIALIZE_TEMPLATE
+struct nsCharSourceTraits<const char*>
+  {
+    typedef ptrdiff_t difference_type;
+
+#if 0
+    static
+    PRUint32
+    distance( const char* first, const char* last )
+      {
+        return PRUint32(last-first);
+      }
+#endif
+
+    static
+    PRUint32
+    readable_distance( const char* s )
+      {
+        return PRUint32(nsCharTraits<char>::length(s));
+//      return numeric_limits<PRUint32>::max();
+      }
+
+    static
+    PRUint32
+    readable_distance( const char* first, const char* last )
+      {
+        return PRUint32(last-first);
+      }
+
+    static
+    const char*
+    read( const char* s )
+      {
+        return s;
+      }
+
+    static
+    void
+    advance( const char*& s, difference_type n )
+      {
+        s += n;
+      }
+ };
+
+
+NS_SPECIALIZE_TEMPLATE
+struct nsCharSourceTraits<const PRUnichar*>
+  {
+    typedef ptrdiff_t difference_type;
+
+#if 0
+    static
+    PRUint32
+    distance( const PRUnichar* first, const PRUnichar* last )
+      {
+        return PRUint32(last-first);
+      }
+#endif
+
+    static
+    PRUint32
+    readable_distance( const PRUnichar* s )
+      {
+        return PRUint32(nsCharTraits<PRUnichar>::length(s));
+//      return numeric_limits<PRUint32>::max();
+      }
+
+    static
+    PRUint32
+    readable_distance( const PRUnichar* first, const PRUnichar* last )
+      {
+        return PRUint32(last-first);
+      }
+
+    static
+    const PRUnichar*
+    read( const PRUnichar* s )
+      {
+        return s;
+      }
+
+    static
+    void
+    advance( const PRUnichar*& s, difference_type n )
+      {
+        s += n;
+      }
+ };
+
+#endif
+
+
+template <class OutputIterator>
+struct nsCharSinkTraits
+  {
+    static
+    PRUint32
+    write( OutputIterator& iter, const typename OutputIterator::value_type* s, PRUint32 n )
+      {
+        return iter.write(s, n);
+      }
+  };
+
+#ifdef HAVE_CPP_PARTIAL_SPECIALIZATION
+
+template <class CharT>
+struct nsCharSinkTraits<CharT*>
+  {
+    static
+    PRUint32
+    write( CharT*& iter, const CharT* s, PRUint32 n )
+      {
+        nsCharTraits<CharT>::move(iter, s, n);
+        iter += n;
+        return n;
+      }
+  };
+
+#else
+
+NS_SPECIALIZE_TEMPLATE
+struct nsCharSinkTraits<char*>
+  {
+    static
+    PRUint32
+    write( char*& iter, const char* s, PRUint32 n )
+      {
+        nsCharTraits<char>::move(iter, s, n);
+        iter += n;
+        return n;
+      }
+  };
+
+NS_SPECIALIZE_TEMPLATE
+struct nsCharSinkTraits<PRUnichar*>
+  {
+    static
+    PRUint32
+    write( PRUnichar*& iter, const PRUnichar* s, PRUint32 n )
+      {
+        nsCharTraits<PRUnichar>::move(iter, s, n);
+        iter += n;
+        return n;
+      }
+  };
+
+#endif
+
+#endif // !defined(nsCharTraits_h___)

mozilla/string/public/nsFragmentedString.h

@@ -0,0 +1,69 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla XPCOM.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 2000 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *   Scott Collins <scc@mozilla.org> (original author)
+ *
+ */
+
+#ifndef nsFragmentedString_h___
+#define nsFragmentedString_h___
+
+  // WORK IN PROGRESS
+
+#ifndef nsAWritableString_h___
+#include "nsAWritableString.h"
+#endif
+
+#ifndef nsSharedBufferList_h___
+#include "nsSharedBufferList.h"
+#endif
+
+
+class nsFragmentedString
+      : public basic_nsAWritableString<PRUnichar>
+    /*
+      ...
+    */
+  {
+    protected:
+      virtual const PRUnichar* GetReadableFragment( nsReadableFragment<PRUnichar>&, nsFragmentRequest, PRUint32 ) const;
+      virtual PRUnichar* GetWritableFragment( nsWritableFragment<PRUnichar>&, nsFragmentRequest, PRUint32 );
+
+    public:
+      nsFragmentedString() { }
+
+      virtual PRUint32 Length() const;
+
+      virtual void SetLength( PRUint32 aNewLength );
+      // virtual void SetCapacity( PRUint32 aNewCapacity );
+
+      // virtual void Cut( PRUint32 cutStart, PRUint32 cutLength );
+
+    protected:
+      // virtual void do_AssignFromReadable( const basic_nsAReadableString<PRUnichar>& );
+      // virtual void do_AppendFromReadable( const basic_nsAReadableString<PRUnichar>& );
+      // virtual void do_InsertFromReadable( const basic_nsAReadableString<PRUnichar>&, PRUint32 );
+      // virtual void do_ReplaceFromReadable( PRUint32, PRUint32, const basic_nsAReadableString<PRUnichar>& );
+
+    private:
+      nsSharedBufferList  mBufferList;
+  };
+
+#endif // !defined(nsFragmentedString_h___)

mozilla/string/public/nsPrintfCString.h

@@ -0,0 +1,93 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is mozilla.org code.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are 
+ * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
+ * Rights Reserved.
+ * 
+ * Original Author:
+ *   Scott Collins <scc@mozilla.org>
+ *
+ * Contributor(s):
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License Version 2 or later (the
+ * "GPL"), in which case the provisions of the GPL are applicable 
+ * instead of those above.  If you wish to allow use of your 
+ * version of this file only under the terms of the GPL and not to
+ * allow others to use your version of this file under the MPL,
+ * indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by
+ * the GPL.  If you do not delete the provisions above, a recipient
+ * may use your version of this file under either the MPL or the
+ * GPL.
+ */
+
+#ifndef nsPrintfCString_h___
+#define nsPrintfCString_h___
+ 
+#include "nsAWritableString.h"
+
+
+  /**
+   * |nsPrintfCString| lets you use a formated |printf| string as an |nsAReadableCString|.
+   *
+   *   myCStr += nsPrintfCString("%f", 13.917);
+   *     // ...a general purpose substitute for |AppendFloat|
+   *
+   * For longer patterns, you'll want to use the constructor that takes a length
+   *
+   *   nsPrintfCString(128, "%f, %f, %f, %f, %f, %f, %f, %i, %f", x, y, z, 3.2, j, k, l, 3, 3.1);
+   *
+   * Exceding the default size (which you must specify in the constructor, it is not determined)
+   * causes an allocation, so avoid that.  If your formatted string exceeds the allocated space, it is
+   * cut off at the size of the buffer, no error is reported (and no out-of-bounds writing occurs).
+   * This class is intended to be useful for numbers and short
+   * strings, not arbitrary formatting of other strings (e.g., with %s).  There is currently no
+   * wide version of this class, since wide |printf| is not generally available.  That means
+   * to get a wide version of your formatted data, you must, e.g.,
+   *
+   *   CopyASCIItoUCS2(nsPrintfCString("%f", 13.917"), myStr);
+   *
+   * That's another good reason to avoid this class for anything but numbers ... as strings can be
+   * much more efficiently handled with |NS_LITERAL_[C]STRING| and |nsLiteral[C]String|.
+   */
+
+class nsPrintfCString
+    : public nsAReadableCString
+  {
+    enum { kLocalBufferSize=15 };
+      // ought to be large enough for most things ... a |long long| needs at most 20 (so you'd better ask)
+      //  pinkerton suggests 7.  We should measure and decide what's appropriate
+
+
+    public:
+      explicit nsPrintfCString( const char* format, ... );
+      nsPrintfCString( size_t n, const char* format, ...);
+     ~nsPrintfCString();
+
+      virtual PRUint32 Length() const;
+
+    protected:
+      virtual const char* GetReadableFragment( nsReadableFragment<char>& aFragment, nsFragmentRequest aRequest, PRUint32 aOffset ) const;
+//    virtual PRBool GetReadableFragment( nsReadableFragment<char>& aFragment, nsFragmentRequest aRequest ) const;
+
+    private:
+      char*     mStart;
+      PRUint32  mLength;
+      char      mLocalBuffer[ kLocalBufferSize + 1 ];
+  };
+
+#endif // !defined(nsPrintfCString_h___)

mozilla/string/public/nsPrivateSharableString.h

@@ -0,0 +1,60 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla strings.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 2000 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *   Scott Collins <scc@mozilla.org> (original author)
+ *
+ */
+
+#ifndef nsPrivateSharableString_h___
+#define nsPrivateSharableString_h___
+
+#ifndef nsBufferHandle_h___
+#include "nsBufferHandle.h"
+#endif
+
+  /**
+   * This class is (will be) part of the machinery that makes
+   * most string implementations in this family share their underlying buffers
+   * when convenient.  It is _not_ part of the abstract string interface,
+   * though other machinery interested in sharing buffers will know about it.
+   */
+template <class CharT>
+class nsPrivateSharableString
+  {
+    public:
+      virtual const nsBufferHandle<CharT>*        GetBufferHandle() const;
+      virtual const nsSharedBufferHandle<CharT>*  GetSharedBufferHandle() const;
+  };
+
+template <class CharT>
+const nsSharedBufferHandle<CharT>*
+nsPrivateSharableString<CharT>::GetSharedBufferHandle() const
+  {
+    return 0;
+  }
+
+template <class CharT>
+const nsBufferHandle<CharT>*
+nsPrivateSharableString<CharT>::GetBufferHandle() const
+  {
+    return GetSharedBufferHandle();
+  }
+
+#endif // !defined(nsPrivateSharableString_h___)

mozilla/string/public/nsReadableUtils.h

@@ -0,0 +1,145 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 2000 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *   Scott Collins <scc@mozilla.org> (original author)
+ *   Johnny Stenbeck <jst@netscape.com>
+ *
+ */
+
+#ifndef nsReadableUtils_h___
+#define nsReadableUtils_h___
+
+  /**
+   * I guess all the routines in this file are all mis-named.
+   * According to our conventions, they should be |NS_xxx|.
+   */
+
+#ifndef nsAWritableString_h___
+#include "nsAWritableString.h"
+#endif
+
+#if 0
+NS_COM size_t Distance( const nsReadingIterator<PRUnichar>&, const nsReadingIterator<PRUnichar>& );
+NS_COM size_t Distance( const nsReadingIterator<char>&, const nsReadingIterator<char>& );
+#endif
+
+
+NS_COM void CopyUCS2toASCII( const nsAReadableString& aSource, nsAWritableCString& aDest );
+NS_COM void CopyASCIItoUCS2( const nsAReadableCString& aSource, nsAWritableString& aDest );
+
+  /**
+   * Returns a new |char| buffer containing a zero-terminated copy of |aSource|.
+   *
+   * Allocates and returns a new |char| buffer which you must free with |nsMemory::Free|.
+   * Performs a lossy encoding conversion by chopping 16-bit wide characters down to 8-bits wide while copying |aSource| to your new buffer.
+   * This conversion is not well defined; but it reproduces legacy string behavior.
+   * The new buffer is zero-terminated, but that may not help you if |aSource| contains embedded nulls.
+   *
+   * @param aSource a 16-bit wide string
+   * @return a new |char| buffer you must free with |nsMemory::Free|.
+   */
+NS_COM char* ToNewCString( const nsAReadableString& aSource );
+
+
+  /**
+   * Returns a new |char| buffer containing a zero-terminated copy of |aSource|.
+   *
+   * Allocates and returns a new |char| buffer which you must free with |nsMemory::Free|.
+   * The new buffer is zero-terminated, but that may not help you if |aSource| contains embedded nulls.
+   *
+   * @param aSource an 8-bit wide string
+   * @return a new |char| buffer you must free with |nsMemory::Free|.
+   */
+NS_COM char* ToNewCString( const nsAReadableCString& aSource );
+
+  /**
+   * Returns a new |char| buffer containing a zero-terminated copy of |aSource|.
+   *
+   * Allocates and returns a new |char| buffer which you must free with |nsMemory::Free|.
+   * Performs a encoding conversion by converting 16-bit wide characters down to UTF8 encoded 8-bits wide string copying |aSource| to your new buffer.
+   * The new buffer is zero-terminated, but that may not help you if |aSource| contains embedded nulls.
+   *
+   * @param aSource a 16-bit wide string
+   * @return a new |char| buffer you must free with |nsMemory::Free|.
+   */
+
+NS_COM char* ToNewUTF8String( const nsAReadableString& aSource );
+
+
+  /**
+   * Returns a new |PRUnichar| buffer containing a zero-terminated copy of |aSource|.
+   *
+   * Allocates and returns a new |char| buffer which you must free with |nsMemory::Free|.
+   * The new buffer is zero-terminated, but that may not help you if |aSource| contains embedded nulls.
+   *
+   * @param aSource a 16-bit wide string
+   * @return a new |PRUnichar| buffer you must free with |nsMemory::Free|.
+   */
+NS_COM PRUnichar* ToNewUnicode( const nsAReadableString& aSource );
+
+
+  /**
+   * Returns a new |PRUnichar| buffer containing a zero-terminated copy of |aSource|.
+   *
+   * Allocates and returns a new |char| buffer which you must free with |nsMemory::Free|.
+   * Performs an encoding conversion by 0-padding 8-bit wide characters up to 16-bits wide while copying |aSource| to your new buffer.
+   * This conversion is not well defined; but it reproduces legacy string behavior.
+   * The new buffer is zero-terminated, but that may not help you if |aSource| contains embedded nulls.
+   *
+   * @param aSource an 8-bit wide string
+   * @return a new |PRUnichar| buffer you must free with |nsMemory::Free|.
+   */
+NS_COM PRUnichar* ToNewUnicode( const nsAReadableCString& aSource );
+
+  /**
+   * Copies |aLength| 16-bit characters from the start of |aSource| to the
+   * |PRUnichar| buffer |aDest|.
+   *
+   * After this operation |aDest| is not null terminated.
+   *
+   * @param aSource a 16-bit wide string
+   * @param aDest a |PRUnichar| buffer
+   * @param aLength the number of 16-bit characters to copy
+   * @return pointer to destination buffer - identical to |aDest|
+   */
+NS_COM PRUnichar* CopyUnicodeTo( const nsAReadableString& aSource,
+                                 PRUnichar* aDest,
+                                 PRUint32 aLength );
+
+
+  /**
+   * Returns |PR_TRUE| if |aString| contains only ASCII characters, that is, characters in the range (0x00, 0x7F).
+   *
+   * @param aString a 16-bit wide string to scan
+   */
+NS_COM PRBool IsASCII( const nsAReadableString& aString );
+
+
+
+  /**
+   * Converts case in place in the argument string.
+   */
+NS_COM void ToUpperCase( nsAWritableString& );
+NS_COM void ToUpperCase( nsAWritableCString& );
+
+NS_COM void ToLowerCase( nsAWritableString& );
+NS_COM void ToLowerCase( nsAWritableCString& );
+
+#endif // !defined(nsReadableUtils_h___)

mozilla/string/public/nsSharedBufferList.h

@@ -0,0 +1,163 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla strings.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 2000 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *   Scott Collins <scc@mozilla.org> (original author)
+ *
+ */
+
+#ifndef nsSharedBufferList_h___
+#define nsSharedBufferList_h___
+
+#ifndef nsBufferHandle_h___
+#include "nsBufferHandle.h"
+  // for |nsSharedBufferHandle|
+#endif
+
+#ifndef nscore_h___
+#include "nscore.h"
+  // for |PRUnichar|
+#endif
+
+#ifndef nsAReadableString_h___
+#include "nsAReadableString.h"
+  // for |nsReadingIterator|
+#endif
+
+  /**
+   * This class forms the basis for several multi-fragment string classes, in
+   * particular: |nsFragmentedString| (though not yet), and |nsSlidingString|/|nsSlidingSubstring|.
+   *
+   * This class is not templated.  It is provided only for |PRUnichar|-based strings.
+   * If we turn out to have a need for multi-fragment ASCII strings, then perhaps we'll templatize
+   * or else duplicate this class.
+   */
+class nsSharedBufferList
+  {
+    public:
+
+      class Buffer
+          : public nsFlexBufferHandle<PRUnichar>
+        {
+          public:
+            Buffer( PRUnichar* aDataStart, PRUnichar* aDataEnd, PRUnichar* aStorageStart, PRUnichar* aStorageEnd, PRBool aIsSingleAllocation=PR_FALSE )
+                : nsFlexBufferHandle<PRUnichar>(aDataStart, aDataEnd, aStorageStart, aStorageEnd)
+              {
+                if ( aIsSingleAllocation )
+                  this->mFlags |= this->kIsSingleAllocationWithBuffer;
+              }
+
+            Buffer* mPrev;
+            Buffer* mNext;
+
+          private:
+              // pass-by-value is explicitly denied
+            Buffer( const Buffer& );          // NOT TO BE IMPLEMENTED
+            void operator=( const Buffer& );  // NOT TO BE IMPLEMENTED
+        };
+
+      struct Position
+        {
+          Buffer*     mBuffer;
+          PRUnichar*  mPosInBuffer;
+
+          Position() { }
+          Position( Buffer* aBuffer, PRUnichar* aPosInBuffer ) : mBuffer(aBuffer), mPosInBuffer(aPosInBuffer) { }
+
+          // Position( const Position& );             -- auto-generated copy-constructor OK
+          // Position& operator=( const Position& );  -- auto-generated copy-assignment OK
+          // ~Position();                             -- auto-generated destructor OK
+
+            // iff |aIter| is a valid iterator into a |nsSharedBufferList|
+          explicit
+          Position( const nsReadingIterator<PRUnichar>& aIter )
+              : mBuffer( NS_CONST_CAST(Buffer*, NS_REINTERPRET_CAST(const Buffer*, aIter.fragment().mFragmentIdentifier)) ),
+                mPosInBuffer( NS_CONST_CAST(PRUnichar*, aIter.get()) )
+            {
+              // nothing else to do here
+            }
+
+            // iff |aIter| is a valid iterator into a |nsSharedBufferList|
+          Position&
+          operator=( const nsReadingIterator<PRUnichar>& aIter )
+            {
+              mBuffer       = NS_CONST_CAST(Buffer*, NS_REINTERPRET_CAST(const Buffer*, aIter.fragment().mFragmentIdentifier));
+              mPosInBuffer  = NS_CONST_CAST(PRUnichar*, aIter.get());
+              return *this;
+            }
+
+          void PointTo( Buffer* aBuffer, PRUnichar* aPosInBuffer )  { mBuffer=aBuffer; mPosInBuffer=aPosInBuffer; }
+          void PointBefore( Buffer* aBuffer )                       { PointTo(aBuffer, aBuffer->DataStart()); }
+          void PointAfter( Buffer* aBuffer )                        { PointTo(aBuffer, aBuffer->DataEnd()); }
+
+          // Position( const Position& );             -- automatically generated copy-constructor is OK
+          // Position& operator=( const Position& );  -- automatically generated copy-assignment operator is OK
+        };
+
+
+
+    public:
+      nsSharedBufferList( Buffer* aBuffer = 0 )
+          : mFirstBuffer(aBuffer),
+            mLastBuffer(aBuffer),
+            mTotalDataLength(0)
+        {
+          if ( aBuffer )
+            {
+              aBuffer->mPrev = aBuffer->mNext = 0;
+              mTotalDataLength = aBuffer->DataLength();
+            }
+        }
+
+      virtual ~nsSharedBufferList();
+
+    private:
+        // pass-by-value is explicitly denied
+      nsSharedBufferList( const nsSharedBufferList& );  // NOT TO BE IMPLEMENTED
+      void operator=( const nsSharedBufferList& );      // NOT TO BE IMPLEMENTED
+
+    public:
+      void    LinkBuffer( Buffer*, Buffer*, Buffer* );
+      Buffer* UnlinkBuffer( Buffer* );
+      void    SplitBuffer( const Position& );
+
+      static Buffer* NewSingleAllocationBuffer( const PRUnichar*, PRUint32, PRUint32 = 0 );
+      static Buffer* NewWrappingBuffer( PRUnichar*, PRUnichar*, PRUnichar* );
+
+      void    DiscardSuffix( PRUint32 );
+        // need other discards: prefix, and by iterator or pointer or something
+
+            Buffer* GetFirstBuffer()        { return mFirstBuffer; }
+      const Buffer* GetFirstBuffer() const  { return mFirstBuffer; }
+      
+            Buffer* GetLastBuffer()         { return mLastBuffer; }
+      const Buffer* GetLastBuffer() const   { return mLastBuffer; }
+      
+      ptrdiff_t     GetDataLength() const   { return mTotalDataLength; }
+
+    protected:
+      void    DestroyBuffers();
+
+    protected:
+      Buffer*   mFirstBuffer;
+      Buffer*   mLastBuffer;
+      ptrdiff_t mTotalDataLength;
+  };
+
+#endif // !defined(nsSharedBufferList_h___)

mozilla/string/public/nsSharedString.h

@@ -0,0 +1,203 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Original Author:
+ *   Scott Collins <scc@mozilla.org>
+ *
+ * Contributor(s):
+ */
+
+#ifndef nsSharedString_h___
+#define nsSharedString_h___
+
+#ifndef nsAReadableString_h___
+#include "nsAReadableString.h"
+#endif
+
+template <class CharT>
+class basic_nsSharedString
+      : public basic_nsAReadableString<CharT>
+    /*
+      ...
+    */
+  {
+    public:
+      basic_nsSharedString( const CharT* data, size_t length )
+          : mRefCount(0), mData(data), mLength(length)
+        {
+          // nothing else to do here
+        }
+
+    private:
+      ~basic_nsSharedString() { } // You can't sub-class me, or make an instance of me on the stack
+
+        // NOT TO BE IMPLEMENTED
+        // we're reference counted, remember.  copying and passing by value are wrong
+      // basic_nsSharedString(); // we define at least one constructor, so the default constructor will not be auto-generated.  It's wrong to create me with no data anyway
+      basic_nsSharedString( const basic_nsSharedString<CharT>& ); // copy-constructor, the auto generated one would reference somebody elses data
+      void operator=( const basic_nsSharedString<CharT>& );       // copy-assignment operator
+      
+      // operator delete?
+
+    public:
+
+      virtual const CharT* GetReadableFragment( nsReadableFragment<CharT>&, nsFragmentRequest, PRUint32 ) const;
+
+      virtual
+      PRUint32
+      Length() const
+        {
+          return mLength;
+        }
+
+      nsrefcnt
+      AddRef() const
+        {
+          return ++mRefCount;
+        }
+
+      nsrefcnt
+      Release() const
+        {
+          nsrefcnt result = --mRefCount;
+          if ( !mRefCount )
+            {
+              // would have to call my destructor by hand here, if there was anything to destruct
+              operator delete(this); // form of |delete| should always match the |new|
+            }
+          return result;
+        }
+
+    private:
+      mutable nsrefcnt  mRefCount;
+      const CharT*      mData;
+      size_t            mLength;
+  };
+
+NS_DEF_TEMPLATE_STRING_COMPARISON_OPERATORS(basic_nsSharedString<CharT>, CharT)
+
+template <class CharT>
+const CharT*
+basic_nsSharedString<CharT>::GetReadableFragment( nsReadableFragment<CharT>& aFragment, nsFragmentRequest aRequest, PRUint32 anOffset ) const
+  {
+    switch ( aRequest )
+      {
+        case kFirstFragment:
+        case kLastFragment:
+        case kFragmentAt:
+          aFragment.mEnd = (aFragment.mStart = mData) + mLength;
+          return aFragment.mStart + anOffset;
+        
+        case kPrevFragment:
+        case kNextFragment:
+        default:
+          return 0;
+      }
+  }
+
+
+
+template <class CharT>
+class basic_nsSharedStringPtr
+  {
+    public:
+        // default constructor
+      basic_nsSharedStringPtr() : mRawPtr(0) { }
+
+        // copy-constructor
+      basic_nsSharedStringPtr( const basic_nsSharedStringPtr<CharT>& rhs )
+          : mRawPtr(rhs.mRawPtr)
+        {
+          mRawPtr->AddRef();
+        }
+
+     ~basic_nsSharedStringPtr()
+        {
+          if ( mRawPtr )
+            mRawPtr->Release();
+        }
+
+        // copy-assignment operator
+      basic_nsSharedStringPtr<CharT>&
+      operator=( const basic_nsSharedStringPtr<CharT>& );
+
+      basic_nsSharedString<CharT>*
+      operator->() const
+        {
+          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL string pointer with operator->().");
+          return mRawPtr;
+        }
+
+      basic_nsSharedString<CharT>&
+      operator*() const
+        {
+          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL string pointer with operator->().");
+          return *mRawPtr;
+        }
+
+    private:
+      const basic_nsSharedString<CharT>*  mRawPtr;
+  };
+
+template <class CharT>
+basic_nsSharedStringPtr<CharT>&
+basic_nsSharedStringPtr<CharT>::operator=( const basic_nsSharedStringPtr<CharT>& rhs )
+    // Not |inline|
+  {
+    if ( rhs.mRawPtr )
+      rhs.mRawPtr->AddRef();
+    basic_nsSharedString<CharT>* oldPtr = mRawPtr;
+    mRawPtr = rhs.mRawPtr;
+    if ( oldPtr )
+      oldPtr->Release();
+  }
+
+
+template <class CharT>
+basic_nsSharedString<CharT>*
+new_nsSharedString( const basic_nsAReadableString<CharT>& aReadable )
+  {
+    size_t object_size    = ((sizeof(basic_nsSharedString<CharT>) + sizeof(CharT) - 1) / sizeof(CharT)) * sizeof(CharT);
+    size_t string_length  = aReadable.Length();
+    size_t string_size    = string_length * sizeof(CharT);
+
+    void* object_ptr = operator new(object_size + string_size);
+    if ( object_ptr )
+      {
+        typedef CharT* CharT_ptr;
+        CharT* string_ptr = CharT_ptr(NS_STATIC_CAST(unsigned char*, object_ptr) + object_size);
+
+        nsReadingIterator<CharT> fromBegin, fromEnd;
+        CharT* toBegin = string_ptr;
+        copy_string(aReadable.BeginReading(fromBegin), aReadable.EndReading(fromEnd), toBegin);
+        return new (object_ptr) basic_nsSharedString<CharT>(string_ptr, string_length);
+      }
+
+    return 0;
+  }
+
+
+typedef basic_nsSharedString<PRUnichar>     nsSharedString;
+typedef basic_nsSharedString<char>          nsSharedCString;
+
+typedef basic_nsSharedStringPtr<PRUnichar>  nsSharedStringPtr;
+typedef basic_nsSharedStringPtr<char>       nsSharedCStringPtr;
+
+
+#endif // !defined(nsSharedString_h___)

mozilla/string/public/nsSlidingString.h

@@ -0,0 +1,135 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla strings.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 2000 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *   Scott Collins <scc@mozilla.org> (original author)
+ *
+ */
+
+#ifndef nsSlidingString_h___
+#define nsSlidingString_h___
+
+#include "nsAReadableString.h"
+#include "nsSharedBufferList.h"
+
+
+  /**
+   * Maintains the sequence from the prev-most referenced buffer to the last buffer.
+   * As prev-most buffers become un-referenced, they are unlinked from the list
+   * and destroyed.
+   *
+   * One or more |nsSlidingSubstring|s may reference into the list.  Each |nsSlidingSubstring|
+   * holds a reference into the prev-most buffer intersecting the 
+   * substring it describes.  The destructor of a |nsSlidingSubstring| releases this
+   * reference, allowing the buffer list to destroy the contiguous prefix of
+   * unreferenced buffers.
+   *
+   * A single instance of |nsSlidingString| may reference this list.
+   * Through that interface, new data can be appended onto the next-most end
+   * of the list.  |nsSlidingString| also the client to advance its starting point.
+   * 
+   */
+class nsSlidingSharedBufferList
+    : public nsSharedBufferList
+  {
+    public:
+      nsSlidingSharedBufferList( Buffer* aBuffer ) : nsSharedBufferList(aBuffer), mRefCount(0) { }
+
+      void  AcquireReference()    { ++mRefCount; }
+      void  ReleaseReference()    { if ( !--mRefCount ) delete this; }
+
+      void  DiscardUnreferencedPrefix( Buffer* );
+
+    private:
+      PRUint32 mRefCount;
+  };
+
+
+
+
+
+  /**
+   * a substring over a buffer list, this 
+   */
+class nsSlidingSubstring
+     : public nsPromiseReadable<PRUnichar>
+  {
+    public:
+      typedef nsSlidingSharedBufferList::Buffer   Buffer;
+      typedef nsSlidingSharedBufferList::Position Position;
+
+      nsSlidingSubstring( const nsSlidingSubstring& );  // copy-constructor
+      nsSlidingSubstring( const nsSlidingSubstring& aString, const nsReadingIterator<PRUnichar>& aStart, const nsReadingIterator<PRUnichar>& aEnd );
+     ~nsSlidingSubstring();
+
+      virtual PRUint32 Length() const { return mLength; }
+
+    protected:
+      nsSlidingSubstring( nsSlidingSharedBufferList& aBufferList );
+      virtual const PRUnichar* GetReadableFragment( nsReadableFragment<PRUnichar>&, nsFragmentRequest, PRUint32 ) const;
+
+    private:
+        // can't assign into me, I'm a read-only reference
+      void operator=( const nsSlidingSubstring& );  // NOT TO BE IMPLEMENTED
+
+    protected:
+      Position                    mStart;
+      Position                    mEnd;
+      nsSlidingSharedBufferList&  mBufferList;
+      PRUint32                    mLength;
+  };
+
+
+
+
+  /**
+   * An |nsSlidingSharedBufferList| may be modified by zero or one instances of this class.
+   *  
+   */
+class nsSlidingString
+    : public nsSlidingSubstring
+  {
+    public:
+      nsSlidingString( PRUnichar* aStorageStart, PRUnichar* aDataEnd, PRUnichar* aStorageEnd );
+        // ...created by consuming ownership of a buffer ... |aStorageStart| must point to something
+        //  that it will be OK for the slidking string to call |nsMemory::Free| on
+
+        // you are giving ownership to the string, it takes and keeps your buffer, deleting it (with |nsMemory::Free|) when done
+      void AppendBuffer( PRUnichar* aStorageStart, PRUnichar* aDataEnd, PRUnichar* aStorageEnd );
+
+//    void Append( ... ); do you want some |Append|s that copy the supplied data?
+
+      void DiscardPrefix( const nsReadingIterator<PRUnichar>& );
+        // any other way you want to do this?
+
+    private:
+      nsSlidingString( const nsSlidingString& );  // NOT TO BE IMPLEMENTED
+      void operator=( const nsSlidingString& );   // NOT TO BE IMPLEMENTED
+  };
+
+
+#if 0
+  // this (or something similar) is what should appear in the parser, I think
+#include "nsSlidingString.h"
+
+typedef nsSlidingString     nsParserString;
+typedef nsSlidingSubstring  nsParserToken;
+#endif
+
+#endif // !defined(nsSlidingString_h___)

mozilla/string/src/nsFragmentedString.cpp

@@ -0,0 +1,162 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla XPCOM.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 2000 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Original Author:
+ *   Scott Collins <scc@mozilla.org>
+ *
+ * Contributor(s):
+ */
+
+#include "nsFragmentedString.h"
+
+
+const PRUnichar*
+nsFragmentedString::GetReadableFragment( nsReadableFragment<PRUnichar>& aFragment, nsFragmentRequest aRequest, PRUint32 aOffset ) const
+  {
+    const nsSharedBufferList::Buffer* buffer = 0;
+    switch ( aRequest )
+      {
+        case kPrevFragment:
+          buffer = NS_STATIC_CAST(const nsSharedBufferList::Buffer*, aFragment.mFragmentIdentifier)->mPrev;
+          break;
+
+        case kFirstFragment:
+          buffer = mBufferList.GetFirstBuffer();
+          break;
+
+        case kLastFragment:
+          buffer = mBufferList.GetLastBuffer();
+          break;
+
+        case kNextFragment:
+          buffer = NS_STATIC_CAST(const nsSharedBufferList::Buffer*, aFragment.mFragmentIdentifier)->mNext;
+          break;
+
+        case kFragmentAt:
+          // ...work...
+          break;
+      }
+
+    if ( buffer )
+      {
+        aFragment.mStart  = buffer->DataStart();
+        aFragment.mEnd    = buffer->DataEnd();
+        aFragment.mFragmentIdentifier = buffer;
+        return aFragment.mStart + aOffset;
+      }
+
+    return 0;
+  }
+
+
+PRUnichar*
+nsFragmentedString::GetWritableFragment( nsWritableFragment<PRUnichar>& aFragment, nsFragmentRequest aRequest, PRUint32 aOffset )
+  {
+    nsSharedBufferList::Buffer* buffer = 0;
+    switch ( aRequest )
+      {
+        case kPrevFragment:
+          buffer = NS_STATIC_CAST(nsSharedBufferList::Buffer*, aFragment.mFragmentIdentifier)->mPrev;
+          break;
+
+        case kFirstFragment:
+          buffer = mBufferList.GetFirstBuffer();
+          break;
+
+        case kLastFragment:
+          buffer = mBufferList.GetLastBuffer();
+          break;
+
+        case kNextFragment:
+          buffer = NS_STATIC_CAST(nsSharedBufferList::Buffer*, aFragment.mFragmentIdentifier)->mNext;
+          break;
+
+        case kFragmentAt:
+          // ...work...
+          break;
+      }
+
+    if ( buffer )
+      {
+        aFragment.mStart  = buffer->DataStart();
+        aFragment.mEnd    = buffer->DataEnd();
+        aFragment.mFragmentIdentifier = buffer;
+        return aFragment.mStart + aOffset;
+      }
+
+    return 0;
+  }
+
+  /**
+   * ...
+   */
+PRUint32
+nsFragmentedString::Length() const
+  {
+    return PRUint32(mBufferList.GetDataLength());
+  }
+
+  /**
+   * |SetLength|
+   */
+void
+nsFragmentedString::SetLength( PRUint32 aNewLength )
+  {
+    // according to the current interpretation of |SetLength|,
+    //  cut off characters from the end, or else add unitialized space to fill
+
+    if ( aNewLength < mBufferList.GetDataLength() )
+      {
+//      if ( aNewLength )
+          mBufferList.DiscardSuffix(mBufferList.GetDataLength()-aNewLength);
+//      else
+//        mBufferList.DestroyBuffers();
+      }
+
+// temporarily... eliminate as soon as our munging routines don't need this form of |SetLength|
+    else if ( aNewLength > mBufferList.GetDataLength() )
+      {
+        size_t empty_space_to_add = aNewLength - mBufferList.GetDataLength();
+        nsSharedBufferList::Buffer* new_buffer = nsSharedBufferList::NewSingleAllocationBuffer(0, 0, empty_space_to_add);
+        new_buffer->DataEnd(new_buffer->DataStart()+empty_space_to_add);
+        mBufferList.LinkBuffer(mBufferList.GetLastBuffer(), new_buffer, 0);
+      }
+  }
+
+
+#if 0
+  /**
+   * |SetCapacity|.
+   *
+   * If a client tries to increase the capacity of multi-fragment string, perhaps a single
+   * empty fragment of the appropriate size should be appended.
+   */
+void
+nsFragmentedString::SetCapacity( PRUint32 aNewCapacity )
+  {
+    if ( !aNewCapacity )
+      {
+        // |SetCapacity(0)| is special and means ``release all storage''.
+      }
+    else if ( aNewCapacity > ... )
+      {
+        
+      }
+  }
+#endif

mozilla/string/src/nsPrintfCString.cpp

@@ -0,0 +1,135 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is mozilla.org code.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are 
+ * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
+ * Rights Reserved.
+ * 
+ * Original Author:
+ *   Scott Collins <scc@mozilla.org>
+ *
+ * Contributor(s):
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License Version 2 or later (the
+ * "GPL"), in which case the provisions of the GPL are applicable 
+ * instead of those above.  If you wish to allow use of your 
+ * version of this file only under the terms of the GPL and not to
+ * allow others to use your version of this file under the MPL,
+ * indicate your decision by deleting the provisions above and
+ * replace them with the notice and other provisions required by
+ * the GPL.  If you do not delete the provisions above, a recipient
+ * may use your version of this file under either the MPL or the
+ * GPL.
+ */
+
+#include "nsPrintfCString.h"
+#include <stdarg.h>
+#include "prprf.h"
+
+
+nsPrintfCString::nsPrintfCString( const char* format, ... )
+    : mStart(mLocalBuffer),
+      mLength(0)
+  {
+    va_list ap;
+
+    size_t logical_capacity = kLocalBufferSize;
+    size_t physical_capacity = logical_capacity + 1;
+
+    va_start(ap, format);
+    mLength = PR_vsnprintf(mStart, physical_capacity, format, ap);
+    va_end(ap);
+  }
+
+nsPrintfCString::nsPrintfCString( size_t n, const char* format, ... )
+    : mStart(mLocalBuffer),
+      mLength(0)
+  {
+    va_list ap;
+
+      // make sure there's at least |n| space
+    size_t logical_capacity = kLocalBufferSize;
+    if ( n > logical_capacity )
+      {
+        char* nonlocal_buffer = new char[n];
+
+          // if we got something, use it
+        if ( nonlocal_buffer )
+          {
+            mStart = nonlocal_buffer;
+            logical_capacity = n;
+          }
+        // else, it's the error case ... we'll use what space we have
+        //  (since we can't throw)
+      }
+    size_t physical_capacity = logical_capacity + 1;
+
+    va_start(ap, format);
+    mLength = PR_vsnprintf(mStart, physical_capacity, format, ap);
+    va_end(ap);
+  }
+
+nsPrintfCString::~nsPrintfCString()
+  {
+    if ( mStart != mLocalBuffer )
+      delete [] mStart;
+  }
+
+PRUint32
+nsPrintfCString::Length() const
+  {
+    return mLength;
+  }
+
+#if 0
+PRBool
+nsPrintfCString::GetReadableFragment( nsReadableFragment<char>& aFragment, nsFragmentRequest aRequest ) const
+  {
+    switch ( aRequest )
+      {
+        case kFirstFragment:
+        case kLastFragment:
+          aFragment.mFragmentIdentifier = this;
+          // fall through
+        case kThisFragment:
+          aFragment.mStart = mStart;
+          aFragment.mEnd = mStart + mLength;
+          return PR_TRUE;
+
+        default:
+          return PR_FALSE;
+      }
+  }
+#else
+const char*
+nsPrintfCString::GetReadableFragment( nsReadableFragment<char>& aFragment, nsFragmentRequest aRequest, PRUint32 aOffset ) const
+  {
+    switch ( aRequest )
+      {
+        case kFirstFragment:
+        case kLastFragment:
+        case kFragmentAt:
+          aFragment.mEnd = (aFragment.mStart = mStart) + mLength;
+          return mStart + aOffset;
+
+        case kPrevFragment:
+        case kNextFragment:
+          default:
+          return 0;
+      }
+  }
+#endif
+

mozilla/string/src/nsReadableUtils.cpp

@@ -0,0 +1,343 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 2000 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *   Scott Collins <scc@mozilla.org> (original author)
+ */
+
+#include "nsReadableUtils.h"
+#include "nsMemory.h"
+#include "nsString.h"
+#include "nsCRT.h"
+
+
+template <class CharT> class CalculateLength
+  {
+    public:
+      typedef CharT value_type;
+
+      CalculateLength() : mDistance(0) { }
+      size_t GetDistance() const       { return mDistance; }
+
+      PRUint32 write( const CharT*, PRUint32 N )
+                                       { mDistance += N; return N; }
+    private:
+      size_t mDistance;
+  };
+
+template <class CharT>
+inline
+size_t
+Distance_Impl( const nsReadingIterator<CharT>& aStart,
+          const nsReadingIterator<CharT>& aEnd )
+  {
+    CalculateLength<CharT> sink;
+    nsReadingIterator<CharT> fromBegin(aStart);
+    copy_string(fromBegin, aEnd, sink);
+    return sink.GetDistance();
+  }
+
+NS_COM
+size_t
+Distance( const nsReadingIterator<PRUnichar>& aStart, const nsReadingIterator<PRUnichar>& aEnd )
+  {
+    return Distance_Impl(aStart, aEnd);
+  }
+
+NS_COM
+size_t
+Distance( const nsReadingIterator<char>& aStart, const nsReadingIterator<char>& aEnd )
+  {
+    return Distance_Impl(aStart, aEnd);
+  }
+
+
+
+  /**
+   * A character sink that performs a |reinterpret_cast| style conversion between character types.
+   */
+template <class FromCharT, class ToCharT>
+class LossyConvertEncoding
+  {
+    public:
+      typedef FromCharT value_type;
+ 
+      typedef FromCharT input_type;
+      typedef ToCharT   output_type;
+
+    public:
+      LossyConvertEncoding( output_type* aDestination ) : mDestination(aDestination) { }
+
+      PRUint32
+      write( const input_type* aSource, PRUint32 aSourceLength )
+        {
+          const input_type* done_writing = aSource + aSourceLength;
+          while ( aSource < done_writing )
+            *mDestination++ = (output_type)(*aSource++);  // use old-style cast to mimic old |ns[C]String| behavior
+          return aSourceLength;
+        }
+
+      void
+      write_terminator()
+        {
+          *mDestination = output_type(0);
+        }
+
+    private:
+      output_type* mDestination;
+  };
+
+
+NS_COM
+void
+CopyUCS2toASCII( const nsAReadableString& aSource, nsAWritableCString& aDest )
+  {
+      // right now, this won't work on multi-fragment destinations
+    aDest.SetLength(aSource.Length());
+
+    nsReadingIterator<PRUnichar> fromBegin, fromEnd;
+
+    nsWritingIterator<char> toBegin;
+    LossyConvertEncoding<PRUnichar, char> converter(aDest.BeginWriting(toBegin).get());
+    
+    copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd), converter);
+  }
+
+NS_COM
+void
+CopyASCIItoUCS2( const nsAReadableCString& aSource, nsAWritableString& aDest )
+  {
+      // right now, this won't work on multi-fragment destinations
+    aDest.SetLength(aSource.Length());
+
+    nsReadingIterator<char> fromBegin, fromEnd;
+
+    nsWritingIterator<PRUnichar> toBegin;
+    LossyConvertEncoding<char, PRUnichar> converter(aDest.BeginWriting(toBegin).get());
+
+    copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd), converter);
+  }
+
+
+  /**
+   * A helper function that allocates a buffer of the desired character type big enough to hold a copy of the supplied string (plus a zero terminator).
+   *
+   * @param aSource an string you will eventually be making a copy of
+   * @return a new buffer (of the type specified by the second parameter) which you must free with |nsMemory::Free|.
+   *
+   */
+template <class FromCharT, class ToCharT>
+inline
+ToCharT*
+AllocateStringCopy( const basic_nsAReadableString<FromCharT>& aSource, ToCharT* )
+  {
+    return NS_STATIC_CAST(ToCharT*, nsMemory::Alloc((aSource.Length()+1) * sizeof(ToCharT)));
+  }
+
+
+NS_COM
+char*
+ToNewCString( const nsAReadableString& aSource )
+  {
+    char* result = AllocateStringCopy(aSource, (char*)0);
+
+    nsReadingIterator<PRUnichar> fromBegin, fromEnd;
+    LossyConvertEncoding<PRUnichar, char> converter(result);
+    copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd), converter).write_terminator();
+    return result;
+  }
+
+NS_COM
+char*
+ToNewUTF8String( const nsAReadableString& aSource )
+  {
+    NS_ConvertUCS2toUTF8 temp(aSource);
+
+    char* result;
+    if (temp.mOwnsBuffer) {
+      // We allocated. Trick the string into not freeing its buffer to
+      // avoid an extra allocation.
+      result = temp.mStr;
+
+      temp.mStr=0;
+      temp.mOwnsBuffer = PR_FALSE;
+    }
+    else {
+      // We didn't allocate a buffer, so we need to copy it out of the
+      // nsCAutoString's storage.
+      result = nsCRT::strdup(temp.mStr);
+    }
+
+    return result;
+  }
+
+NS_COM
+char*
+ToNewCString( const nsAReadableCString& aSource )
+  {
+    // no conversion needed, just allocate a buffer of the correct length and copy into it
+
+    char* result = AllocateStringCopy(aSource, (char*)0);
+
+    nsReadingIterator<char> fromBegin, fromEnd;
+    char* toBegin = result;
+    *copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd), toBegin) = char(0);
+    return result;
+  }
+
+NS_COM
+PRUnichar*
+ToNewUnicode( const nsAReadableString& aSource )
+  {
+    // no conversion needed, just allocate a buffer of the correct length and copy into it
+
+    PRUnichar* result = AllocateStringCopy(aSource, (PRUnichar*)0);
+
+    nsReadingIterator<PRUnichar> fromBegin, fromEnd;
+    PRUnichar* toBegin = result;
+    *copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd), toBegin) = PRUnichar(0);
+    return result;
+  }
+
+NS_COM
+PRUnichar*
+ToNewUnicode( const nsAReadableCString& aSource )
+  {
+    PRUnichar* result = AllocateStringCopy(aSource, (PRUnichar*)0);
+
+    nsReadingIterator<char> fromBegin, fromEnd;
+    LossyConvertEncoding<char, PRUnichar> converter(result);
+    copy_string(aSource.BeginReading(fromBegin), aSource.EndReading(fromEnd), converter).write_terminator();
+    return result;
+  }
+
+NS_COM
+PRUnichar*
+CopyUnicodeTo( const nsAReadableString& aSource, PRUnichar* aDest, PRUint32 aLength )
+  {
+    nsReadingIterator<PRUnichar> fromBegin, fromEnd;
+    PRUnichar* toBegin = aDest;
+    copy_string(aSource.BeginReading(fromBegin), aSource.BeginReading(fromEnd).advance( PRInt32(aLength) ), toBegin);
+    return aDest;
+  }
+
+NS_COM
+PRBool
+IsASCII( const nsAReadableString& aString )
+  {
+    static const PRUnichar NOT_ASCII = PRUnichar(~0x007F);
+
+
+    // Don't want to use |copy_string| for this task, since we can stop at the first non-ASCII character
+
+    nsReadingIterator<PRUnichar> done_reading;
+    aString.EndReading(done_reading);
+
+      // for each chunk of |aString|...
+    PRUint32 fragmentLength = 0;
+    nsReadingIterator<PRUnichar> iter;
+    for ( aString.BeginReading(iter); iter != done_reading; iter.advance( PRInt32(fragmentLength) ) )
+      {
+        fragmentLength = PRUint32(iter.size_forward());
+        const PRUnichar* c = iter.get();
+        const PRUnichar* fragmentEnd = c + fragmentLength;
+
+          // for each character in this chunk...
+        while ( c < fragmentEnd )
+          if ( *c++ & NOT_ASCII )
+            return PR_FALSE;
+      }
+
+    return PR_TRUE;
+  }
+
+
+
+  /**
+   * A character sink for case conversion.
+   */
+template <class CharT>
+class ConvertToUpperCase
+  {
+    public:
+      typedef CharT value_type;
+
+      PRUint32
+      write( const CharT* aSource, PRUint32 aSourceLength )
+        {
+          for ( int i=0; i<aSourceLength; ++i )
+            NS_CONST_CAST(CharT*, aSource)[i] = nsCRT::ToUpper(aSource[i]);
+          return aSourceLength;
+        }
+  };
+
+NS_COM
+void
+ToUpperCase( nsAWritableString& aString )
+  {
+    nsAWritableString::iterator fromBegin, fromEnd;
+    ConvertToUpperCase<PRUnichar> converter;
+    copy_string(aString.BeginWriting(fromBegin), aString.EndWriting(fromEnd), converter);
+  }
+
+NS_COM
+void
+ToUpperCase( nsAWritableCString& aCString )
+  {
+    nsAWritableCString::iterator fromBegin, fromEnd;
+    ConvertToUpperCase<char> converter;
+    copy_string(aCString.BeginWriting(fromBegin), aCString.EndWriting(fromEnd), converter);
+  }
+
+
+  /**
+   * A character sink for case conversion.
+   */
+template <class CharT>
+class ConvertToLowerCase
+  {
+    public:
+      typedef CharT value_type;
+
+      PRUint32
+      write( const CharT* aSource, PRUint32 aSourceLength )
+        {
+          for ( int i=0; i<aSourceLength; ++i )
+            NS_CONST_CAST(CharT*, aSource)[i] = nsCRT::ToLower(aSource[i]);
+          return aSourceLength;
+        }
+  };
+
+NS_COM
+void
+ToLowerCase( nsAWritableString& aString )
+  {
+    nsAWritableString::iterator fromBegin, fromEnd;
+    ConvertToLowerCase<PRUnichar> converter;
+    copy_string(aString.BeginWriting(fromBegin), aString.EndWriting(fromEnd), converter);
+  }
+
+NS_COM
+void
+ToLowerCase( nsAWritableCString& aCString )
+  {
+    nsAWritableCString::iterator fromBegin, fromEnd;
+    ConvertToLowerCase<char> converter;
+    copy_string(aCString.BeginWriting(fromBegin), aCString.EndWriting(fromEnd), converter);
+  }

mozilla/string/src/nsSharedBufferList.cpp

@@ -0,0 +1,186 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla strings.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 2000 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *   Scott Collins <scc@mozilla.org> (original author)
+ *
+ */
+
+#include "nsSharedBufferList.h"
+#include "nsAlgorithm.h"
+  // for |copy_string|
+#include <new.h>
+
+
+void
+nsSharedBufferList::DestroyBuffers()
+  {
+      // destroy the entire list of buffers, without bothering to manage their links
+    Buffer* next_buffer;
+    for ( Buffer* cur_buffer=mFirstBuffer; cur_buffer; cur_buffer=next_buffer )
+      {
+        next_buffer = cur_buffer->mNext;
+        operator delete(cur_buffer);
+      }
+    mFirstBuffer = mLastBuffer = 0;
+    mTotalDataLength = 0;
+  }
+
+nsSharedBufferList::~nsSharedBufferList()
+  {
+    DestroyBuffers();
+  }
+
+
+nsSharedBufferList::Buffer*
+nsSharedBufferList::NewSingleAllocationBuffer( const PRUnichar* aData, PRUint32 aDataLength, PRUint32 aAdditionalSpace )
+  {
+    size_t    object_size    = ((sizeof(Buffer) + sizeof(PRUnichar) - 1) / sizeof(PRUnichar)) * sizeof(PRUnichar);
+    PRUint32  buffer_length  = aDataLength + aAdditionalSpace;
+    size_t    buffer_size    = size_t(buffer_length) * sizeof(PRUnichar);
+
+    void* object_ptr = operator new(object_size + buffer_size);
+    if ( object_ptr )
+      {
+        typedef PRUnichar* PRUnichar_ptr;
+        PRUnichar* buffer_ptr = PRUnichar_ptr(NS_STATIC_CAST(unsigned char*, object_ptr) + object_size);
+        if ( aDataLength )
+          {
+            PRUnichar* toBegin = buffer_ptr;
+            copy_string(aData, aData+aDataLength, toBegin);
+          }
+        return new (object_ptr) Buffer(buffer_ptr, buffer_ptr+aDataLength, buffer_ptr, buffer_ptr+buffer_length, PR_TRUE);
+      }
+
+    return 0;
+  }
+
+nsSharedBufferList::Buffer*
+nsSharedBufferList::NewWrappingBuffer( PRUnichar* aDataStart, PRUnichar* aDataEnd, PRUnichar* aStorageEnd )
+  {
+    return new Buffer(aDataStart, aDataEnd, aDataStart, aStorageEnd);
+  }
+
+
+
+void
+nsSharedBufferList::LinkBuffer( Buffer* aPrevBuffer, Buffer* aNewBuffer, Buffer* aNextBuffer )
+  {
+    NS_ASSERTION(aNewBuffer, "aNewBuffer");
+    NS_ASSERTION(aPrevBuffer || mFirstBuffer == aNextBuffer, "aPrevBuffer || mFirstBuffer == aNextBuffer");
+    NS_ASSERTION(!aPrevBuffer || aPrevBuffer->mNext == aNextBuffer, "!aPrevBuffer || aPrevBuffer->mNext == aNextBuffer");
+    NS_ASSERTION(aNextBuffer || mLastBuffer == aPrevBuffer, "aNextBuffer || mLastBuffer == aPrevBuffer");
+    NS_ASSERTION(!aNextBuffer || aNextBuffer->mPrev == aPrevBuffer, "!aNextBuffer || aNextBuffer->mPrev == aPrevBuffer");
+
+    if ( (aNewBuffer->mPrev = aPrevBuffer) )
+      aPrevBuffer->mNext = aNewBuffer;
+    else
+      mFirstBuffer = aNewBuffer;
+
+    if ( (aNewBuffer->mNext = aNextBuffer) )
+      aNextBuffer->mPrev = aNewBuffer;
+    else
+      mLastBuffer = aNewBuffer;
+
+    mTotalDataLength += aNewBuffer->DataLength();
+  }
+
+void
+nsSharedBufferList::SplitBuffer( const Position& aSplitPosition )
+  {
+    Buffer* bufferToSplit = aSplitPosition.mBuffer;
+
+    NS_ASSERTION(bufferToSplit, "bufferToSplit");
+
+    ptrdiff_t splitOffset = aSplitPosition.mPosInBuffer - bufferToSplit->DataStart();
+
+    NS_ASSERTION(0 <= splitOffset && splitOffset <= bufferToSplit->DataLength(), "|splitOffset| within buffer");
+
+    if ( (bufferToSplit->DataLength() >> 1) > splitOffset )
+      {
+        Buffer* new_buffer = NewSingleAllocationBuffer(bufferToSplit->DataStart(), PRUint32(splitOffset));
+        LinkBuffer(bufferToSplit->mPrev, new_buffer, bufferToSplit);
+        bufferToSplit->DataStart(aSplitPosition.mPosInBuffer);
+      }
+    else
+      {
+        Buffer* new_buffer = NewSingleAllocationBuffer(bufferToSplit->DataStart()+splitOffset, PRUint32(bufferToSplit->DataLength()-splitOffset));
+        LinkBuffer(bufferToSplit, new_buffer, bufferToSplit->mNext);
+        bufferToSplit->DataEnd(aSplitPosition.mPosInBuffer);
+      }
+  }
+
+
+nsSharedBufferList::Buffer*
+nsSharedBufferList::UnlinkBuffer( Buffer* aBufferToUnlink )
+  {
+    NS_ASSERTION(aBufferToUnlink, "aBufferToUnlink");
+
+    Buffer* prev_buffer = aBufferToUnlink->mPrev;
+    Buffer* next_buffer = aBufferToUnlink->mNext;
+
+    if ( prev_buffer )
+      prev_buffer->mNext = next_buffer;
+    else
+      mFirstBuffer = next_buffer;
+
+    if ( next_buffer )
+      next_buffer->mPrev = prev_buffer;
+    else
+      mLastBuffer = prev_buffer;
+
+    mTotalDataLength -= aBufferToUnlink->DataLength();
+
+    return aBufferToUnlink;
+  }
+
+
+void
+nsSharedBufferList::DiscardSuffix( PRUint32 /* aLengthToDiscard */ )
+  {
+    // XXX
+  }
+
+
+
+#if 0
+template <class CharT>
+void
+nsChunkList<CharT>::CutTrailingData( PRUint32 aLengthToCut )
+  {
+    Chunk* chunk = mLastChunk;
+    while ( chunk && aLengthToCut )
+      {
+        Chunk* prev_chunk = chunk->mPrev;
+        if ( aLengthToCut < chunk->mDataLength )
+          {
+            chunk->mDataLength -= aLengthToCut;
+            aLengthToCut = 0;
+          }
+        else
+          {
+            RemoveChunk(chunk);
+            aLengthToCut -= chunk->mDataLength;
+            operator delete(chunk);
+          }
+
+        chunk = prev_chunk;
+      }
+  }
+#endif

mozilla/string/src/nsSlidingString.cpp

@@ -0,0 +1,180 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla strings.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 2000 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *   Scott Collins <scc@mozilla.org> (original author)
+ *
+ */
+
+#include "nsSlidingString.h"
+
+void
+nsSlidingSharedBufferList::DiscardUnreferencedPrefix( Buffer* aRecentlyReleasedBuffer )
+  {
+    if ( aRecentlyReleasedBuffer == mFirstBuffer )
+      {
+        while ( mFirstBuffer && !mFirstBuffer->IsReferenced() )
+          delete UnlinkBuffer(mFirstBuffer);
+      }
+  }
+
+
+ptrdiff_t Distance( const nsSharedBufferList::Position&, const nsSharedBufferList::Position& );
+
+ptrdiff_t
+Distance( const nsSharedBufferList::Position& aStart, const nsSharedBufferList::Position& aEnd )
+  {
+    ptrdiff_t result = 0;
+    if ( aStart.mBuffer == aEnd.mBuffer )
+      result = aEnd.mPosInBuffer - aStart.mPosInBuffer;
+    else
+      {
+        result = aStart.mBuffer->DataEnd() - aStart.mPosInBuffer;
+        for ( nsSharedBufferList::Buffer* b = aStart.mBuffer->mNext; b != aEnd.mBuffer; b = b->mNext )
+          result += b->DataLength();
+        result += aEnd.mPosInBuffer - aEnd.mBuffer->DataStart();
+      }
+
+    return result;
+  }
+
+nsSlidingSubstring::nsSlidingSubstring( const nsSlidingSubstring& aString )
+    : mStart(aString.mStart),
+      mEnd(aString.mEnd),
+      mBufferList(aString.mBufferList),
+      mLength(aString.mLength)
+  {
+    mBufferList.AcquireReference();
+    mStart.mBuffer->AcquireReference();
+  }
+
+nsSlidingSubstring::nsSlidingSubstring( const nsSlidingSubstring& aString, const nsReadingIterator<PRUnichar>& aStart, const nsReadingIterator<PRUnichar>& aEnd )
+    : mStart(aStart),
+      mEnd(aEnd),
+      mBufferList(aString.mBufferList),
+      mLength(PRUint32(Distance(mStart, mEnd)))
+  {
+    mBufferList.AcquireReference();
+    mStart.mBuffer->AcquireReference();
+  }
+
+nsSlidingSubstring::nsSlidingSubstring( nsSlidingSharedBufferList& aBufferList )
+    : mBufferList(aBufferList)
+  {
+    mBufferList.AcquireReference();
+
+    mStart.PointBefore(mBufferList.GetFirstBuffer());
+    mStart.mBuffer->AcquireReference();
+
+    mEnd.PointAfter(mBufferList.GetLastBuffer());
+    mLength = PRUint32(Distance(mStart, mEnd));
+  }
+
+nsSlidingSubstring::~nsSlidingSubstring()
+  {
+    mStart.mBuffer->ReleaseReference();
+    mBufferList.DiscardUnreferencedPrefix(mStart.mBuffer);
+    mBufferList.ReleaseReference();
+  }
+
+const PRUnichar*
+nsSlidingSubstring::GetReadableFragment( nsReadableFragment<PRUnichar>& aFragment, nsFragmentRequest aRequest, PRUint32 aOffset ) const
+  {
+    const Buffer* result_buffer = 0;
+    switch ( aRequest )
+      {
+        case kPrevFragment:
+          {
+            const Buffer* current_buffer = NS_STATIC_CAST(const Buffer*, aFragment.mFragmentIdentifier);
+            if ( current_buffer != mStart.mBuffer )
+              result_buffer = current_buffer->mPrev;
+          }
+          break;
+
+        case kFirstFragment:
+          result_buffer = mStart.mBuffer;
+          break;
+
+        case kLastFragment:
+          result_buffer = mEnd.mBuffer;
+          break;
+
+        case kNextFragment:
+          {
+            const Buffer* current_buffer = NS_STATIC_CAST(const Buffer*, aFragment.mFragmentIdentifier);
+            if ( current_buffer != mEnd.mBuffer )
+              result_buffer = current_buffer->mNext;
+          }
+          break;
+
+        case kFragmentAt:
+          // ...work...
+          break;
+      }
+
+    if ( result_buffer )
+      {
+        if ( result_buffer == mStart.mBuffer )
+          aFragment.mStart = mStart.mPosInBuffer;
+        else
+          aFragment.mStart = result_buffer->DataStart();
+
+        if ( result_buffer == mEnd.mBuffer )
+          aFragment.mEnd = mEnd.mPosInBuffer;
+        else
+          aFragment.mEnd = result_buffer->DataEnd();
+
+        aFragment.mFragmentIdentifier = result_buffer;
+        return aFragment.mStart + aOffset;
+      }
+
+    return 0;
+  }
+
+
+
+nsSlidingString::nsSlidingString( PRUnichar* aStorageStart, PRUnichar* aDataEnd, PRUnichar* aStorageEnd )
+    : nsSlidingSubstring(*(new nsSlidingSharedBufferList(nsSlidingSharedBufferList::NewWrappingBuffer(aStorageStart, aDataEnd, aStorageEnd))))
+  {
+    // nothing else to do here
+  }
+
+void
+nsSlidingString::AppendBuffer( PRUnichar* aStorageStart, PRUnichar* aDataEnd, PRUnichar* aStorageEnd )
+  {
+    Buffer* new_buffer = new Buffer(aStorageStart, aDataEnd, aStorageStart, aStorageEnd);
+    Buffer* old_last_buffer = mBufferList.GetLastBuffer();
+    mBufferList.LinkBuffer(old_last_buffer, new_buffer, 0);
+    mLength += new_buffer->DataLength();
+
+    mEnd.PointAfter(new_buffer);
+  }
+
+void
+nsSlidingString::DiscardPrefix( const nsReadingIterator<PRUnichar>& aIter )
+  {
+    Position old_start(mStart);
+    mStart = aIter;
+    mLength -= Distance(old_start, mStart);
+
+    mStart.mBuffer->AcquireReference();
+    old_start.mBuffer->ReleaseReference();
+
+    mBufferList.DiscardUnreferencedPrefix(old_start.mBuffer);
+  }

mozilla/tools/trace-malloc/bloatblame.c

@@ -0,0 +1,746 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is nsTraceMalloc.c/bloatblame.c code, released
+ * April 19, 2000.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 2000 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *    Brendan Eich, 14-April-2000
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the MPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#ifdef HAVE_GETOPT_H
+#include <getopt.h>
+#else
+extern int  getopt(int argc, char *const *argv, const char *shortopts);
+extern char *optarg;
+extern int  optind;
+#endif
+#include <math.h>
+#include <time.h>
+#include <sys/stat.h>
+#include "prtypes.h"
+#include "prlog.h"
+#include "prprf.h"
+#include "plhash.h"
+#include "nsTraceMalloc.h"
+#include "tmreader.h"
+
+static char   *program;
+static int    sort_by_direct = 0;
+static int    js_mode = 0;
+static int    do_tree_dump = 0;
+static int    unified_output = 0;
+static char   *function_dump = NULL;
+static uint32 min_subtotal = 0;
+
+static void compute_callsite_totals(tmcallsite *site)
+{
+    tmcallsite *kid;
+
+    site->allocs.bytes.total += site->allocs.bytes.direct;
+    site->allocs.calls.total += site->allocs.calls.direct;
+    for (kid = site->kids; kid; kid = kid->siblings) {
+        compute_callsite_totals(kid);
+        site->allocs.bytes.total += kid->allocs.bytes.total;
+        site->allocs.calls.total += kid->allocs.calls.total;
+    }
+}
+
+static void walk_callsite_tree(tmcallsite *site, int level, int kidnum, FILE *fp)
+{
+    tmcallsite *parent;
+    tmgraphnode *meth, *pmeth, *comp, *pcomp, *lib, *plib;
+    int old_meth_low, old_comp_low, old_lib_low, nkids;
+    tmcallsite *kid;
+
+    parent = site->parent;
+    meth = comp = lib = NULL;
+    if (parent) {
+        meth = site->method;
+        if (meth) {
+            pmeth = parent->method;
+            if (pmeth && pmeth != meth) {
+                if (!meth->low) {
+                    meth->allocs.bytes.total += site->allocs.bytes.total;
+                    meth->allocs.calls.total += site->allocs.calls.total;
+                }
+                if (!tmgraphnode_connect(pmeth, meth, site))
+                    goto bad;
+
+                comp = meth->up;
+                if (comp) {
+                    pcomp = pmeth->up;
+                    if (pcomp && pcomp != comp) {
+                        if (!comp->low) {
+                            comp->allocs.bytes.total
+                                += site->allocs.bytes.total;
+                            comp->allocs.calls.total
+                                += site->allocs.calls.total;
+                        }
+                        if (!tmgraphnode_connect(pcomp, comp, site))
+                            goto bad;
+
+                        lib = comp->up;
+                        if (lib) {
+                            plib = pcomp->up;
+                            if (plib && plib != lib) {
+                                if (!lib->low) {
+                                    lib->allocs.bytes.total
+                                        += site->allocs.bytes.total;
+                                    lib->allocs.calls.total
+                                        += site->allocs.calls.total;
+                                }
+                                if (!tmgraphnode_connect(plib, lib, site))
+                                    goto bad;
+                            }
+                            old_lib_low = lib->low;
+                            if (!old_lib_low)
+                                lib->low = level;
+                        }
+                    }
+                    old_comp_low = comp->low;
+                    if (!old_comp_low)
+                        comp->low = level;
+                }
+            }
+            old_meth_low = meth->low;
+            if (!old_meth_low)
+                meth->low = level;
+        }
+    }
+
+    if (do_tree_dump) {
+        fprintf(fp, "%c%*s%3d %3d %s %lu %ld\n",
+                site->kids ? '+' : '-', level, "", level, kidnum,
+                meth ? tmgraphnode_name(meth) : "???",
+                (unsigned long)site->allocs.bytes.direct,
+                (long)site->allocs.bytes.total);
+    }
+    nkids = 0;
+    level++;
+    for (kid = site->kids; kid; kid = kid->siblings) {
+        walk_callsite_tree(kid, level, nkids, fp);
+        nkids++;
+    }
+
+    if (meth) {
+        if (!old_meth_low)
+            meth->low = 0;
+        if (comp) {
+            if (!old_comp_low)
+                comp->low = 0;
+            if (lib) {
+                if (!old_lib_low)
+                    lib->low = 0;
+            }
+        }
+    }
+    return;
+
+bad:
+    perror(program);
+    exit(1);
+}
+
+/*
+ * Linked list bubble-sort (waterson and brendan went bald hacking this).
+ *
+ * Sort the list in non-increasing order, using the expression passed as the
+ * 'lessthan' formal macro parameter.  This expression should use 'curr' as
+ * the pointer to the current node (of type nodetype) and 'next' as the next
+ * node pointer.  It should return true if curr is less than next, and false
+ * otherwise.
+ */
+#define BUBBLE_SORT_LINKED_LIST(listp, nodetype, lessthan)                    \
+    PR_BEGIN_MACRO                                                            \
+        nodetype *curr, **currp, *next, **nextp, *tmp;                        \
+                                                                              \
+        currp = listp;                                                        \
+        while ((curr = *currp) != NULL && curr->next) {                       \
+            nextp = &curr->next;                                              \
+            while ((next = *nextp) != NULL) {                                 \
+                if (lessthan) {                                               \
+                    tmp = curr->next;                                         \
+                    *currp = tmp;                                             \
+                    if (tmp == next) {                                        \
+                        PR_ASSERT(nextp == &curr->next);                      \
+                        curr->next = next->next;                              \
+                        next->next = curr;                                    \
+                    } else {                                                  \
+                        *nextp = next->next;                                  \
+                        curr->next = next->next;                              \
+                        next->next = tmp;                                     \
+                        *currp = next;                                        \
+                        *nextp = curr;                                        \
+                        nextp = &curr->next;                                  \
+                    }                                                         \
+                    curr = next;                                              \
+                    continue;                                                 \
+                }                                                             \
+                nextp = &next->next;                                          \
+            }                                                                 \
+            currp = &curr->next;                                              \
+        }                                                                     \
+    PR_END_MACRO
+
+static PRIntn tabulate_node(PLHashEntry *he, PRIntn i, void *arg)
+{
+    tmgraphnode *node = (tmgraphnode*) he;
+    tmgraphnode **table = (tmgraphnode**) arg;
+
+    table[i] = node;
+    BUBBLE_SORT_LINKED_LIST(&node->down, tmgraphnode,
+        (curr->allocs.bytes.total < next->allocs.bytes.total));
+    return HT_ENUMERATE_NEXT;
+}
+
+/* Sort in reverse size order, so biggest node comes first. */
+static int node_table_compare(const void *p1, const void *p2)
+{
+    const tmgraphnode *node1, *node2;
+    uint32 key1, key2;
+
+    node1 = *(const tmgraphnode**) p1;
+    node2 = *(const tmgraphnode**) p2;
+    if (sort_by_direct) {
+        key1 = node1->allocs.bytes.direct;
+        key2 = node2->allocs.bytes.direct;
+    } else {
+        key1 = node1->allocs.bytes.total;
+        key2 = node2->allocs.bytes.total;
+    }
+    return (key2 < key1) ? -1 : (key2 > key1) ? 1 : 0;
+}
+
+static int mean_size_compare(const void *p1, const void *p2)
+{
+    const tmgraphnode *node1, *node2;
+    double div1, div2, key1, key2;
+
+    node1 = *(const tmgraphnode**) p1;
+    node2 = *(const tmgraphnode**) p2;
+    div1 = (double)node1->allocs.calls.direct;
+    div2 = (double)node2->allocs.calls.direct;
+    if (div1 == 0 || div2 == 0)
+        return div2 - div1;
+    key1 = (double)node1->allocs.bytes.direct / div1;
+    key2 = (double)node2->allocs.bytes.direct / div2;
+    if (key1 < key2)
+        return 1;
+    if (key1 > key2)
+        return -1;
+    return 0;
+}
+
+static const char *prettybig(uint32 num, char *buf, size_t limit)
+{
+    if (num >= 1000000000)
+        PR_snprintf(buf, limit, "%1.2fG", (double) num / 1e9);
+    else if (num >= 1000000)
+        PR_snprintf(buf, limit, "%1.2fM", (double) num / 1e6);
+    else if (num >= 1000)
+        PR_snprintf(buf, limit, "%1.2fK", (double) num / 1e3);
+    else
+        PR_snprintf(buf, limit, "%lu", (unsigned long) num);
+    return buf;
+}
+
+static double percent(uint32 num, uint32 total)
+{
+    if (num == 0)
+        return 0.0;
+    return ((double) num * 100) / (double) total;
+}
+
+static void sort_graphlink_list(tmgraphlink **listp, int which)
+{
+    BUBBLE_SORT_LINKED_LIST(listp, tmgraphlink,
+        (TM_LINK_TO_EDGE(curr, which)->allocs.bytes.total
+         < TM_LINK_TO_EDGE(next, which)->allocs.bytes.total));
+}
+
+static void dump_graphlink_list(tmgraphlink *list, int which, const char *name,
+                                FILE *fp)
+{
+    tmcounts bytes;
+    tmgraphlink *link;
+    tmgraphedge *edge;
+    char buf[16];
+
+    bytes.direct = bytes.total = 0;
+    for (link = list; link; link = link->next) {
+        edge = TM_LINK_TO_EDGE(link, which);
+        bytes.direct += edge->allocs.bytes.direct;
+        bytes.total += edge->allocs.bytes.total;
+    }
+
+    if (js_mode) {
+        fprintf(fp,
+                "   %s:{dbytes:%ld, tbytes:%ld, edges:[\n",
+                name, (long) bytes.direct, (long) bytes.total);
+        for (link = list; link; link = link->next) {
+            edge = TM_LINK_TO_EDGE(link, which);
+            fprintf(fp,
+                    "    {node:%d, dbytes:%ld, tbytes:%ld},\n",
+                    link->node->sort,
+                    (long) edge->allocs.bytes.direct,
+                    (long) edge->allocs.bytes.total);
+        }
+        fputs("   ]},\n", fp);
+    } else {
+        fputs("<td valign=top>", fp);
+        for (link = list; link; link = link->next) {
+            edge = TM_LINK_TO_EDGE(link, which);
+            fprintf(fp,
+                    "<a href='#%s'>%s&nbsp;(%1.2f%%)</a>\n",
+                    tmgraphnode_name(link->node),
+                    prettybig(edge->allocs.bytes.total, buf, sizeof buf),
+                    percent(edge->allocs.bytes.total, bytes.total));
+        }
+        fputs("</td>", fp);
+    }
+}
+
+static void dump_graph(tmreader *tmr, PLHashTable *hashtbl, const char *varname,
+                       const char *title, FILE *fp)
+{
+    uint32 i, count;
+    tmgraphnode **table, *node;
+    char *name;
+    size_t namelen;
+    char buf1[16], buf2[16], buf3[16], buf4[16];
+    static char NA[] = "N/A";
+
+    count = hashtbl->nentries;
+    table = (tmgraphnode**) malloc(count * sizeof(tmgraphnode*));
+    if (!table) {
+        perror(program);
+        exit(1);
+    }
+    PL_HashTableEnumerateEntries(hashtbl, tabulate_node, table);
+    qsort(table, count, sizeof(tmgraphnode*), node_table_compare);
+    for (i = 0; i < count; i++)
+        table[i]->sort = i;
+
+    if (js_mode) {
+        fprintf(fp,
+                "var %s = {\n name:'%s', title:'%s', nodes:[\n",
+                varname, varname, title);
+    } else {
+        fprintf(fp,
+                "<table border=1>\n"
+                  "<tr>"
+                    "<th>%s</th>"
+                    "<th>Down</th>"
+                    "<th>Next</th>"
+                    "<th>Total/Direct (percents)</th>"
+                    "<th>Allocations</th>"
+                    "<th>Fan-in</th>"
+                    "<th>Fan-out</th>"
+                  "</tr>\n",
+                title);
+    }
+
+    for (i = 0; i < count; i++) {
+        /* Don't bother with truly puny nodes. */
+        node = table[i];
+        if (node->allocs.bytes.total < min_subtotal)
+            break;
+
+        name = tmgraphnode_name(node);
+        if (js_mode) {
+            fprintf(fp,
+                    "  {name:'%s', dbytes:%ld, tbytes:%ld,"
+                                 " dallocs:%ld, tallocs:%ld,\n",
+                    name,
+                    (long) node->allocs.bytes.direct,
+                    (long) node->allocs.bytes.total,
+                    (long) node->allocs.calls.direct,
+                    (long) node->allocs.calls.total);
+        } else {
+            namelen = strlen(name);
+            fprintf(fp,
+                    "<tr>"
+                      "<td valign=top><a name='%s'>%.*s%s</a></td>",
+                    name,
+                    (namelen > 40) ? 40 : (int)namelen, name,
+                    (namelen > 40) ? "<i>...</i>" : "");
+            if (node->down) {
+                fprintf(fp,
+                      "<td valign=top><a href='#%s'><i>down</i></a></td>",
+                        tmgraphnode_name(node->down));
+            } else {
+                fputs("<td></td>", fp);
+            }
+            if (node->next) {
+                fprintf(fp,
+                      "<td valign=top><a href='#%s'><i>next</i></a></td>",
+                        tmgraphnode_name(node->next));
+            } else {
+                fputs("<td></td>", fp);
+            }
+            fprintf(fp,
+                      "<td valign=top>%s/%s (%1.2f%%/%1.2f%%)</td>"
+                      "<td valign=top>%s/%s (%1.2f%%/%1.2f%%)</td>",
+                    prettybig(node->allocs.bytes.total, buf1, sizeof buf1),
+                    prettybig(node->allocs.bytes.direct, buf2, sizeof buf2),
+                    percent(node->allocs.bytes.total,
+                            tmr->calltree_root.allocs.bytes.total),
+                    percent(node->allocs.bytes.direct,
+                            tmr->calltree_root.allocs.bytes.total),
+                    prettybig(node->allocs.calls.total, buf3, sizeof buf3),
+                    prettybig(node->allocs.calls.direct, buf4, sizeof buf4),
+                    percent(node->allocs.calls.total,
+                            tmr->calltree_root.allocs.calls.total),
+                    percent(node->allocs.calls.direct,
+                            tmr->calltree_root.allocs.calls.total));
+        }
+
+        /* NB: we must use 'fin' because 'in' is a JS keyword! */
+        sort_graphlink_list(&node->in, TM_EDGE_IN_LINK);
+        dump_graphlink_list(node->in, TM_EDGE_IN_LINK, "fin", fp);
+        sort_graphlink_list(&node->out, TM_EDGE_OUT_LINK);
+        dump_graphlink_list(node->out, TM_EDGE_OUT_LINK, "out", fp);
+
+        if (js_mode)
+            fputs("  },\n", fp);
+        else
+            fputs("</tr>\n", fp);
+    }
+
+    if (js_mode) {
+        fputs("]};\n", fp);
+    } else {
+        fputs("</table>\n<hr>\n", fp);
+
+        qsort(table, count, sizeof(tmgraphnode*), mean_size_compare);
+
+        fprintf(fp,
+                "<table border=1>\n"
+                  "<tr><th colspan=4>Direct Allocators</th></tr>\n"
+                  "<tr>"
+                    "<th>%s</th>"
+                    "<th>Mean&nbsp;Size</th>"
+                    "<th>StdDev</th>"
+                    "<th>Allocations<th>"
+                  "</tr>\n",
+                title);
+
+        for (i = 0; i < count; i++) {
+            double allocs, bytes, mean, variance, sigma;
+
+            node = table[i];
+            allocs = (double)node->allocs.calls.direct;
+            if (!allocs)
+                continue;
+
+            /* Compute direct-size mean and standard deviation. */
+            bytes = (double)node->allocs.bytes.direct;
+            mean = bytes / allocs;
+            variance = allocs * node->sqsum - bytes * bytes;
+            if (variance < 0 || allocs == 1)
+                variance = 0;
+            else
+                variance /= allocs * (allocs - 1);
+            sigma = sqrt(variance);
+
+            name = tmgraphnode_name(node);
+            namelen = strlen(name);
+            fprintf(fp,
+                    "<tr>"
+                      "<td valign=top>%.*s%s</td>"
+                      "<td valign=top>%s</td>"
+                      "<td valign=top>%s</td>"
+                      "<td valign=top>%s</td>"
+                    "</tr>\n",
+                    (namelen > 65) ? 45 : (int)namelen, name,
+                    (namelen > 65) ? "<i>...</i>" : "",
+                    prettybig((uint32)mean, buf1, sizeof buf1),
+                    prettybig((uint32)sigma, buf2, sizeof buf2),
+                    prettybig(node->allocs.calls.direct, buf3, sizeof buf3));
+        }
+        fputs("</table>\n", fp);
+    }
+
+    free((void*) table);
+}
+
+static void my_tmevent_handler(tmreader *tmr, tmevent *event)
+{
+    switch (event->type) {
+      case TM_EVENT_STATS:
+        if (js_mode)
+            break;
+        fprintf(stdout,
+                "<p><table border=1>"
+                  "<tr><th>Counter</th><th>Value</th></tr>\n"
+                  "<tr><td>maximum actual stack depth</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>maximum callsite tree depth</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>number of parent callsites</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>maximum kids per parent</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>hits looking for a kid</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>misses looking for a kid</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>steps over other kids</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>callsite recurrences</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>number of stack backtraces</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>backtrace failures</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>backtrace malloc failures</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>backtrace dladdr failures</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>malloc calls</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>malloc failures</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>calloc calls</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>calloc failures</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>realloc calls</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>realloc failures</td><td align=right>%lu</td></tr>\n"
+                  "<tr><td>free calls</td><td align=right>%lu</td></tr>\n"
+                "<tr><td>free(null) calls</td><td align=right>%lu</td></tr>\n"
+                "</table>",
+                (unsigned long) event->u.stats.tmstats.calltree_maxstack,
+                (unsigned long) event->u.stats.tmstats.calltree_maxdepth,
+                (unsigned long) event->u.stats.tmstats.calltree_parents,
+                (unsigned long) event->u.stats.tmstats.calltree_maxkids,
+                (unsigned long) event->u.stats.tmstats.calltree_kidhits,
+                (unsigned long) event->u.stats.tmstats.calltree_kidmisses,
+                (unsigned long) event->u.stats.tmstats.calltree_kidsteps,
+                (unsigned long) event->u.stats.tmstats.callsite_recurrences,
+                (unsigned long) event->u.stats.tmstats.backtrace_calls,
+                (unsigned long) event->u.stats.tmstats.backtrace_failures,
+                (unsigned long) event->u.stats.tmstats.btmalloc_failures,
+                (unsigned long) event->u.stats.tmstats.dladdr_failures,
+                (unsigned long) event->u.stats.tmstats.malloc_calls,
+                (unsigned long) event->u.stats.tmstats.malloc_failures,
+                (unsigned long) event->u.stats.tmstats.calloc_calls,
+                (unsigned long) event->u.stats.tmstats.calloc_failures,
+                (unsigned long) event->u.stats.tmstats.realloc_calls,
+                (unsigned long) event->u.stats.tmstats.realloc_failures,
+                (unsigned long) event->u.stats.tmstats.free_calls,
+                (unsigned long) event->u.stats.tmstats.null_free_calls);
+
+        if (event->u.stats.calltree_maxkids_parent) {
+            tmcallsite *site =
+                tmreader_callsite(tmr, event->u.stats.calltree_maxkids_parent);
+            if (site && site->method) {
+                fprintf(stdout, "<p>callsite with the most kids: %s</p>",
+                        tmgraphnode_name(site->method));
+            }
+        }
+
+        if (event->u.stats.calltree_maxstack_top) {
+            tmcallsite *site =
+                tmreader_callsite(tmr, event->u.stats.calltree_maxstack_top);
+            fputs("<p>deepest callsite tree path:\n"
+                  "<table border=1>\n"
+                    "<tr><th>Method</th><th>Offset</th></tr>\n",
+                  stdout);
+            while (site) {
+                fprintf(stdout,
+                    "<tr><td>%s</td><td>0x%08lX</td></tr>\n",
+                        site->method ? tmgraphnode_name(site->method) : "???",
+                        (unsigned long) site->offset);
+                site = site->parent;
+            }
+            fputs("</table>\n<hr>\n", stdout);
+        }
+        break;
+    }
+}
+
+int main(int argc, char **argv)
+{
+    int c, i, j, rv;
+    tmreader *tmr;
+    FILE *fp;
+
+    program = *argv;
+    tmr = tmreader_new(program, NULL);
+    if (!tmr) {
+        perror(program);
+        exit(1);
+    }
+
+    while ((c = getopt(argc, argv, "djtuf:m:")) != EOF) {
+        switch (c) {
+          case 'd':
+            sort_by_direct = 1;
+            break;
+          case 'j':
+            js_mode = 1;
+            break;
+          case 't':
+            do_tree_dump = 1;
+            break;
+          case 'u':
+            unified_output = 1;
+            break;
+          case 'f':
+            function_dump = optarg;
+            break;
+          case 'm':
+            min_subtotal = atoi(optarg);
+            break;
+          default:
+            fprintf(stderr,
+        "usage: %s [-dtu] [-f function-dump-filename] [-m min] [output.html]\n",
+                    program);
+            exit(2);
+        }
+    }
+
+    if (!js_mode) {
+        time_t start = time(NULL);
+
+        fprintf(stdout,
+                "<script language=\"JavaScript\">\n"
+                "function onload() {\n"
+                "  document.links[0].__proto__.onmouseover = new Function("
+                    "\"window.status ="
+                    " this.href.substring(this.href.lastIndexOf('#') + 1)\");\n"
+                "}\n"
+                "</script>\n");
+        fprintf(stdout, "%s starting at %s", program, ctime(&start));
+        fflush(stdout);
+    }
+
+    argc -= optind;
+    argv += optind;
+    if (argc == 0) {
+        if (tmreader_eventloop(tmr, "-", my_tmevent_handler) <= 0)
+            exit(1);
+    } else {
+        for (i = j = 0; i < argc; i++) {
+            fp = fopen(argv[i], "r");
+            if (!fp) {
+                fprintf(stderr, "%s: can't open %s: %s\n",
+                        program, argv[i], strerror(errno));
+                exit(1);
+            }
+            rv = tmreader_eventloop(tmr, argv[i], my_tmevent_handler);
+            if (rv < 0)
+                exit(1);
+            if (rv > 0)
+                j++;
+            fclose(fp);
+        }
+        if (j == 0)
+            exit(1);
+    }
+
+    compute_callsite_totals(&tmr->calltree_root);
+    walk_callsite_tree(&tmr->calltree_root, 0, 0, stdout);
+
+    if (js_mode) {
+        fprintf(stdout,
+                "<script language='javascript'>\n"
+                "// direct and total byte and allocator-call counts\n"
+                "var dbytes = %ld, tbytes = %ld,"
+                   " dallocs = %ld, tallocs = %ld;\n",
+                (long) tmr->calltree_root.allocs.bytes.direct,
+                (long) tmr->calltree_root.allocs.bytes.total,
+                (long) tmr->calltree_root.allocs.calls.direct,
+                (long) tmr->calltree_root.allocs.calls.total);
+    }
+
+    dump_graph(tmr, tmr->libraries, "libraries", "Library", stdout);
+    if (!js_mode)
+        fputs("<hr>\n", stdout);
+
+    dump_graph(tmr, tmr->components, "classes", "Class or Component", stdout);
+    if (js_mode || unified_output || function_dump) {
+        if (js_mode || unified_output || strcmp(function_dump, "-") == 0) {
+            fp = stdout;
+            if (!js_mode)
+                fputs("<hr>\n", fp);
+        } else {
+            struct stat sb, fsb;
+
+            fstat(fileno(stdout), &sb);
+            if (stat(function_dump, &fsb) == 0 &&
+                fsb.st_dev == sb.st_dev && fsb.st_ino == sb.st_ino) {
+                fp = stdout;
+                fputs("<hr>\n", fp);
+            } else {
+                fp = fopen(function_dump, "w");
+                if (!fp) {
+                    fprintf(stderr, "%s: can't open %s: %s\n",
+                            program, function_dump, strerror(errno));
+                    exit(1);
+                }
+            }
+        }
+
+        dump_graph(tmr, tmr->methods, "methods", "Function or Method", fp);
+        if (fp != stdout)
+            fclose(fp);
+
+        if (js_mode) {
+            fputs("function viewnode(graph, index) {\n"
+                  "  view.location = viewsrc();\n"
+                  "}\n"
+                  "function viewnodelink(graph, index) {\n"
+                  "  var node = graph.nodes[index];\n"
+                  "  return '<a href=\"javascript:viewnode('"
+                      " + graph.name.quote() + ', ' + node.sort"
+                      " + ')\" onmouseover=' + node.name.quote() + '>'"
+                      " + node.name + '</a>';\n"
+                  "}\n"
+                  "function search(expr) {\n"
+                  "  var re = new RegExp(expr);\n"
+                  "  var src = '';\n"
+                  "  var graphs = [libraries, classes, methods]\n"
+                  "  var nodes;\n"
+                  "  for (var n = 0; n < (nodes = graphs[n].nodes).length; n++) {\n"
+                  "    for (var i = 0; i < nodes.length; i++) {\n"
+                  "      if (re.test(nodes[i].name))\n"
+                  "        src += viewnodelink(graph, i) + '\\n';\n"
+                  "    }\n"
+                  "  }\n"
+                  "  view.location = viewsrc();\n"
+                  "}\n"
+                  "function ctrlsrc() {\n"
+                  "  return \"<form>\\n"
+                      "search: <input size=40 onchange='search(this.value)'>\\n"
+                      "</form>\\n\";\n"
+                  "}\n"
+                  "function viewsrc() {\n"
+                  "  return 'hiiiii'\n"
+                  "}\n"
+                  "</script>\n"
+                  "<frameset rows='10%,*'>\n"
+                  " <frame name='ctrl' src='javascript:top.ctrlsrc()'>\n"
+                  " <frame name='view' src='javascript:top.viewsrc()'>\n"
+                  "</frameset>\n",
+                  stdout);
+        }
+    }
+
+    exit(0);
+}

mozilla/tools/trace-malloc/lib/nsTraceMalloc.h

@@ -0,0 +1,173 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is nsTraceMalloc.c/bloatblame.c code, released
+ * April 19, 2000.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 2000 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *    Brendan Eich, 14-April-2000
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the MPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ */
+#ifndef nsTraceMalloc_h___
+#define nsTraceMalloc_h___
+
+#include "prtypes.h"
+
+PR_BEGIN_EXTERN_C
+
+/**
+ * Magic "number" at start of a trace-malloc log file.  Inspired by the PNG
+ * magic string, which inspired XPCOM's typelib (.xpt) file magic.  See the
+ * NS_TraceMallocStartup comment (below) for magic number differences in log
+ * file structure.
+ */
+#define NS_TRACE_MALLOC_MAGIC           "XPCOM\nTMLog03\r\n\032"
+#define NS_TRACE_MALLOC_MAGIC_SIZE      16
+
+/**
+ * Trace-malloc stats, traced via the 'Z' event at the end of a log file.
+ */
+typedef struct nsTMStats {
+    uint32 calltree_maxstack;
+    uint32 calltree_maxdepth;
+    uint32 calltree_parents;
+    uint32 calltree_maxkids;
+    uint32 calltree_kidhits;
+    uint32 calltree_kidmisses;
+    uint32 calltree_kidsteps;
+    uint32 callsite_recurrences;
+    uint32 backtrace_calls;
+    uint32 backtrace_failures;
+    uint32 btmalloc_failures;
+    uint32 dladdr_failures;
+    uint32 malloc_calls;
+    uint32 malloc_failures;
+    uint32 calloc_calls;
+    uint32 calloc_failures;
+    uint32 realloc_calls;
+    uint32 realloc_failures;
+    uint32 free_calls;
+    uint32 null_free_calls;
+} nsTMStats;
+
+#define NS_TMSTATS_STATIC_INITIALIZER {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
+
+/**
+ * Call NS_TraceMallocStartup with a valid file descriptor to enable logging
+ * of compressed malloc traces, including callsite chains.  Integers may be
+ * unsigned serial numbers, sizes, or offsets, and require at most 32 bits.
+ * They're encoded as follows:
+ *   0-127                  0xxxxxxx (binary, one byte)
+ *   128-16383              10xxxxxx xxxxxxxx
+ *   16384-0x1fffff         110xxxxx xxxxxxxx xxxxxxxx
+ *   0x200000-0xfffffff     1110xxxx xxxxxxxx xxxxxxxx xxxxxxxx
+ *   0x10000000-0xffffffff  11110000 xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
+ * Strings are NUL-terminated ASCII.
+ *
+ * Event Operands (magic TMLog01)
+ *   'L' library serial, shared object filename string
+ *   'N' method serial, library serial, demangled name string
+ *   'S' site serial, parent serial, method serial, calling pc offset
+ *   'M' site serial, malloc size
+ *   'C' site serial, calloc size
+ *   'R' site serial, realloc oldsize, realloc size
+ *   'F' site serial, free size
+ *
+ * Event Operands (magic TMLog02)
+ *   'Z' serialized struct tmstats (20 unsigned integers),
+ *       maxkids parent callsite serial,
+ *       maxstack top callsite serial
+ *
+ * Event Operands (magic TMLog03)
+ *   'T' seconds, microseconds, caption
+ *
+ * See xpcom/base/bloatblame.c for an example log-file reader.
+ */
+#define TM_EVENT_LIBRARY        'L'
+#define TM_EVENT_METHOD         'N'
+#define TM_EVENT_CALLSITE       'S'
+#define TM_EVENT_MALLOC         'M'
+#define TM_EVENT_CALLOC         'C'
+#define TM_EVENT_REALLOC        'R'
+#define TM_EVENT_FREE           'F'
+#define TM_EVENT_STATS          'Z'
+#define TM_EVENT_TIMESTAMP      'T'
+
+PR_EXTERN(void) NS_TraceMallocStartup(int logfd);
+
+/**
+ * Initialize malloc tracing, using the ``standard'' startup arguments.
+ */
+PR_EXTERN(int) NS_TraceMallocStartupArgs(int argc, char* argv[]);
+
+/**
+ * Stop all malloc tracing, flushing any buffered events to the logfile.
+ */
+PR_EXTERN(void) NS_TraceMallocShutdown(void);
+
+/**
+ * Disable malloc tracing.
+ */
+PR_EXTERN(void) NS_TraceMallocDisable(void);
+
+/**
+ * Enable malloc tracing.
+ */
+PR_EXTERN(void) NS_TraceMallocEnable(void);
+
+/**
+ * Change the log file descriptor, flushing any buffered output to the old
+ * fd, and writing NS_TRACE_MALLOC_MAGIC to the new file if it is zero length.
+ * Return the old fd, so the caller can swap open fds.  Return -2 on failure,
+ * which means malloc failure.
+ */
+PR_EXTERN(int) NS_TraceMallocChangeLogFD(int fd);
+
+/**
+ * Close the file descriptor fd and forget any bookkeeping associated with it.
+ * Do nothing if fd is -1.
+ */
+PR_EXTERN(void) NS_TraceMallocCloseLogFD(int fd);
+
+/**
+ * Emit a timestamp event with the given caption to the current log file. 
+ */
+PR_EXTERN(void) NS_TraceMallocLogTimestamp(const char *caption);
+
+/**
+ * Dump a human-readable listing of current allocations and their compressed
+ * stack backtraces to the file named by pathname.  Beware this file may have
+ * very long lines.
+ *
+ * Return -1 on error with errno set by the system, 0 on success.
+ */
+PR_EXTERN(int)
+NS_TraceMallocDumpAllocations(const char *pathname);
+
+PR_END_EXTERN_C
+
+#endif /* nsTraceMalloc_h___ */

mozilla/tools/trace-malloc/tmreader.c

@@ -0,0 +1,700 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is tmreader.h/tmreader.c code, released
+ * July 7, 2000.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 2000 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *    Brendan Eich, 7-July-2000
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the MPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>      /* XXX push error reporting out to clients? */
+#include <unistd.h>
+#include "prlog.h"
+#include "plhash.h"
+#include "nsTraceMalloc.h"
+#include "tmreader.h"
+
+static int accum_byte(FILE *fp, uint32 *uip)
+{
+    int c = getc(fp);
+    if (c == EOF)
+        return 0;
+    *uip = (*uip << 8) | c;
+    return 1;
+}
+
+static int get_uint32(FILE *fp, uint32 *uip)
+{
+    int c;
+    uint32 ui;
+
+    c = getc(fp);
+    if (c == EOF)
+        return 0;
+    ui = 0;
+    if (c & 0x80) {
+        c &= 0x7f;
+        if (c & 0x40) {
+            c &= 0x3f;
+            if (c & 0x20) {
+                c &= 0x1f;
+                if (c & 0x10) {
+                    if (!accum_byte(fp, &ui))
+                        return 0;
+                } else {
+                    ui = (uint32) c;
+                }
+                if (!accum_byte(fp, &ui))
+                    return 0;
+            } else {
+                ui = (uint32) c;
+            }
+            if (!accum_byte(fp, &ui))
+                return 0;
+        } else {
+            ui = (uint32) c;
+        }
+        if (!accum_byte(fp, &ui))
+            return 0;
+    } else {
+        ui = (uint32) c;
+    }
+    *uip = ui;
+    return 1;
+}
+
+static char *get_string(FILE *fp)
+{
+    char *cp;
+    int c;
+    static char buf[256];
+    static char *bp = buf, *ep = buf + sizeof buf;
+    static size_t bsize = sizeof buf;
+
+    cp = bp;
+    do {
+        c = getc(fp);
+        if (c == EOF)
+            return 0;
+        if (cp == ep) {
+            if (bp == buf) {
+                bp = malloc(2 * bsize);
+                if (bp)
+                    memcpy(bp, buf, bsize);
+            } else {
+                bp = realloc(bp, 2 * bsize);
+            }
+            if (!bp)
+                return 0;
+            cp = bp + bsize;
+            bsize *= 2;
+            ep = bp + bsize;
+        }
+        *cp++ = c;
+    } while (c != '\0');
+    return strdup(bp);
+}
+
+static int get_tmevent(FILE *fp, tmevent *event)
+{
+    int c;
+    char *s;
+
+    c = getc(fp);
+    if (c == EOF)
+        return 0;
+    event->type = (char) c;
+    if (!get_uint32(fp, &event->serial))
+        return 0;
+    switch (c) {
+      case TM_EVENT_LIBRARY:
+        s = get_string(fp);
+        if (!s)
+            return 0;
+        event->u.libname = s;
+        break;
+
+      case TM_EVENT_METHOD:
+        if (!get_uint32(fp, &event->u.method.library))
+            return 0;
+        s = get_string(fp);
+        if (!s)
+            return 0;
+        event->u.method.name = s;
+        break;
+
+      case TM_EVENT_CALLSITE:
+        if (!get_uint32(fp, &event->u.site.parent))
+            return 0;
+        if (!get_uint32(fp, &event->u.site.method))
+            return 0;
+        if (!get_uint32(fp, &event->u.site.offset))
+            return 0;
+        break;
+
+      case TM_EVENT_MALLOC:
+      case TM_EVENT_CALLOC:
+      case TM_EVENT_FREE:
+        event->u.alloc.oldsize = 0;
+        if (!get_uint32(fp, &event->u.alloc.size))
+            return 0;
+        break;
+
+      case TM_EVENT_REALLOC:
+        if (!get_uint32(fp, &event->u.alloc.oldsize))
+            return 0;
+        if (!get_uint32(fp, &event->u.alloc.size))
+            return 0;
+        break;
+
+      case TM_EVENT_STATS:
+        if (!get_uint32(fp, &event->u.stats.tmstats.calltree_maxstack))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.calltree_maxdepth))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.calltree_parents))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.calltree_maxkids))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.calltree_kidhits))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.calltree_kidmisses))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.calltree_kidsteps))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.callsite_recurrences))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.backtrace_calls))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.backtrace_failures))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.btmalloc_failures))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.dladdr_failures))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.malloc_calls))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.malloc_failures))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.calloc_calls))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.calloc_failures))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.realloc_calls))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.realloc_failures))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.free_calls))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.tmstats.null_free_calls))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.calltree_maxkids_parent))
+            return 0;
+        if (!get_uint32(fp, &event->u.stats.calltree_maxstack_top))
+            return 0;
+        break;
+    }
+    return 1;
+}
+
+static void *generic_alloctable(void *pool, PRSize size)
+{
+    return malloc(size);
+}
+
+static void generic_freetable(void *pool, void *item)
+{
+    free(item);
+}
+
+static PLHashEntry *callsite_allocentry(void *pool, const void *key)
+{
+    return malloc(sizeof(tmcallsite));
+}
+
+static PLHashEntry *graphnode_allocentry(void *pool, const void *key)
+{
+    tmgraphnode *node = (tmgraphnode*) malloc(sizeof(tmgraphnode));
+    if (!node)
+        return NULL;
+    node->in = node->out = NULL;
+    node->up = node->down = node->next = NULL;
+    node->low = 0;
+    node->allocs.bytes.direct = node->allocs.bytes.total = 0;
+    node->allocs.calls.direct = node->allocs.calls.total = 0;
+    node->frees.bytes.direct = node->frees.bytes.total = 0;
+    node->frees.calls.direct = node->frees.calls.total = 0;
+    node->sqsum = 0;
+    node->sort = -1;
+    return &node->entry;
+}
+
+static void graphnode_freeentry(void *pool, PLHashEntry *he, PRUintn flag)
+{
+    /* Always free the value, which points to a strdup'd string. */
+    free(he->value);
+
+    /* Free the whole thing if we're told to. */
+    if (flag == HT_FREE_ENTRY)
+        free((void*) he);
+}
+
+static void component_freeentry(void *pool, PLHashEntry *he, PRUintn flag)
+{
+    if (flag == HT_FREE_ENTRY) {
+        tmgraphnode *comp = (tmgraphnode*) he;
+
+        /* Free the key, which was strdup'd (N.B. value also points to it). */
+        free((void*) tmcomponent_name(comp));
+        free((void*) comp);
+    }
+}
+
+static PLHashAllocOps callsite_hashallocops = {
+    generic_alloctable,     generic_freetable,
+    callsite_allocentry,    graphnode_freeentry
+};
+
+static PLHashAllocOps graphnode_hashallocops = {
+    generic_alloctable,     generic_freetable,
+    graphnode_allocentry,   graphnode_freeentry
+};
+
+static PLHashAllocOps component_hashallocops = {
+    generic_alloctable,     generic_freetable,
+    graphnode_allocentry,   component_freeentry
+};
+
+static PLHashNumber hash_serial(const void *key)
+{
+    return (PLHashNumber) key;
+}
+
+tmreader *tmreader_new(const char *program, void *data)
+{
+    tmreader *tmr;
+
+    tmr = calloc(1, sizeof *tmr);
+    if (!tmr)
+        return NULL;
+    tmr->program = program;
+    tmr->data = data;
+
+    tmr->libraries = PL_NewHashTable(100, hash_serial, PL_CompareValues,
+                                     PL_CompareStrings, &graphnode_hashallocops,
+                                     NULL);
+    tmr->components = PL_NewHashTable(10000, PL_HashString, PL_CompareStrings,
+                                      PL_CompareValues, &component_hashallocops,
+                                      NULL);
+    tmr->methods = PL_NewHashTable(10000, hash_serial, PL_CompareValues,
+                                   PL_CompareStrings, &graphnode_hashallocops,
+                                   NULL);
+    tmr->callsites = PL_NewHashTable(200000, hash_serial, PL_CompareValues,
+                                     PL_CompareValues, &callsite_hashallocops,
+                                     NULL);
+    tmr->calltree_root.entry.value = (void*) strdup("root");
+
+    if (!tmr->libraries || !tmr->components || !tmr->methods ||
+        !tmr->callsites || !tmr->calltree_root.entry.value) {
+        tmreader_destroy(tmr);
+        return NULL;
+    }
+    return tmr;
+}
+
+void tmreader_destroy(tmreader *tmr)
+{
+    if (tmr->libraries)
+        PL_HashTableDestroy(tmr->libraries);
+    if (tmr->components)
+        PL_HashTableDestroy(tmr->components);
+    if (tmr->methods)
+        PL_HashTableDestroy(tmr->methods);
+    if (tmr->callsites)
+        PL_HashTableDestroy(tmr->callsites);
+    free(tmr);
+}
+
+int tmreader_eventloop(tmreader *tmr, const char *filename,
+                       tmeventhandler eventhandler)
+{
+    FILE *fp;
+    char buf[NS_TRACE_MALLOC_MAGIC_SIZE];
+    tmevent event;
+    static const char magic[] = NS_TRACE_MALLOC_MAGIC;
+
+    if (strcmp(filename, "-") == 0) {
+        fp = stdin;
+    } else {
+        fp = fopen(filename, "r");
+        if (!fp) {
+            fprintf(stderr, "%s: can't open %s: %s.\n",
+                    tmr->program, filename, strerror(errno));
+            return 0;
+        }
+    }
+
+    if (read(fileno(fp), buf, sizeof buf) != sizeof buf ||
+        strncmp(buf, magic, sizeof buf) != 0) {
+        fprintf(stderr, "%s: bad magic string %s at start of %s.\n",
+                tmr->program, buf, filename);
+        return 0;
+    }
+
+    while (get_tmevent(fp, &event)) {
+        switch (event.type) {
+          case TM_EVENT_LIBRARY: {
+            const void *key;
+            PLHashNumber hash;
+            PLHashEntry **hep, *he;
+
+            key = (const void*) event.serial;
+            hash = hash_serial(key);
+            hep = PL_HashTableRawLookup(tmr->libraries, hash, key);
+            he = *hep;
+            PR_ASSERT(!he);
+            if (he) exit(2);
+
+            he = PL_HashTableRawAdd(tmr->libraries, hep, hash, key,
+                                    event.u.libname);
+            if (!he) {
+                perror(tmr->program);
+                return -1;
+            }
+            break;
+          }
+
+          case TM_EVENT_METHOD: {
+            const void *key;
+            PLHashNumber hash;
+            PLHashEntry **hep, *he;
+            char *name, *head, *mark, save;
+            tmgraphnode *meth, *comp, *lib;
+
+            key = (const void*) event.serial;
+            hash = hash_serial(key);
+            hep = PL_HashTableRawLookup(tmr->methods, hash, key);
+            he = *hep;
+            PR_ASSERT(!he);
+            if (he) exit(2);
+
+            name = event.u.method.name;
+            he = PL_HashTableRawAdd(tmr->methods, hep, hash, key, name);
+            if (!he) {
+                perror(tmr->program);
+                return -1;
+            }
+            meth = (tmgraphnode*) he;
+
+            head = name;
+            mark = strchr(name, ':');
+            if (!mark) {
+                mark = name;
+                while (*mark != '\0' && *mark == '_')
+                    mark++;
+                head = mark;
+                mark = strchr(head, '_');
+                if (!mark) {
+                    mark = strchr(head, '+');
+                    if (!mark)
+                        mark = head + strlen(head);
+                }
+            }
+
+            save = *mark;
+            *mark = '\0';
+            hash = PL_HashString(head);
+            hep = PL_HashTableRawLookup(tmr->components, hash, head);
+            he = *hep;
+            if (he) {
+                comp = (tmgraphnode*) he;
+            } else {
+                head = strdup(head);
+                if (head) {
+                    he = PL_HashTableRawAdd(tmr->components, hep, hash, head,
+                                            head);
+                }
+                if (!he) {
+                    perror(tmr->program);
+                    return -1;
+                }
+                comp = (tmgraphnode*) he;
+
+                key = (const void*) event.u.method.library;
+                hash = hash_serial(key);
+                lib = (tmgraphnode*)
+                      *PL_HashTableRawLookup(tmr->libraries, hash, key);
+                if (lib) {
+                    comp->up = lib;
+                    comp->next = lib->down;
+                    lib->down = comp;
+                }
+            }
+            *mark = save;
+
+            meth->up = comp;
+            meth->next = comp->down;
+            comp->down = meth;
+            break;
+          }
+
+          case TM_EVENT_CALLSITE: {
+            const void *key, *mkey;
+            PLHashNumber hash, mhash;
+            PLHashEntry **hep, *he;
+            tmcallsite *site, *parent;
+            tmgraphnode *meth;
+
+            key = (const void*) event.serial;
+            hash = hash_serial(key);
+            hep = PL_HashTableRawLookup(tmr->callsites, hash, key);
+            he = *hep;
+            PR_ASSERT(!he);
+            if (he) exit(2);
+
+            if (event.u.site.parent == 0) {
+                parent = &tmr->calltree_root;
+            } else {
+                parent = tmreader_callsite(tmr, event.u.site.parent);
+                if (!parent) {
+                    fprintf(stderr, "%s: no parent for %lu (%lu)!\n",
+                            tmr->program, (unsigned long) event.serial,
+                            (unsigned long) event.u.site.parent);
+                    continue;
+                }
+            }
+
+            he = PL_HashTableRawAdd(tmr->callsites, hep, hash, key, NULL);
+            if (!he) {
+                perror(tmr->program);
+                return -1;
+            }
+
+            site = (tmcallsite*) he;
+            site->parent = parent;
+            site->siblings = parent->kids;
+            parent->kids = site;
+            site->kids = NULL;
+
+            mkey = (const void*) event.u.site.method;
+            mhash = hash_serial(mkey);
+            meth = (tmgraphnode*)
+                   *PL_HashTableRawLookup(tmr->methods, mhash, mkey);
+            site->method = meth;
+            site->offset = event.u.site.offset;
+            site->allocs.bytes.direct = site->allocs.bytes.total = 0;
+            site->allocs.calls.direct = site->allocs.calls.total = 0;
+            site->frees.bytes.direct = site->frees.bytes.total = 0;
+            site->frees.calls.direct = site->frees.calls.total = 0;
+            break;
+          }
+
+          case TM_EVENT_MALLOC:
+          case TM_EVENT_CALLOC:
+          case TM_EVENT_REALLOC: {
+            tmcallsite *site;
+            uint32 size, oldsize;
+            double delta, sqdelta, sqszdelta;
+            tmgraphnode *meth, *comp, *lib;
+
+            site = tmreader_callsite(tmr, event.serial);
+            if (!site) {
+                fprintf(stderr, "%s: no callsite for '%c' (%lu)!\n",
+                        tmr->program, event.type, (unsigned long) event.serial);
+                continue;
+            }
+
+            size = event.u.alloc.size;
+            oldsize = event.u.alloc.oldsize;
+            delta = (double)size - (double)oldsize;
+            site->allocs.bytes.direct += delta;
+            if (event.type != TM_EVENT_REALLOC)
+                site->allocs.calls.direct++;
+            meth = site->method;
+            if (meth) {
+                meth->allocs.bytes.direct += delta;
+                sqdelta = delta * delta;
+                if (event.type == TM_EVENT_REALLOC) {
+                    sqszdelta = ((double)size * size)
+                              - ((double)oldsize * oldsize);
+                    meth->sqsum += sqszdelta;
+                } else {
+                    meth->sqsum += sqdelta;
+                    meth->allocs.calls.direct++;
+                }
+                comp = meth->up;
+                if (comp) {
+                    comp->allocs.bytes.direct += delta;
+                    if (event.type == TM_EVENT_REALLOC) {
+                        comp->sqsum += sqszdelta;
+                    } else {
+                        comp->sqsum += sqdelta;
+                        comp->allocs.calls.direct++;
+                    }
+                    lib = comp->up;
+                    if (lib) {
+                        lib->allocs.bytes.direct += delta;
+                        if (event.type == TM_EVENT_REALLOC) {
+                            lib->sqsum += sqszdelta;
+                        } else {
+                            lib->sqsum += sqdelta;
+                            lib->allocs.calls.direct++;
+                        }
+                    }
+                }
+            }
+            break;
+          }
+
+          case TM_EVENT_FREE: {
+            tmcallsite *site;
+            uint32 size;
+            tmgraphnode *meth, *comp, *lib;
+
+            site = tmreader_callsite(tmr, event.serial);
+            if (!site) {
+                fprintf(stderr, "%s: no callsite for '%c' (%lu)!\n",
+                        tmr->program, event.type, (unsigned long) event.serial);
+                continue;
+            }
+            size = event.u.alloc.size;
+            site->frees.bytes.direct += size;
+            site->frees.calls.direct++;
+            meth = site->method;
+            if (meth) {
+                meth->frees.bytes.direct += size;
+                meth->frees.calls.direct++;
+                comp = meth->up;
+                if (comp) {
+                    comp->frees.bytes.direct += size;
+                    comp->frees.calls.direct++;
+                    lib = comp->up;
+                    if (lib) {
+                        lib->frees.bytes.direct += size;
+                        lib->frees.calls.direct++;
+                    }
+                }
+            }
+            break;
+          }
+
+          case TM_EVENT_STATS:
+            break;
+        }
+
+        eventhandler(tmr, &event);
+    }
+
+    return 1;
+}
+
+tmgraphnode *tmreader_library(tmreader *tmr, uint32 serial)
+{
+    const void *key;
+    PLHashNumber hash;
+
+    key = (const void*) serial;
+    hash = hash_serial(key);
+    return (tmgraphnode*) *PL_HashTableRawLookup(tmr->libraries, hash, key);
+}
+
+tmgraphnode *tmreader_component(tmreader *tmr, const char *name)
+{
+    PLHashNumber hash;
+
+    hash = PL_HashString(name);
+    return (tmgraphnode*) *PL_HashTableRawLookup(tmr->components, hash, name);
+}
+
+tmgraphnode *tmreader_method(tmreader *tmr, uint32 serial)
+{
+    const void *key;
+    PLHashNumber hash;
+
+    key = (const void*) serial;
+    hash = hash_serial(key);
+    return (tmgraphnode*) *PL_HashTableRawLookup(tmr->methods, hash, key);
+}
+
+tmcallsite *tmreader_callsite(tmreader *tmr, uint32 serial)
+{
+    const void *key;
+    PLHashNumber hash;
+
+    key = (const void*) serial;
+    hash = hash_serial(key);
+    return (tmcallsite*) *PL_HashTableRawLookup(tmr->callsites, hash, key);
+}
+
+int tmgraphnode_connect(tmgraphnode *from, tmgraphnode *to, tmcallsite *site)
+{
+    tmgraphlink *outlink;
+    tmgraphedge *edge;
+
+    for (outlink = from->out; outlink; outlink = outlink->next) {
+        if (outlink->node == to) {
+            /*
+             * Say the stack looks like this: ... => JS => js => JS => js.
+             * We must avoid overcounting JS=>js because the first edge total
+             * includes the second JS=>js edge's total (which is because the
+             * lower site's total includes all its kids' totals).
+             */
+            edge = TM_LINK_TO_EDGE(outlink, TM_EDGE_OUT_LINK);
+            if (!to->low || to->low < from->low) {
+                /* Add the direct and total counts to edge->allocs. */
+                edge->allocs.bytes.direct += site->allocs.bytes.direct;
+                edge->allocs.bytes.total += site->allocs.bytes.total;
+                edge->allocs.calls.direct += site->allocs.calls.direct;
+                edge->allocs.calls.total += site->allocs.calls.total;
+
+                /* Now update the free counts. */
+                edge->frees.bytes.direct += site->frees.bytes.direct;
+                edge->frees.bytes.total += site->frees.bytes.total;
+                edge->frees.calls.direct += site->frees.calls.direct;
+                edge->frees.calls.total += site->frees.calls.total;
+            }
+            return 1;
+        }
+    }
+
+    edge = (tmgraphedge*) malloc(sizeof(tmgraphedge));
+    if (!edge)
+        return 0;
+    edge->links[TM_EDGE_OUT_LINK].node = to;
+    edge->links[TM_EDGE_OUT_LINK].next = from->out;
+    from->out = &edge->links[TM_EDGE_OUT_LINK];
+    edge->links[TM_EDGE_IN_LINK].node = from;
+    edge->links[TM_EDGE_IN_LINK].next = to->in;
+    to->in = &edge->links[TM_EDGE_IN_LINK];
+    edge->allocs = site->allocs;
+    edge->frees = site->frees;
+    return 1;
+}

mozilla/tools/trace-malloc/tmreader.h

@@ -0,0 +1,192 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is tmreader.h/tmreader.c code, released
+ * July 7, 2000.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 2000 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ *    Brendan Eich, 7-July-2000
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the MPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ */
+#ifndef tmreader_h___
+#define tmreader_h___
+
+#include "prtypes.h"
+#include "plhash.h"
+#include "nsTraceMalloc.h"
+
+PR_BEGIN_EXTERN_C
+
+typedef struct tmreader     tmreader;
+typedef struct tmevent      tmevent;
+typedef struct tmcounts     tmcounts;
+typedef struct tmallcounts  tmallcounts;
+typedef struct tmgraphlink  tmgraphlink;
+typedef struct tmgraphedge  tmgraphedge;
+typedef struct tmgraphnode  tmgraphnode;
+typedef struct tmcallsite   tmcallsite;
+
+struct tmevent {
+    char            type;
+    uint32          serial;
+    union {
+        char        *libname;
+        struct {
+            uint32  library;
+            char    *name;
+        } method;
+        struct {
+            uint32  parent;
+            uint32  method;
+            uint32  offset;
+        } site;
+        struct {
+            uint32  oldsize;
+            uint32  size;
+        } alloc;
+        struct {
+            nsTMStats tmstats;
+            uint32  calltree_maxkids_parent;
+            uint32  calltree_maxstack_top;
+        } stats;
+    } u;
+};
+
+struct tmcounts {
+    uint32          direct;     /* things allocated by this node's code */
+    uint32          total;      /* direct + things from all descendents */
+};
+
+struct tmallcounts {
+    tmcounts        bytes;
+    tmcounts        calls;
+};
+
+struct tmgraphnode {
+    PLHashEntry     entry;      /* key is serial or name, value must be name */
+    tmgraphlink     *in;
+    tmgraphlink     *out;
+    tmgraphnode     *up;        /* parent in supergraph, e.g., JS for JS_*() */
+    tmgraphnode     *down;      /* subgraph kids, declining bytes.total order */
+    tmgraphnode     *next;      /* next kid in supergraph node's down list */
+    int             low;        /* 0 or lowest current tree walk level */
+    tmallcounts     allocs;
+    tmallcounts     frees;
+    double          sqsum;      /* sum of squared bytes.direct */
+    int             sort;       /* sorted index in node table, -1 if no table */
+};
+
+#define tmgraphnode_name(node)  ((char*) (node)->entry.value)
+
+#define tmlibrary_serial(lib)   ((uint32) (lib)->entry.key)
+#define tmcomponent_name(comp)  ((const char*) (comp)->entry.key)
+
+/* Half a graphedge, not including per-edge allocation stats. */
+struct tmgraphlink {
+    tmgraphlink     *next;      /* next fanning out from or into a node */
+    tmgraphnode     *node;      /* the other node (to if OUT, from if IN) */
+};
+
+/*
+ * It's safe to downcast a "from" tmgraphlink (one linked from a node's out
+ * pointer) to tmgraphedge.  To go from an "out" (linked via tmgraphedge.from)
+ * or "in" (linked via tmgraphedge.to) list link to its containing edge, use
+ * TM_LINK_TO_EDGE(link, which).
+ */
+struct tmgraphedge {
+    tmgraphlink     links[2];
+    tmallcounts     allocs;
+    tmallcounts     frees;
+};
+
+/* Indices into tmgraphedge.links -- out must come first. */
+#define TM_EDGE_OUT_LINK        0
+#define TM_EDGE_IN_LINK         1
+
+#define TM_LINK_TO_EDGE(link,which) ((tmgraphedge*) &(link)[-(which)])
+
+struct tmcallsite {
+    PLHashEntry     entry;      /* key is site serial number */
+    tmcallsite      *parent;    /* calling site */
+    tmcallsite      *siblings;  /* other sites reached from parent */
+    tmcallsite      *kids;      /* sites reached from here */
+    tmgraphnode     *method;    /* method node in tmr->methods graph */
+    uint32          offset;     /* pc offset from start of method */
+    tmallcounts     allocs;
+    tmallcounts     frees;
+};
+
+struct tmreader {
+    const char      *program;
+    void            *data;
+    PLHashTable     *libraries;
+    PLHashTable     *components;
+    PLHashTable     *methods;
+    PLHashTable     *callsites;
+    tmcallsite      calltree_root;
+};
+
+typedef void (*tmeventhandler)(tmreader *tmr, tmevent *event);
+
+/* The tmreader constructor and destructor. */
+extern tmreader     *tmreader_new(const char *program, void *data);
+extern void         tmreader_destroy(tmreader *tmr);
+
+/*
+ * Return -1 on permanent fatal error, 0 if filename can't be opened or is not
+ * a trace-malloc logfile, and 1 on success.
+ */
+extern int          tmreader_eventloop(tmreader *tmr, const char *filename,
+                                       tmeventhandler eventhandler);
+
+/* Map serial number or name to graphnode or callsite. */
+extern tmgraphnode  *tmreader_library(tmreader *tmr, uint32 serial);
+extern tmgraphnode  *tmreader_component(tmreader *tmr, const char *name);
+extern tmgraphnode  *tmreader_method(tmreader *tmr, uint32 serial);
+extern tmcallsite   *tmreader_callsite(tmreader *tmr, uint32 serial);
+
+/*
+ * Connect node 'from' to node 'to' with an edge, if there isn't one already
+ * connecting the nodes.  Add site's allocation stats to the edge only if we
+ * create the edge, or if we find that it exists, but that to->low is zero or
+ * less than from->low.
+ *
+ * If the callsite tree already totals allocation costs (tmcounts.total for
+ * each site includes tmcounts.direct for that site, plus tmcounts.total for
+ * all kid sites), then the node->low watermarks should be set from the tree
+ * level when walking the callsite tree, and should be set to non-zero values
+ * only if zero (the root is at level 0).  A low watermark should be cleared
+ * when the tree walk unwinds past the level at which it was set non-zero.
+ *
+ * Return 0 on error (malloc failure) and 1 on success.
+ */
+extern int tmgraphnode_connect(tmgraphnode *from, tmgraphnode *to,
+                               tmcallsite *site);
+
+PR_END_EXTERN_C
+
+#endif /* tmreader_h___ */

mozilla/webtools/bugzilla/docs/en/xml/Bugzilla-Guide.xml

@@ -1,135 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
-                      "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
-    <!ENTITY % myents SYSTEM "bugzilla.ent">
-    %myents;
-
-]>
-
-
-<!-- Coding standards for this document 
-
-*  Other than the GFDL, please use the "section" tag instead of "sect1", 
-   "sect2", etc.
-*  Use Entities to include files for new chapters in Bugzilla-Guide.xml.
-*  Try to use Entities for frequently-used passages of text as well.
-*  Ensure all documents compile cleanly to HTML after modification.
-   The warning, "DTDDECL catalog types not supported" is normal.
-*  Try to index important terms wherever possible.
-*  Use "glossterm" whenever you introduce a new term.
-*  Follow coding standards at http://www.tldp.org, and
-   check out the KDE guidelines (they are nice, too)
-   http://i18n.kde.org/doc/markup.html
-*  All tags should be lowercase.
-*  Please use sensible spacing.  The comments at the very end of each
-   file define reasonable defaults for PSGML mode in EMACS.
-*  Double-indent tags, use double spacing whenever possible, and
-   try to avoid clutter and feel free to waste space in the code to make it 
-   more readable.
-
--->
-
-<book id="index">
-
-<!-- Header -->
-
-  <bookinfo>
-    <title>The Bugzilla Guide - &bz-ver; 
-    <!-- BZ-DEVEL -->Development <!-- /BZ-DEVEL -->
-    Release</title>
-
-    <authorgroup>
-      <corpauthor>The Bugzilla Team</corpauthor>
-    </authorgroup>
-
-    <pubdate>&bz-date;</pubdate>
-
-    <abstract>
-      <para>
-	      This is the documentation for Bugzilla, a 
-	      bug-tracking system from mozilla.org.
-	      Bugzilla is an enterprise-class piece of software
-	      that tracks millions of bugs and issues for hundreds of
-	      organizations around the world.
-      </para>
-
-      <para>
-        The most current version of this document can always be found on the
-        <ulink url="http://www.bugzilla.org/docs/">Bugzilla 
-        Documentation Page</ulink>.
-      </para>
-
-    </abstract>
-
-    <keywordset>
-      <keyword>Bugzilla</keyword>
-      <keyword>Guide</keyword>
-      <keyword>installation</keyword>
-      <keyword>FAQ</keyword>
-      <keyword>administration</keyword>
-      <keyword>integration</keyword>
-      <keyword>MySQL</keyword>
-      <keyword>Mozilla</keyword>
-      <keyword>webtools</keyword>
-    </keywordset>
-  </bookinfo>
-
-  <!-- About This Guide -->
-  <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="about.xml" /> 
-  
-  <!-- Installing Bugzilla -->
-  <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="installation.xml" />
-
-  <!-- Administering Bugzilla -->
-  <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="administration.xml" />
-
-  <!-- Securing Bugzilla -->
-  <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="security.xml" />
-  
-  <!-- Customizing Bugzilla -->
-  <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="customization.xml" />
-
-  <!-- Using Bugzilla -->
-  <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="using.xml" />
-
-  <!-- Appendix: Troubleshooting -->
-  <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="troubleshooting.xml" />
-
-  <!-- Appendix: Custom Patches -->
-  <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="patches.xml" />
-
-  <!-- Appendix: Manually Installing Perl Modules -->
-  <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="modules.xml" />
-  
-  <!-- Appendix: GNU Free Documentation License -->
-  <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="gfdl.xml" />
- 
-  <!-- Glossary -->
-  <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="glossary.xml" />
-
-  <!-- Index -->
-  <!--xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="index.xml" /-->
-
-</book>
-
-<!-- Keep this comment at the end of the file
-Local variables:
-mode: sgml
-sgml-always-quote-attributes:t
-sgml-auto-insert-required-elements:t
-sgml-balanced-tag-edit:t
-sgml-exposed-tags:nil
-sgml-general-insert-case:lower
-sgml-indent-data:t
-sgml-indent-step:2
-sgml-local-catalogs:nil
-sgml-local-ecat-files:nil
-sgml-minimize-attributes:nil
-sgml-namecase-general:t
-sgml-omittag:t
-sgml-parent-document:("Bugzilla-Guide.xml" "book" "chapter")
-sgml-shorttag:t
-sgml-tag-region-if-active:t
-End:
--->
-

mozilla/webtools/bugzilla/docs/en/xml/about.xml

@@ -1,246 +0,0 @@
-<!DOCTYPE chapter PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
-                         "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
-    <!ENTITY % myents SYSTEM "bugzilla.ent">
-    %myents;
-]>
-<!-- $Id: about.xml,v 1.26.4.1 2008-07-13 16:44:28 mozilla%colinogilvie.co.uk Exp $ -->
-
-<chapter id="about">
-<title>About This Guide</title>
-
-  <section id="copyright">
-    <title>Copyright Information</title>
-
-    <para>This document is copyright (c) 2000-&current-year; by the various
-    Bugzilla contributors who wrote it.</para>
-    
-    <blockquote>
-      <para>
-	Permission is granted to copy, distribute and/or modify this
-	document under the terms of the GNU Free Documentation
-	License, Version 1.1 or any later version published by the
-	Free Software Foundation; with no Invariant Sections, no
-	Front-Cover Texts, and with no Back-Cover Texts. A copy of
-	the license is included in <xref linkend="gfdl"/>.
-      </para>
-    </blockquote>
-    <para>
-      If you have any questions regarding this document, its
-      copyright, or publishing this document in non-electronic form,
-      please contact the Bugzilla Team. 
-    </para>
-  </section>
-
-  <section id="disclaimer">
-    <title>Disclaimer</title>
-    <para>
-      No liability for the contents of this document can be accepted.
-      Follow the instructions herein at your own risk.
-      This document may contain errors
-      and inaccuracies that may damage your system, cause your partner 
-      to leave you, your boss to fire you, your cats to
-      pee on your furniture and clothing, and global thermonuclear
-      war. Proceed with caution.
-    </para>
-    <para>
-      Naming of particular products or brands should not be seen as
-      endorsements, with the exception of the term "GNU/Linux". We
-      wholeheartedly endorse the use of GNU/Linux; it is an extremely 
-      versatile, stable,
-      and robust operating system that offers an ideal operating
-      environment for Bugzilla.
-    </para>
-    <para>
-      Although the Bugzilla development team has taken great care to
-      ensure that all exploitable bugs have been fixed, security holes surely 
-      exist in any piece of code. Great care should be taken both in 
-      the installation and usage of this software. The Bugzilla development
-      team members assume no liability for your use of Bugzilla. You have 
-      the source code, and are responsible for auditing it yourself to ensure
-      your security needs are met.
-    </para>
-  </section>
-
-<!-- Section 2: New Versions -->
-
-  <section id="newversions">
-    <title>New Versions</title>
-    <para>
-      This is the &bz-ver; version of The Bugzilla Guide. It is so named 
-      to match the current version of Bugzilla. 
-      <!-- BZ-DEVEL --> This version of the guide, like its associated Bugzilla version, is a
-      development version.<!-- /BZ-DEVEL --> 
-    </para>
-    <para>
-      The latest version of this guide can always be found at <ulink
-      url="http://www.bugzilla.org"/>, or checked out via CVS by
-      following the <ulink url="http://www.mozilla.org/cvs.html">Mozilla 
-      CVS</ulink> instructions and check out the 
-      <filename>mozilla/webtools/bugzilla/docs/</filename>
-      subtree. However, you should read the version
-      which came with the Bugzilla release you are using.
-    </para>
-    <para>
-      The Bugzilla Guide, or a section of it, is also available in
-      the following languages:
-      <ulink url="http://www.traduc.org/docs/guides/lecture/bugzilla/">French</ulink>,
-      <ulink url="http://bugzilla-de.sourceforge.net/docs/html/">German</ulink>,
-      <ulink url="http://www.bugzilla.jp/docs/2.18/">Japanese</ulink>.
-      Note that these may be outdated or not up to date.
-    </para>
-    
-    <para>  
-      In addition, there are Bugzilla template localization projects in
-      the following languages. They may have translated documentation 
-      available: 
-      <ulink url="http://sourceforge.net/projects/bugzilla-ar/">Arabic</ulink>,
-      <ulink url="http://sourceforge.net/projects/bugzilla-be/">Belarusian</ulink>,
-      <ulink url="http://openfmi.net/projects/mozilla-bg/">Bulgarian</ulink>,
-      <ulink url="http://sourceforge.net/projects/bugzilla-br/">Brazilian Portuguese</ulink>,
-      <ulink url="http://sourceforge.net/projects/bugzilla-cn/">Chinese</ulink>,
-      <ulink url="http://sourceforge.net/projects/bugzilla-fr/">French</ulink>,
-      <ulink url="http://germzilla.ganderbay.net/">German</ulink>,
-      <ulink url="http://sourceforge.net/projects/bugzilla-it/">Italian</ulink>,
-      <ulink url="http://www.bugzilla.jp/about/jp.html">Japanese</ulink>,
-      <ulink url="http://sourceforge.net/projects/bugzilla-kr/">Korean</ulink>,
-      <ulink url="http://sourceforge.net/projects/bugzilla-ru/">Russian</ulink> and
-      <ulink url="http://sourceforge.net/projects/bugzilla-es/">Spanish</ulink>.
-    </para>
-    
-    <para>  
-      If you would like to volunteer to translate the Guide into additional
-      languages, please contact
-      <ulink url="mailto:justdave@bugzilla.org">Dave Miller</ulink>.
-    </para>
-  </section>
-
-  <section id="credits">
-    <title>Credits</title>
-    <para>
-      The people listed below have made enormous contributions to the
-      creation of this Guide, through their writing, dedicated hacking efforts,
-      numerous e-mail and IRC support sessions, and overall excellent
-      contribution to the Bugzilla community:
-    </para>
-
-    <!-- TODO: This is evil... there has to be a valid way to get this look -->
-    <variablelist>
-      <varlistentry>
-        <term>Matthew P. Barnson <email>mbarnson@sisna.com</email></term>
-        <listitem>
-          <para>for the Herculean task of pulling together the Bugzilla Guide
-          and shepherding it to 2.14.
-          </para>
-        </listitem>
-      </varlistentry>
-
-      <varlistentry>
-        <term>Terry Weissman <email>terry@mozilla.org</email></term>
-        <listitem>
-          <para>for initially writing Bugzilla and creating the README upon
-          which the UNIX installation documentation is largely based.
-          </para>
-        </listitem>
-      </varlistentry>
-
-      <varlistentry>
-        <term>Tara Hernandez <email>tara@tequilarists.org</email></term>
-        <listitem>
-          <para>for keeping Bugzilla development going strong after Terry left
-          mozilla.org and for running landfill.
-          </para>
-        </listitem>
-      </varlistentry>
-
-      <varlistentry>
-        <term>Dave Lawrence <email>dkl@redhat.com</email></term>
-        <listitem>
-          <para>for providing insight into the key differences between Red
-          Hat's customized Bugzilla.
-          </para>
-        </listitem>
-      </varlistentry>
-
-      <varlistentry>
-        <term>Dawn Endico <email>endico@mozilla.org</email></term>
-        <listitem>
-          <para>for being a hacker extraordinaire and putting up with Matthew's
-          incessant questions and arguments on irc.mozilla.org in #mozwebtools
-          </para>
-        </listitem>
-      </varlistentry>
-
-      <varlistentry>
-        <term>Jacob Steenhagen <email>jake@bugzilla.org</email></term>
-        <listitem>
-          <para>for taking over documentation during the 2.17 development
-          period.
-          </para>
-        </listitem>
-      </varlistentry>
-
-      <varlistentry>
-	<term>Dave Miller <email>justdave@bugzilla.org</email></term>
-	<listitem>
-          <para>for taking over as project lead when Tara stepped down and
-	  continually pushing for the documentation to be the best it can be.
-          </para>
-        </listitem>
-      </varlistentry>
-
-    </variablelist>
-
-
-    <para>
-      Thanks also go to the following people for significant contributions 
-      to this documentation:
-      <simplelist type="inline">
-        <member>Kevin Brannen</member>
-        <member>Vlad Dascalu</member>
-        <member>Ben FrantzDale</member>
-        <member>Eric Hanson</member>
-        <member>Zach Lipton</member>
-        <member>Gervase Markham</member>
-        <member>Andrew Pearson</member>
-        <member>Joe Robins</member>
-        <member>Spencer Smith</member>
-        <member>Ron Teitelbaum</member>
-        <member>Shane Travis</member>
-        <member>Martin Wulffeld</member>
-      </simplelist>.
-    </para>
-    
-    <para>
-      Also, thanks are due to the members of the 
-      <ulink url="news://news.mozilla.org/mozilla.support.bugzilla">
-      mozilla.support.bugzilla</ulink>
-      newsgroup (and its predecessor, netscape.public.mozilla.webtools).
-      Without your discussions, insight, suggestions, and patches,
-      this could never have happened.
-    </para>
-  </section>
-
-  <!-- conventions used here (didn't want to give it a chapter of its own) -->
-  <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="conventions.xml" /> 
-</chapter> 
-
-<!-- Keep this comment at the end of the file 
-Local variables: 
-mode: sgml 
-sgml-always-quote-attributes:t
-sgml-auto-insert-required-elements:t
-sgml-balanced-tag-edit:t
-sgml-exposed-tags:nil
-sgml-general-insert-case:lower
-sgml-indent-data:t 
-sgml-indent-step:2 
-sgml-local-catalogs:nil
-sgml-local-ecat-files:nil 
-sgml-minimize-attributes:nil
-sgml-namecase-general:t 
-sgml-omittag:t
-sgml-parent-document:("Bugzilla-Guide.xml" "book" "chapter")
-sgml-shorttag:t 
-sgml-tag-region-if-active:t 
-End: -->
-

mozilla/webtools/bugzilla/docs/en/xml/conventions.xml

@@ -1,168 +0,0 @@
-<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
-                      "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
-    <!ENTITY % myents SYSTEM "bugzilla.ent">
-    %myents;
-]>
-<section id="conventions">
-  <title>Document Conventions</title>
-
-  <indexterm zone="conventions">
-    <primary>conventions</primary>
-  </indexterm>
-
-  <para>This document uses the following conventions:</para>
-
-  <informaltable frame="none">
-    <tgroup cols="2">
-      <thead>
-        <row>
-          <entry>Descriptions</entry>
-
-          <entry>Appearance</entry>
-        </row>
-      </thead>
-
-      <tbody>
-        <row>
-          <entry>Caution</entry>
-
-          <entry>
-            <caution>
-              <para>Don't run with scissors!</para>
-            </caution>
-          </entry>
-        </row>
-
-        <row>
-          <entry>Hint or Tip</entry>
-
-          <entry>
-            <tip>
-              <para>For best results... </para>
-            </tip>
-          </entry>
-        </row>
-
-        <row>
-          <entry>Note</entry>
-
-          <entry>
-            <note>
-              <para>Dear John...</para>
-            </note>
-          </entry>
-        </row>
-
-        <row>
-          <entry>Warning</entry>
-
-          <entry>
-            <warning>
-              <para>Read this or the cat gets it.</para>
-            </warning>
-          </entry>
-        </row>
-
-        <row>
-          <entry>File or directory name</entry>
-
-          <entry>
-            <filename>filename</filename>
-          </entry>
-        </row>
-
-        <row>
-          <entry>Command to be typed</entry>
-
-          <entry>
-            <command>command</command>
-          </entry>
-        </row>
-
-        <row>
-          <entry>Application name</entry>
-
-          <entry>
-            <application>application</application>
-          </entry>
-        </row>
-
-        <row>
-          <entry>
-          Normal user's prompt under bash shell</entry>
-
-          <entry>bash$</entry>
-        </row>
-
-        <row>
-          <entry>
-          Root user's prompt under bash shell</entry>
-
-          <entry>bash#</entry>
-        </row>
-
-        <row>
-          <entry>
-          Normal user's prompt under tcsh shell</entry>
-
-          <entry>tcsh$</entry>
-        </row>
-
-        <row>
-          <entry>Environment variables</entry>
-
-          <entry>
-            <envar>VARIABLE</envar>
-          </entry>
-        </row>
-
-        <row>
-          <entry>Term found in the glossary</entry>
-
-          <entry>
-            <glossterm linkend="gloss-bugzilla">Bugzilla</glossterm>
-          </entry>
-        </row>
-
-        <row>
-          <entry>Code example</entry>
-
-          <entry>
-            <programlisting><sgmltag class="starttag">para</sgmltag>
-Beginning and end of paragraph
-<sgmltag class="endtag">para</sgmltag></programlisting>
-          </entry>
-        </row>
-      </tbody>
-    </tgroup>
-  </informaltable>
-
-  <para>  
-	  This documentation is maintained in DocBook 4.1.2 XML format.
-    Changes are best submitted as plain text or XML diffs, attached
-    to a bug filed in the &bzg-bugs; component.
-  </para>
-  
-</section>
-
-<!-- Keep this comment at the end of the file
-Local variables:
-mode: sgml
-sgml-always-quote-attributes:t
-sgml-auto-insert-required-elements:t
-sgml-balanced-tag-edit:t
-sgml-exposed-tags:nil
-sgml-general-insert-case:lower
-sgml-indent-data:t
-sgml-indent-step:2
-sgml-local-catalogs:nil
-sgml-local-ecat-files:nil
-sgml-minimize-attributes:nil
-sgml-namecase-general:t
-sgml-omittag:t
-sgml-parent-document:("Bugzilla-Guide.xml" "book" "chapter")
-sgml-shorttag:t
-sgml-tag-region-if-active:t
-End:
--->
-

mozilla/webtools/bugzilla/docs/en/xml/customization.xml

@@ -1,821 +0,0 @@
-<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
-                      "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
-    <!ENTITY % myents SYSTEM "bugzilla.ent">
-    %myents;
-]>
-<chapter id="customization">
-  <title>Customizing Bugzilla</title>
-
-  <section id="cust-skins">
-    <title>Custom Skins</title>
-    
-    <para>
-      Bugzilla allows you to have multiple skins. These are custom CSS and possibly
-      also custom images for Bugzilla. To create a new custom skin, you have two
-      choices:
-      <itemizedlist>
-        <listitem>
-          <para>
-            Make a single CSS file, and put it in the 
-            <filename>skins/contrib</filename> directory.
-          </para>
-        </listitem>
-        <listitem>
-          <para>
-            Make a directory that contains all the same CSS file
-            names as <filename>skins/standard/</filename>, and put
-            your directory in <filename>skins/contrib/</filename>.
-          </para>
-        </listitem>
-      </itemizedlist>
-    </para>
-      
-    <para>
-      After you put the file or the directory there, make sure to run checksetup.pl
-      so that it can reset the file permissions correctly.
-    </para>
-    <para>
-      After you have installed the new skin, it will show up as an option in the
-      user's General Preferences. If you would like to force a particular skin on all
-      users, just select it in the Default Preferences and then uncheck "Enabled" on
-      the preference.
-    </para>
-  </section>
-  
-  <section id="cust-templates">
-    <title>Template Customization</title>
-    
-    <para>
-      Administrators can configure the look and feel of Bugzilla without
-      having to edit Perl files or face the nightmare of massive merge
-      conflicts when they upgrade to a newer version in the future.
-    </para>
-    
-    <para>
-      Templatization also makes localized versions of Bugzilla possible, 
-      for the first time. It's possible to have Bugzilla's UI language 
-      determined by the user's browser. More information is available in
-      <xref linkend="template-http-accept"/>.
-    </para>
-    
-    <section id="template-directory">
-      <title>Template Directory Structure</title>
-      <para>
-        The template directory structure starts with top level directory 
-        named <filename>template</filename>, which contains a directory
-        for each installed localization. The next level defines the
-        language used in the templates. Bugzilla comes with English
-        templates, so the directory name is <filename>en</filename>,
-        and we will discuss <filename>template/en</filename> throughout
-        the documentation. Below <filename>template/en</filename> is the
-        <filename>default</filename> directory, which contains all the
-        standard templates shipped with Bugzilla.
-      </para>
-
-      <warning>
-        <para>
-          A directory <filename>data/templates</filename> also exists;
-          this is where Template Toolkit puts the compiled versions of
-          the templates from either the default or custom directories.
-          <emphasis>Do not</emphasis> directly edit the files in this
-          directory, or all your changes will be lost the next time
-          Template Toolkit recompiles the templates.
-        </para>
-      </warning>
-    </section>
-
-    <section id="template-method">
-      <title>Choosing a Customization Method</title>
-      <para>
-        If you want to edit Bugzilla's templates, the first decision
-        you must make is how you want to go about doing so. There are two
-        choices, and which you use depends mainly on the scope of your 
-        modifications, and the method you plan to use to upgrade Bugzilla.
-      </para> 
-
-      <para>
-        The first method of making customizations is to directly edit the
-        templates found in <filename>template/en/default</filename>.
-        This is probably the best way to go about it if you are going to
-        be upgrading Bugzilla through CVS, because if you then execute
-        a <command>cvs update</command>, any changes you have made will
-        be merged automagically with the updated versions.
-      </para>
-
-      <note>
-        <para>
-          If you use this method, and CVS conflicts occur during an
-          update, the conflicted templates (and possibly other parts
-          of your installation) will not work until they are resolved.
-        </para>
-      </note>
-
-      <para>
-        The second method is to copy the templates to be modified
-        into a mirrored directory structure under 
-        <filename>template/en/custom</filename>. Templates in this
-        directory structure automatically override any identically-named
-        and identically-located templates in the 
-        <filename>default</filename> directory. 
-      </para>
-
-      <note>
-        <para>
-          The <filename>custom</filename> directory does not exist
-          at first and must be created if you want to use it.
-        </para>
-      </note>
-
-      <para>
-        The second method of customization should be used if you 
-        use the overwriting method of upgrade, because otherwise 
-        your changes will be lost.  This method may also be better if
-        you are using the CVS method of upgrading and are going to make major
-        changes, because it is guaranteed that the contents of this directory
-        will not be touched during an upgrade, and you can then decide whether
-        to continue using your own templates, or make the effort to merge your
-        changes into the new versions by hand.
-      </para>
-
-      <para>
-        Using this method, your installation may break if incompatible
-        changes are made to the template interface.  Such changes should
-        be documented in the release notes, provided you are using a
-        stable release of Bugzilla.  If you use using unstable code, you will
-        need to deal with this one yourself, although if possible the changes
-        will be mentioned before they occur in the deprecations section of the
-        previous stable release's release notes.
-      </para>
-
-      <note>
-        <para>
-          Regardless of which method you choose, it is recommended that
-          you run <command>./checksetup.pl</command> after creating or
-          editing any templates in the <filename>template/en/default</filename>
-          directory, and after editing any templates in the 
-          <filename>custom</filename> directory.
-        </para>
-      </note>
-
-      <warning>
-        <para>
-          It is <emphasis>required</emphasis> that you run 
-          <command>./checksetup.pl</command> after creating a new
-          template in the <filename>custom</filename> directory. Failure
-          to do so will raise an incomprehensible error message.
-        </para>
-      </warning>
-    </section>
-    
-    <section id="template-edit">
-      <title>How To Edit Templates</title>
-      
-      <note>
-        <para>
-          If you are making template changes that you intend on submitting back
-          for inclusion in standard Bugzilla, you should read the relevant
-          sections of the 
-          <ulink url="http://www.bugzilla.org/docs/developer.html">Developers'
-          Guide</ulink>.
-        </para>
-      </note>
-      
-      <para>
-        The syntax of the Template Toolkit language is beyond the scope of
-        this guide. It's reasonably easy to pick up by looking at the current 
-        templates; or, you can read the manual, available on the
-        <ulink url="http://www.template-toolkit.org">Template Toolkit home
-        page</ulink>.
-      </para>
-      
-      <para>
-        One thing you should take particular care about is the need
-        to properly HTML filter data that has been passed into the template.
-        This means that if the data can possibly contain special HTML characters
-        such as &lt;, and the data was not intended to be HTML, they need to be
-        converted to entity form, i.e. &amp;lt;.  You use the 'html' filter in the
-        Template Toolkit to do this.  If you forget, you may open up
-        your installation to cross-site scripting attacks.
-      </para>
-
-      <para>
-        Also note that Bugzilla adds a few filters of its own, that are not
-        in standard Template Toolkit.  In particular, the 'url_quote' filter
-        can convert characters that are illegal or have special meaning in URLs,
-        such as &amp;, to the encoded form, i.e. %26.  This actually encodes most
-        characters (but not the common ones such as letters and numbers and so
-        on), including the HTML-special characters, so there's never a need to
-        HTML filter afterwards.
-      </para>
- 
-      <para>
-        Editing templates is a good way of doing a <quote>poor man's custom
-        fields</quote>.
-        For example, if you don't use the Status Whiteboard, but want to have
-        a free-form text entry box for <quote>Build Identifier</quote>,
-        then you can just
-        edit the templates to change the field labels. It's still be called
-        status_whiteboard internally, but your users don't need to know that.
-      </para>
-      
-    </section>
-            
-    
-    <section id="template-formats">
-      <title>Template Formats and Types</title>
-      
-      <para>
-        Some CGI's have the ability to use more than one template. For example,
-        <filename>buglist.cgi</filename> can output itself as RDF, or as two 
-        formats of HTML (complex and simple). The mechanism that provides this 
-        feature is extensible.
-      </para>
-
-      <para>
-        Bugzilla can support different types of output, which again can have 
-        multiple formats. In order to request a certain type, you can append 
-        the &amp;ctype=&lt;contenttype&gt; (such as rdf or html) to the 
-        <filename>&lt;cginame&gt;.cgi</filename> URL. If you would like to 
-        retrieve a certain format, you can use the &amp;format=&lt;format&gt; 
-        (such as simple or complex) in the URL.
-      </para>
-      
-      <para>
-        To see if a CGI supports multiple output formats and types, grep the
-        CGI for <quote>get_format</quote>. If it's not present, adding
-        multiple format/type support isn't too hard - see how it's done in
-        other CGIs, e.g. config.cgi.
-      </para>
-      
-      <para>
-        To make a new format template for a CGI which supports this, 
-        open a current template for
-        that CGI and take note of the INTERFACE comment (if present.) This 
-        comment defines what variables are passed into this template. If 
-        there isn't one, I'm afraid you'll have to read the template and
-        the code to find out what information you get. 
-      </para>     
-  
-      <para>
-        Write your template in whatever markup or text style is appropriate.
-      </para>
-      
-      <para>
-        You now need to decide what content type you want your template
-        served as. The content types are defined in the
-        <filename>Bugzilla/Constants.pm</filename> file in the 
-        <filename>contenttypes</filename>
-        constant. If your content type is not there, add it. Remember
-        the three- or four-letter tag assigned to your content type. 
-        This tag will be part of the template filename.
-      </para>
-
-      <note>
-        <para>
-          After adding or changing a content type, it's suitable to edit
-          <filename>Bugzilla/Constants.pm</filename> in order to reflect
-          the changes. Also, the file should be kept up to date after an
-          upgrade if content types have been customized in the past. 
-        </para>
-      </note>
-      
-      <para>
-        Save the template as <filename>&lt;stubname&gt;-&lt;formatname&gt;.&lt;contenttypetag&gt;.tmpl</filename>. 
-        Try out the template by calling the CGI as 
-        <filename>&lt;cginame&gt;.cgi?format=&lt;formatname&gt;&amp;ctype=&lt;type&gt;</filename> .
-      </para>       
-    </section>
-    
-    
-    <section id="template-specific">
-      <title>Particular Templates</title>
-      
-      <para>
-        There are a few templates you may be particularly interested in
-        customizing for your installation.
-      </para>
-      
-      <para>
-        <command>index.html.tmpl</command>:
-        This is the Bugzilla front page.
-      </para>      
-
-      <para>
-        <command>global/header.html.tmpl</command>:
-        This defines the header that goes on all Bugzilla pages.
-        The header includes the banner, which is what appears to users
-        and is probably what you want to edit instead.  However the
-        header also includes the HTML HEAD section, so you could for
-        example add a stylesheet or META tag by editing the header.
-      </para>
-
-      <para>
-        <command>global/banner.html.tmpl</command>:
-        This contains the <quote>banner</quote>, the part of the header
-        that appears
-        at the top of all Bugzilla pages.  The default banner is reasonably
-        barren, so you'll probably want to customize this to give your
-        installation a distinctive look and feel.  It is recommended you
-        preserve the Bugzilla version number in some form so the version 
-        you are running can be determined, and users know what docs to read.
-      </para>
-
-      <para>
-        <command>global/footer.html.tmpl</command>:
-        This defines the footer that goes on all Bugzilla pages.  Editing
-        this is another way to quickly get a distinctive look and feel for
-        your Bugzilla installation.
-      </para>
-
-      <para>
-        <command>global/variables.none.tmpl</command>:
-        This defines a list of terms that may be changed in order to
-        <quote>brand</quote> the Bugzilla instance In this way, terms
-        like <quote>bugs</quote> can be replaced with <quote>issues</quote>
-        across the whole Bugzilla installation. The name
-        <quote>Bugzilla</quote> and other words can be customized as well.
-      </para>
-
-      <para>
-        <command>list/table.html.tmpl</command>:
-        This template controls the appearance of the bug lists created
-        by Bugzilla. Editing this template allows per-column control of 
-        the width and title of a column, the maximum display length of
-        each entry, and the wrap behaviour of long entries.
-        For long bug lists, Bugzilla inserts a 'break' every 100 bugs by
-        default; this behaviour is also controlled by this template, and
-        that value can be modified here.
-       </para>
-
-      <para>
-        <command>bug/create/user-message.html.tmpl</command>:
-        This is a message that appears near the top of the bug reporting page.
-        By modifying this, you can tell your users how they should report
-        bugs.
-      </para>
-
-      <para>
-        <command>bug/process/midair.html.tmpl</command>:
-        This is the page used if two people submit simultaneous changes to the
-        same bug.  The second person to submit their changes will get this page
-        to tell them what the first person did, and ask if they wish to
-        overwrite those changes or go back and revisit the bug.  The default
-        title and header on this page read "Mid-air collision detected!"  If
-        you work in the aviation industry, or other environment where this
-        might be found offensive (yes, we have true stories of this happening)
-        you'll want to change this to something more appropriate for your
-        environment.
-      </para>
-
-      <para>
-        <command>bug/create/create.html.tmpl</command> and
-        <command>bug/create/comment.txt.tmpl</command>:
-        You may not wish to go to the effort of creating custom fields in
-        Bugzilla, yet you want to make sure that each bug report contains
-        a number of pieces of important information for which there is not
-        a special field. The bug entry system has been designed in an
-        extensible fashion to enable you to add arbitrary HTML widgets,
-        such as drop-down lists or textboxes, to the bug entry page
-        and have their values appear formatted in the initial comment.
-        A hidden field that indicates the format should be added inside
-        the form in order to make the template functional. Its value should
-        be the suffix of the template filename. For example, if the file
-        is called <filename>create-cust.html.tmpl</filename>, then
-        <programlisting>&lt;input type="hidden" name="format" value="cust"&gt;</programlisting>
-        should be used inside the form.
-      </para>
-
-      <para>  
-        An example of this is the mozilla.org 
-        <ulink url="http://landfill.bugzilla.org/bugzilla-tip/enter_bug.cgi?product=WorldControl&amp;format=guided">guided 
-        bug submission form</ulink>. The code for this comes with the Bugzilla
-        distribution as an example for you to copy. It can be found in the
-        files 
-        <filename>create-guided.html.tmpl</filename> and
-        <filename>comment-guided.html.tmpl</filename>.
-      </para>  
-
-      <para>
-        So to use this feature, create a custom template for 
-        <filename>enter_bug.cgi</filename>. The default template, on which you
-        could base it, is 
-        <filename>custom/bug/create/create.html.tmpl</filename>.
-        Call it <filename>create-&lt;formatname&gt;.html.tmpl</filename>, and
-        in it, add widgets for each piece of information you'd like
-        collected - such as a build number, or set of steps to reproduce.
-      </para>
-
-      <para>
-        Then, create a template like 
-        <filename>custom/bug/create/comment.txt.tmpl</filename>, and call it 
-        <filename>comment-&lt;formatname&gt;.txt.tmpl</filename>. This 
-        template should reference the form fields you have created using
-        the syntax <filename>[% form.&lt;fieldname&gt; %]</filename>. When a 
-        bug report is
-        submitted, the initial comment attached to the bug report will be
-        formatted according to the layout of this template.
-      </para> 
-
-      <para>
-        For example, if your custom enter_bug template had a field
-        <programlisting>&lt;input type="text" name="buildid" size="30"&gt;</programlisting>
-        and then your comment.txt.tmpl had
-        <programlisting>BuildID: [% form.buildid %]</programlisting>
-        then something like
-        <programlisting>BuildID: 20020303</programlisting>
-        would appear in the initial comment.
-      </para>            
-    </section>          
-
-
-    <section id="template-http-accept">
-      <title>Configuring Bugzilla to Detect the User's Language</title>
-
-      <para>Bugzilla honours the user's Accept: HTTP header. You can install
-      templates in other languages, and Bugzilla will pick the most appropriate
-      according to a priority order defined by you. Many
-      language templates can be obtained from <ulink 
-      url="http://www.bugzilla.org/download.html#localizations"/>. Instructions
-      for submitting new languages are also available from that location.
-      </para>
-    </section>
-      
-  </section>
-
-  <section id="cust-hooks">
-    <title>The Bugzilla Extension Mechanism</title>
-    
-    <warning>
-      <para>
-        Note that the below paths are inconsistent and confusing. They will
-        likely be changed in Bugzilla 4.0.
-      </para>
-    </warning>
-       
-    <para>
-      Extensions are a way for extensions to Bugzilla to insert code
-      into the standard Bugzilla templates and source files
-      without modifying these files themselves.  The extension mechanism 
-      defines a consistent API for extending the standard templates and source files 
-      in a way that cleanly separates standard code from extension code.  
-      Hooks reduce merge conflicts and make it easier to write extensions that work 
-      across multiple versions of Bugzilla, making upgrading a Bugzilla installation 
-      with installed extensions easier. Furthermore, they make it easy to install 
-      and remove extensions as each extension is nothing more than a 
-      simple directory structure. 
-    </para>
-    
-    <para>
-      There are two main types of hooks: code hooks and template hooks. Code 
-      hooks allow extensions to invoke code at specific points in various 
-      source files, while template hooks allow extensions to add elements to 
-      the Bugzilla user interface. 
-    </para>
-
-    <para>
-      A hook is just a named place in a standard source or template file
-      where extension source code or template files for that hook get processed. 
-      Each extension has a corresponding directory in the Bugzilla directory 
-      tree (<filename>BUGZILLA_ROOT/extensions/extension_name</filename>).  Hooking 
-      an extension source file or template to a hook is as simple as putting 
-      the extension file into extension's template or code directory. 
-      When Bugzilla processes the source file or template and reaches the hook, 
-      it will process all extension files in the hook's directory. 
-      The hooks themselves can be added into any source file or standard template 
-      upon request by extension authors.
-    </para>
-    
-    <para>
-      To use hooks to extend Bugzilla, first make sure there is
-      a hook at the appropriate place within the source file or template you 
-      want to extend. The exact appearance of a hook depends on if the hook 
-      is a code hook or a template hook. 
-    </para>
-    
-    <para>
-      Code hooks appear in Bugzilla source files as a single method call 
-      in the format <literal role="code">Bugzilla::Hook->process("<varname>name</varname>");</literal>.
-      For instance, <filename>enter_bug.cgi</filename> may invoke the hook 
-      "<varname>enter_bug-entrydefaultvars</varname>". Thus, a source file at 
-      <filename>BUGZILLA_ROOT/extensions/EXTENSION_NAME/code/enter_bug-entrydefaultvars.pl</filename>
-      will be automatically invoked when the code hook is reached. 
-    </para>
-   
-    <para>  
-      Template hooks appear in the standard Bugzilla templates as a 
-      single directive in the format
-      <literal role="code">[% Hook.process("<varname>name</varname>") %]</literal>,
-      where <varname>name</varname> is the unique name of the hook.
-    </para>
-
-    <para>
-      If you aren't sure what you want to extend or just want to browse the 
-      available hooks, either use your favorite multi-file search
-      tool (e.g. <command>grep</command>) to search the standard templates
-      for occurrences of <methodname>Hook.process</methodname> or the source 
-      files for occurrences of <methodname>Bugzilla::Hook::process</methodname>.
-    </para>
-
-    <para>
-      If there is no hook at the appropriate place within the Bugzilla 
-      source file or template you want to extend,
-      <ulink url="http://bugzilla.mozilla.org/enter_bug.cgi?product=Bugzilla&amp;component=User%20Interface">file
-      a bug requesting one</ulink>, specifying:
-    </para>
-
-    <simplelist>
-      <member>the source or template file for which you are 
-          requesting a hook;</member>
-      <member>
-        where in the file you would like the hook to be placed
-        (line number/position for latest version of the file in CVS
-        or description of location);
-      </member>
-      <member>the purpose of the hook;</member>
-      <member>a link to information about your extension, if any.</member>
-    </simplelist>
-
-    <para>
-      The Bugzilla reviewers will promptly review each hook request,
-      name the hook, add it to the template or source file, and check 
-      the new version of the template into CVS.
-    </para>
-
-    <para>
-      You may optionally attach a patch to the bug which implements the hook
-      and check it in yourself after receiving approval from a Bugzilla
-      reviewer.  The developers may suggest changes to the location of the
-      hook based on their analysis of your needs or so the hook can satisfy
-      the needs of multiple extensions, but the process of getting hooks
-      approved and checked in is not as stringent as the process for general
-      changes to Bugzilla, and any extension, whether released or still in
-      development, can have hooks added to meet their needs.
-    </para>
-
-    <para>
-      After making sure the hook you need exists (or getting it added if not),
-      add your extension to the directory within the Bugzilla
-      extensions tree corresponding to the hook. 
-    </para>
-    
-    <para>
-      That's it!  Now, when the source file or template containing the hook
-      is processed, your extension file will be processed at the point 
-      where the hook appears.
-    </para>
-
-    <para>
-      For example, let's say you have an extension named Projman that adds
-      project management capabilities to Bugzilla.  Projman has an
-      administration interface <filename>edit-projects.cgi</filename>, 
-      and you want to add a link to it into the navigation bar at the bottom
-      of every Bugzilla page for those users who are authorized
-      to administer projects.
-    </para>
-
-    <para>
-      The navigation bar is generated by the template file
-      <filename>useful-links.html.tmpl</filename>, which is located in
-      the <filename>global/</filename> subdirectory on the standard Bugzilla 
-      template path
-      <filename>BUGZILLA_ROOT/template/en/default/</filename>.
-      Looking in <filename>useful-links.html.tmpl</filename>, you find
-      the following hook at the end of the list of standard Bugzilla
-      administration links:
-    </para>
-
-    <programlisting><![CDATA[...
-    [% ', <a href="editkeywords.cgi">keywords</a>' 
-                                              IF user.groups.editkeywords %]
-    [% Hook.process("edit") %]
-...]]></programlisting>
-
-    <para>
-      The corresponding extension file for this hook is
-      <filename>BUGZILLA_ROOT/extensions/projman/template/en/global/useful-links-edit.html.tmpl</filename>.
-      You then create that template file and add the following constant:
-    </para>
-
-    <programlisting><![CDATA[...[% ', <a href="edit-projects.cgi">projects</a>' IF user.groups.projman_admins %]]]></programlisting>
-
-    <para>
-      Voila!  The link now appears after the other administration links in the
-      navigation bar for users in the <literal>projman_admins</literal> group.
-    </para>
-    
-    <para>
-      Now, let us say your extension adds a custom "project_manager" field 
-      to enter_bug.cgi. You want to modify the CGI script to set the default 
-      project manager to be productname@company.com. Looking at 
-      <filename>enter_bug.cgi</filename>, you see the enter_bug-entrydefaultvars 
-      hook near the bottom of the file before the default form values are set. 
-      The corresponding extension source file for this hook is located at 
-      <filename>BUGZILLA_ROOT/extensions/projman/code/enter_bug-entrydefaultvars.pl</filename>.
-      You then create that file and add the following:
-    </para>
-    
-    <programlisting>$default{'project_manager'} = $product.'@company.com';</programlisting>
-    
-    <para>
-      This code will be invoked whenever enter_bug.cgi is executed. 
-      Assuming that the rest of the customization was completed (e.g. the 
-      custom field was added to the enter_bug template and the required hooks 
-      were used in process_bug.cgi), the new field will now have this 
-      default value. 
-    </para>
-      
-    <para>
-      Notes:
-    </para>
-
-    <itemizedlist>
-      <listitem>
-        <para>
-          If your extension includes entirely new templates in addition to
-          extensions of standard templates, it should store those new
-          templates in its
-          <filename>BUGZILLA_ROOT/extensions/template/en/</filename> 
-          directory. Extension template directories, like the 
-          <filename>default/</filename> and <filename>custom/</filename>
-          directories, are part of the template search path, so putting templates
-          there enables them to be found by the template processor.
-        </para>
-
-        <para>
-          The template processor looks for templates first in the
-          <filename>custom/</filename> directory (i.e. templates added by the 
-          specific installation), then in the <filename>extensions/</filename>
-          directory (i.e. templates added by extensions), and finally in the 
-          <filename>default/</filename> directory (i.e. the standard Bugzilla 
-          templates). Thus, installation-specific templates override both 
-          default and extension templates.
-        </para>
-      </listitem>
-
-      <listitem>
-        <para>
-          If you are looking to customize Bugzilla, you can also take advantage 
-          of template hooks. To do so, create a directory in
-          <filename>BUGZILLA_ROOT/template/en/custom/hook/</filename>
-          that corresponds to the hook you wish to use, then place your 
-          customization templates into those directories. For example, 
-          if you wanted to use the hook "end" in 
-          <filename>global/useful-links.html.tmpl</filename>, you would 
-          create the directory <filename>BUGZILLA_ROOT/template/en/custom/hook/
-          global/useful-links.html.tmpl/end/</filename> and add your customization 
-          template to this directory. 
-        </para>
-
-        <para>
-          Obviously this method of customizing Bugzilla only lets you add code
-          to the standard source files and templates; you cannot change the 
-          existing code. Nevertheless, for those customizations that only add 
-          code, this method can reduce conflicts when merging changes, 
-          making upgrading your customized Bugzilla installation easier.
-        </para>
-      </listitem>
-    </itemizedlist>    
-  </section>
-
-  <section id="cust-change-permissions">
-    <title>Customizing Who Can Change What</title>
-    
-    <warning>
-      <para>
-        This feature should be considered experimental; the Bugzilla code you
-        will be changing is not stable, and could change or move between 
-        versions. Be aware that if you make modifications as outlined here, 
-        you may have
-        to re-make them or port them if Bugzilla changes internally between
-        versions, and you upgrade.
-      </para>
-    </warning>
-      
-    <para>
-      Companies often have rules about which employees, or classes of employees,
-      are allowed to change certain things in the bug system. For example, 
-      only the bug's designated QA Contact may be allowed to VERIFY the bug.
-      Bugzilla has been
-      designed to make it easy for you to write your own custom rules to define
-      who is allowed to make what sorts of value transition.
-    </para>
-
-    <para>
-     By default, assignees, QA owners and users
-     with <emphasis>editbugs</emphasis> privileges can edit all fields of bugs, 
-     except group restrictions (unless they are members of the groups they 
-     are trying to change). Bug reporters also have the ability to edit some 
-     fields, but in a more restrictive manner. Other users, without 
-     <emphasis>editbugs</emphasis> privileges, can not edit 
-     bugs, except to comment and add themselves to the CC list.
-    </para> 
-    
-    <para>
-      For maximum flexibility, customizing this means editing Bugzilla's Perl 
-      code. This gives the administrator complete control over exactly who is
-      allowed to do what. The relevant method is called
-      <filename>check_can_change_field()</filename>,
-      and is found in <filename>Bug.pm</filename> in your
-      Bugzilla/ directory. If you open that file and search for
-      <quote>sub check_can_change_field</quote>, you'll find it.
-    </para>
-    
-    <para>
-      This function has been carefully commented to allow you to see exactly
-      how it works, and give you an idea of how to make changes to it.
-      Certain marked sections should not be changed - these are
-      the <quote>plumbing</quote> which makes the rest of the function work.
-      In between those sections, you'll find snippets of code like:
-      <programlisting>    # Allow the assignee to change anything.
-    if ($ownerid eq $whoid) {
-        return 1;
-    }</programlisting>
-      It's fairly obvious what this piece of code does.
-    </para>      
-      
-    <para>
-      So, how does one go about changing this function? Well, simple changes
-      can be made just by removing pieces - for example, if you wanted to 
-      prevent any user adding a comment to a bug, just remove the lines marked
-      <quote>Allow anyone to change comments.</quote> If you don't want the
-      Reporter to have any special rights on bugs they have filed, just
-      remove the entire section that deals with the Reporter.
-    </para>
-    
-    <para>
-      More complex customizations are not much harder. Basically, you add
-      a check in the right place in the function, i.e. after all the variables
-      you are using have been set up. So, don't look at $ownerid before 
-      $ownerid has been obtained from the database. You can either add a
-      positive check, which returns 1 (allow) if certain conditions are true,
-      or a negative check, which returns 0 (deny.) E.g.:
-      <programlisting>    if ($field eq "qacontact") {
-        if (Bugzilla->user->groups("quality_assurance")) {
-            return 1;
-        } 
-        else {
-            return 0;
-        }
-    }</programlisting>
-      This says that only users in the group "quality_assurance" can change
-      the QA Contact field of a bug.
-    </para>
-
-    <para>
-      Getting more weird:
-      <programlisting><![CDATA[    if (($field eq "priority") &&
-        (Bugzilla->user->email =~ /.*\@example\.com$/))
-    {
-        if ($oldvalue eq "P1") {
-            return 1;
-        } 
-        else {
-            return 0;
-        }
-    }]]></programlisting>
-      This says that if the user is trying to change the priority field,
-      and their email address is @example.com, they can only do so if the
-      old value of the field was "P1". Not very useful, but illustrative.
-    </para>
-
-    <warning>
-      <para>
-        If you are modifying <filename>process_bug.cgi</filename> in any
-        way, do not change the code that is bounded by DO_NOT_CHANGE blocks.
-        Doing so could compromise security, or cause your installation to
-        stop working entirely.
-      </para>
-    </warning>
-    
-    <para>
-      For a list of possible field names, look at the bugs table in the 
-      database. If you need help writing custom rules for your organization,
-      ask in the newsgroup.
-    </para>    
-  </section>   
-
-  <!-- Integrating Bugzilla with Third-Party Tools -->
-<xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="integration.xml" />
-</chapter>
-
-<!-- Keep this comment at the end of the file
-Local variables:
-mode: sgml
-sgml-always-quote-attributes:t
-sgml-auto-insert-required-elements:t
-sgml-balanced-tag-edit:t
-sgml-exposed-tags:nil
-sgml-general-insert-case:lower
-sgml-indent-data:t
-sgml-indent-step:2
-sgml-local-catalogs:nil
-sgml-local-ecat-files:nil
-sgml-minimize-attributes:nil
-sgml-namecase-general:t
-sgml-omittag:t
-sgml-parent-document:("Bugzilla-Guide.xml" "book" "chapter")
-sgml-shorttag:t
-sgml-tag-region-if-active:t
-End:
--->
-

mozilla/webtools/bugzilla/docs/en/xml/gfdl.xml

@@ -1,449 +0,0 @@
-<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
-                      "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
-    <!ENTITY % myents SYSTEM "bugzilla.ent">
-    %myents;
-]>
-<appendix id="gfdl">
-  <title>GNU Free Documentation License</title>
-
-<!-- - GNU Project - Free Software Foundation (FSF) -->
-<!-- LINK REV="made" HREF="mailto:webmasters@gnu.org" -->
-<!-- section>
-    <title>GNU Free Documentation License</title -->
-  <para>Version 1.1, March 2000</para>
-
-  <blockquote>
-    <para>Copyright (C) 2000 Free Software Foundation, Inc. 59 Temple Place,
-    Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and
-    distribute verbatim copies of this license document, but changing it is
-    not allowed.</para>
-  </blockquote>
-
-  <section label="0" id="gfdl-0">
-    <title>Preamble</title>
-
-    <para>The purpose of this License is to make a manual, textbook, or other
-    written document "free" in the sense of freedom: to assure everyone the
-    effective freedom to copy and redistribute it, with or without modifying
-    it, either commercially or noncommercially. Secondarily, this License
-    preserves for the author and publisher a way to get credit for their
-    work, while not being considered responsible for modifications made by
-    others.</para>
-
-    <para>This License is a kind of "copyleft", which means that derivative
-    works of the document must themselves be free in the same sense. It
-    complements the GNU General Public License, which is a copyleft license
-    designed for free software.</para>
-
-    <para>We have designed this License in order to use it for manuals for
-    free software, because free software needs free documentation: a free
-    program should come with manuals providing the same freedoms that the
-    software does. But this License is not limited to software manuals; it
-    can be used for any textual work, regardless of subject matter or whether
-    it is published as a printed book. We recommend this License principally
-    for works whose purpose is instruction or reference.</para>
-  </section>
-
-  <section label="1" id="gfdl-1">
-    <title>Applicability and Definition</title>
-
-    <para>This License applies to any manual or other work that contains a
-    notice placed by the copyright holder saying it can be distributed under
-    the terms of this License. The "Document", below, refers to any such
-    manual or work. Any member of the public is a licensee, and is addressed
-    as "you".</para>
-
-    <para>A "Modified Version" of the Document means any work containing the
-    Document or a portion of it, either copied verbatim, or with
-    modifications and/or translated into another language.</para>
-
-    <para>A "Secondary Section" is a named appendix or a front-matter section
-    of the Document that deals exclusively with the relationship of the
-    publishers or authors of the Document to the Document's overall subject
-    (or to related matters) and contains nothing that could fall directly
-    within that overall subject. (For example, if the Document is in part a
-    textbook of mathematics, a Secondary Section may not explain any
-    mathematics.) The relationship could be a matter of historical connection
-    with the subject or with related matters, or of legal, commercial,
-    philosophical, ethical or political position regarding them.</para>
-
-    <para>The "Invariant Sections" are certain Secondary Sections whose
-    titles are designated, as being those of Invariant Sections, in the
-    notice that says that the Document is released under this License.</para>
-
-    <para>The "Cover Texts" are certain short passages of text that are
-    listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says
-    that the Document is released under this License.</para>
-
-    <para>A "Transparent" copy of the Document means a machine-readable copy,
-    represented in a format whose specification is available to the general
-    public, whose contents can be viewed and edited directly and
-    straightforwardly with generic text editors or (for images composed of
-    pixels) generic paint programs or (for drawings) some widely available
-    drawing editor, and that is suitable for input to text formatters or for
-    automatic translation to a variety of formats suitable for input to text
-    formatters. A copy made in an otherwise Transparent file format whose
-    markup has been designed to thwart or discourage subsequent modification
-    by readers is not Transparent. A copy that is not "Transparent" is called
-    "Opaque".</para>
-
-    <para>Examples of suitable formats for Transparent copies include plain
-    ASCII without markup, Texinfo input format, LaTeX input format, SGML or
-    XML using a publicly available DTD, and standard-conforming simple HTML
-    designed for human modification. Opaque formats include PostScript, PDF,
-    proprietary formats that can be read and edited only by proprietary word
-    processors, SGML or XML for which the DTD and/or processing tools are not
-    generally available, and the machine-generated HTML produced by some word
-    processors for output purposes only.</para>
-
-    <para>The "Title Page" means, for a printed book, the title page itself,
-    plus such following pages as are needed to hold, legibly, the material
-    this License requires to appear in the title page. For works in formats
-    which do not have any title page as such, "Title Page" means the text
-    near the most prominent appearance of the work's title, preceding the
-    beginning of the body of the text.</para>
-  </section>
-
-  <section label="2" id="gfdl-2">
-    <title>Verbatim Copying</title>
-
-    <para>You may copy and distribute the Document in any medium, either
-    commercially or noncommercially, provided that this License, the
-    copyright notices, and the license notice saying this License applies to
-    the Document are reproduced in all copies, and that you add no other
-    conditions whatsoever to those of this License. You may not use technical
-    measures to obstruct or control the reading or further copying of the
-    copies you make or distribute. However, you may accept compensation in
-    exchange for copies. If you distribute a large enough number of copies
-    you must also follow the conditions in section 3.</para>
-
-    <para>You may also lend copies, under the same conditions stated above,
-    and you may publicly display copies.</para>
-  </section>
-
-  <section label="3" id="gfdl-3">
-    <title>Copying in Quantity</title>
-
-    <para>If you publish printed copies of the Document numbering more than
-    100, and the Document's license notice requires Cover Texts, you must
-    enclose the copies in covers that carry, clearly and legibly, all these
-    Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts
-    on the back cover. Both covers must also clearly and legibly identify you
-    as the publisher of these copies. The front cover must present the full
-    title with all words of the title equally prominent and visible. You may
-    add other material on the covers in addition. Copying with changes
-    limited to the covers, as long as they preserve the title of the Document
-    and satisfy these conditions, can be treated as verbatim copying in other
-    respects.</para>
-
-    <para>If the required texts for either cover are too voluminous to fit
-    legibly, you should put the first ones listed (as many as fit reasonably)
-    on the actual cover, and continue the rest onto adjacent pages.</para>
-
-    <para>If you publish or distribute Opaque copies of the Document
-    numbering more than 100, you must either include a machine-readable
-    Transparent copy along with each Opaque copy, or state in or with each
-    Opaque copy a publicly-accessible computer-network location containing a
-    complete Transparent copy of the Document, free of added material, which
-    the general network-using public has access to download anonymously at no
-    charge using public-standard network protocols. If you use the latter
-    option, you must take reasonably prudent steps, when you begin
-    distribution of Opaque copies in quantity, to ensure that this
-    Transparent copy will remain thus accessible at the stated location until
-    at least one year after the last time you distribute an Opaque copy
-    (directly or through your agents or retailers) of that edition to the
-    public.</para>
-
-    <para>It is requested, but not required, that you contact the authors of
-    the Document well before redistributing any large number of copies, to
-    give them a chance to provide you with an updated version of the
-    Document.</para>
-  </section>
-
-  <section label="4" id="gfdl-4">
-    <title>Modifications</title>
-
-    <para>You may copy and distribute a Modified Version of the Document
-    under the conditions of sections 2 and 3 above, provided that you release
-    the Modified Version under precisely this License, with the Modified
-    Version filling the role of the Document, thus licensing distribution and
-    modification of the Modified Version to whoever possesses a copy of it.
-    In addition, you must do these things in the Modified Version:</para>
-
-    <orderedlist numeration="upperalpha">
-      <listitem>
-        <para>Use in the Title Page (and on the covers, if any) a title
-        distinct from that of the Document, and from those of previous
-        versions (which should, if there were any, be listed in the History
-        section of the Document). You may use the same title as a previous
-        version if the original publisher of that version gives
-        permission.</para>
-      </listitem>
-
-      <listitem>
-        <para>List on the Title Page, as authors, one or more persons or
-        entities responsible for authorship of the modifications in the
-        Modified Version, together with at least five of the principal
-        authors of the Document (all of its principal authors, if it has less
-        than five).</para>
-      </listitem>
-
-      <listitem>
-        <para>State on the Title page the name of the publisher of the
-        Modified Version, as the publisher.</para>
-      </listitem>
-
-      <listitem>
-        <para>Preserve all the copyright notices of the Document.</para>
-      </listitem>
-
-      <listitem>
-        <para>Add an appropriate copyright notice for your modifications
-        adjacent to the other copyright notices.</para>
-      </listitem>
-
-      <listitem>
-        <para>Include, immediately after the copyright notices, a license
-        notice giving the public permission to use the Modified Version under
-        the terms of this License, in the form shown in the Addendum
-        below.</para>
-      </listitem>
-
-      <listitem>
-        <para>Preserve in that license notice the full lists of Invariant
-        Sections and required Cover Texts given in the Document's license
-        notice.</para>
-      </listitem>
-
-      <listitem>
-        <para>Include an unaltered copy of this License.</para>
-      </listitem>
-
-      <listitem>
-        <para>Preserve the section entitled "History", and its title, and add
-        to it an item stating at least the title, year, new authors, and
-        publisher of the Modified Version as given on the Title Page. If
-        there is no section entitled "History" in the Document, create one
-        stating the title, year, authors, and publisher of the Document as
-        given on its Title Page, then add an item describing the Modified
-        Version as stated in the previous sentence.</para>
-      </listitem>
-
-      <listitem>
-        <para>Preserve the network location, if any, given in the Document
-        for public access to a Transparent copy of the Document, and likewise
-        the network locations given in the Document for previous versions it
-        was based on. These may be placed in the "History" section. You may
-        omit a network location for a work that was published at least four
-        years before the Document itself, or if the original publisher of the
-        version it refers to gives permission.</para>
-      </listitem>
-
-      <listitem>
-        <para>In any section entitled "Acknowledgements" or "Dedications",
-        preserve the section's title, and preserve in the section all the
-        substance and tone of each of the contributor acknowledgements and/or
-        dedications given therein.</para>
-      </listitem>
-
-      <listitem>
-        <para>Preserve all the Invariant Sections of the Document, unaltered
-        in their text and in their titles. Section numbers or the equivalent
-        are not considered part of the section titles.</para>
-      </listitem>
-
-      <listitem>
-        <para>Delete any section entitled "Endorsements". Such a section may
-        not be included in the Modified Version.</para>
-      </listitem>
-
-      <listitem>
-        <para>Do not retitle any existing section as "Endorsements" or to
-        conflict in title with any Invariant Section.</para>
-      </listitem>
-    </orderedlist>
-
-    <para>If the Modified Version includes new front-matter sections or
-    appendices that qualify as Secondary Sections and contain no material
-    copied from the Document, you may at your option designate some or all of
-    these sections as invariant. To do this, add their titles to the list of
-    Invariant Sections in the Modified Version's license notice. These titles
-    must be distinct from any other section titles.</para>
-
-    <para>You may add a section entitled "Endorsements", provided it contains
-    nothing but endorsements of your Modified Version by various parties--for
-    example, statements of peer review or that the text has been approved by
-    an organization as the authoritative definition of a standard.</para>
-
-    <para>You may add a passage of up to five words as a Front-Cover Text,
-    and a passage of up to 25 words as a Back-Cover Text, to the end of the
-    list of Cover Texts in the Modified Version. Only one passage of
-    Front-Cover Text and one of Back-Cover Text may be added by (or through
-    arrangements made by) any one entity. If the Document already includes a
-    cover text for the same cover, previously added by you or by arrangement
-    made by the same entity you are acting on behalf of, you may not add
-    another; but you may replace the old one, on explicit permission from the
-    previous publisher that added the old one.</para>
-
-    <para>The author(s) and publisher(s) of the Document do not by this
-    License give permission to use their names for publicity for or to assert
-    or imply endorsement of any Modified Version.</para>
-  </section>
-
-  <section label="5" id="gfdl-5">
-    <title>Combining Documents</title>
-
-    <para>You may combine the Document with other documents released under
-    this License, under the terms defined in section 4 above for modified
-    versions, provided that you include in the combination all of the
-    Invariant Sections of all of the original documents, unmodified, and list
-    them all as Invariant Sections of your combined work in its license
-    notice.</para>
-
-    <para>The combined work need only contain one copy of this License, and
-    multiple identical Invariant Sections may be replaced with a single copy.
-    If there are multiple Invariant Sections with the same name but different
-    contents, make the title of each such section unique by adding at the end
-    of it, in parentheses, the name of the original author or publisher of
-    that section if known, or else a unique number. Make the same adjustment
-    to the section titles in the list of Invariant Sections in the license
-    notice of the combined work.</para>
-
-    <para>In the combination, you must combine any sections entitled
-    "History" in the various original documents, forming one section entitled
-    "History"; likewise combine any sections entitled "Acknowledgements", and
-    any sections entitled "Dedications". You must delete all sections
-    entitled "Endorsements."</para>
-  </section>
-
-  <section label="6" id="gfdl-6">
-    <title>Collections of Documents</title>
-
-    <para>You may make a collection consisting of the Document and other
-    documents released under this License, and replace the individual copies
-    of this License in the various documents with a single copy that is
-    included in the collection, provided that you follow the rules of this
-    License for verbatim copying of each of the documents in all other
-    respects.</para>
-
-    <para>You may extract a single document from such a collection, and
-    distribute it individually under this License, provided you insert a copy
-    of this License into the extracted document, and follow this License in
-    all other respects regarding verbatim copying of that document.</para>
-  </section>
-
-  <section label="7" id="gfdl-7">
-    <title>Aggregation with Independent Works</title>
-
-    <para>A compilation of the Document or its derivatives with other
-    separate and independent documents or works, in or on a volume of a
-    storage or distribution medium, does not as a whole count as a Modified
-    Version of the Document, provided no compilation copyright is claimed for
-    the compilation. Such a compilation is called an "aggregate", and this
-    License does not apply to the other self-contained works thus compiled
-    with the Document, on account of their being thus compiled, if they are
-    not themselves derivative works of the Document.</para>
-
-    <para>If the Cover Text requirement of section 3 is applicable to these
-    copies of the Document, then if the Document is less than one quarter of
-    the entire aggregate, the Document's Cover Texts may be placed on covers
-    that surround only the Document within the aggregate. Otherwise they must
-    appear on covers around the whole aggregate.</para>
-  </section>
-
-  <section label="8" id="gfdl-8">
-    <title>Translation</title>
-
-    <para>Translation is considered a kind of modification, so you may
-    distribute translations of the Document under the terms of section 4.
-    Replacing Invariant Sections with translations requires special
-    permission from their copyright holders, but you may include translations
-    of some or all Invariant Sections in addition to the original versions of
-    these Invariant Sections. You may include a translation of this License
-    provided that you also include the original English version of this
-    License. In case of a disagreement between the translation and the
-    original English version of this License, the original English version
-    will prevail.</para>
-  </section>
-
-  <section label="9" id="gfdl-9">
-    <title>Termination</title>
-
-    <para>You may not copy, modify, sublicense, or distribute the Document
-    except as expressly provided for under this License. Any other attempt to
-    copy, modify, sublicense or distribute the Document is void, and will
-    automatically terminate your rights under this License. However, parties
-    who have received copies, or rights, from you under this License will not
-    have their licenses terminated so long as such parties remain in full
-    compliance.</para>
-  </section>
-
-  <section label="10" id="gfdl-10">
-    <title>Future Revisions of this License</title>
-
-    <para>The Free Software Foundation may publish new, revised versions of
-    the GNU Free Documentation License from time to time. Such new versions
-    will be similar in spirit to the present version, but may differ in
-    detail to address new problems or concerns. See 
-    <ulink url="http://www.gnu.org/copyleft/"/>.</para>
-
-    <para>Each version of the License is given a distinguishing version
-    number. If the Document specifies that a particular numbered version of
-    this License "or any later version" applies to it, you have the option of
-    following the terms and conditions either of that specified version or of
-    any later version that has been published (not as a draft) by the Free
-    Software Foundation. If the Document does not specify a version number of
-    this License, you may choose any version ever published (not as a draft)
-    by the Free Software Foundation.</para>
-  </section>
-
-  <section label="" id="gfdl-howto">
-    <title>How to use this License for your documents</title>
-
-    <para>To use this License in a document you have written, include a copy
-    of the License in the document and put the following copyright and
-    license notices just after the title page:</para>
-
-    <blockquote>
-      <para>Copyright (c) YEAR YOUR NAME. Permission is granted to copy,
-      distribute and/or modify this document under the terms of the GNU Free
-      Documentation License, Version 1.1 or any later version published by
-      the Free Software Foundation; with the Invariant Sections being LIST
-      THEIR TITLES, with the Front-Cover Texts being LIST, and with the
-      Back-Cover Texts being LIST. A copy of the license is included in the
-      section entitled "GNU Free Documentation License".</para>
-    </blockquote>
-
-    <para>If you have no Invariant Sections, write "with no Invariant
-    Sections" instead of saying which ones are invariant. If you have no
-    Front-Cover Texts, write "no Front-Cover Texts" instead of "Front-Cover
-    Texts being LIST"; likewise for Back-Cover Texts.</para>
-
-    <para>If your document contains nontrivial examples of program code, we
-    recommend releasing these examples in parallel under your choice of free
-    software license, such as the GNU General Public License, to permit their
-    use in free software.</para>
-  </section>
-</appendix>
-
-<!-- Keep this comment at the end of the file
-Local variables:
-mode: sgml
-sgml-always-quote-attributes:t
-sgml-auto-insert-required-elements:t
-sgml-balanced-tag-edit:t
-sgml-exposed-tags:nil
-sgml-general-insert-case:lower
-sgml-indent-data:t
-sgml-indent-step:2
-sgml-local-catalogs:nil
-sgml-local-ecat-files:nil
-sgml-minimize-attributes:nil
-sgml-namecase-general:t
-sgml-omittag:t
-sgml-parent-document:("Bugzilla-Guide.xml" "book" "chapter")
-sgml-shorttag:t
-sgml-tag-region-if-active:t
-End:
--->
-

mozilla/webtools/bugzilla/docs/en/xml/glossary.xml

@@ -1,555 +0,0 @@
-<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
-                      "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
-    <!ENTITY % myents SYSTEM "bugzilla.ent">
-    %myents;
-]>
-<glossary id="glossary">
-  <glossdiv>
-    <title>0-9, high ascii</title>
-
-    <glossentry id="gloss-htaccess">
-      <glossterm>.htaccess</glossterm>
-
-      <glossdef>
-        <para>Apache web server, and other NCSA-compliant web servers,
-        observe the convention of using files in directories called 
-        <filename>.htaccess</filename>
-
-        to restrict access to certain files. In Bugzilla, they are used
-        to keep secret files which would otherwise
-        compromise your installation - e.g. the 
-        <filename>localconfig</filename>
-        file contains the password to your database.
-        curious.</para>
-      </glossdef>
-    </glossentry>
-  </glossdiv>
-
-  <glossdiv id="gloss-a">
-    <title>A</title>
-
-    <glossentry id="gloss-apache">
-      <glossterm>Apache</glossterm>
-
-      <glossdef>
-        <para>In this context, Apache is the web server most commonly used
-        for serving up Bugzilla 
-        pages. Contrary to popular belief, the apache web server has nothing
-        to do with the ancient and noble Native American tribe, but instead
-        derived its name from the fact that it was 
-        <quote>a patchy</quote>
-        version of the original 
-        <acronym>NCSA</acronym>
-        world-wide-web server.</para>
-
-        <variablelist>
-          <title>Useful Directives when configuring Bugzilla</title>
-
-          <varlistentry>
-            <term><computeroutput><ulink url="http://httpd.apache.org/docs-2.0/mod/core.html#addhandler">AddHandler</ulink></computeroutput></term>
-            <listitem>
-              <para>Tell Apache that it's OK to run CGI scripts.</para>
-            </listitem>
-          </varlistentry>
-          <varlistentry>
-            <term><computeroutput><ulink url="http://httpd.apache.org/docs-2.0/mod/core.html#allowoverride">AllowOverride</ulink></computeroutput></term>
-            <term><computeroutput><ulink url="http://httpd.apache.org/docs-2.0/mod/core.html#options">Options</ulink></computeroutput></term>
-            <listitem>
-              <para>These directives are used to tell Apache many things about
-              the directory they apply to. For Bugzilla's purposes, we need
-              them to allow script execution and <filename>.htaccess</filename>
-              overrides.
-              </para>
-            </listitem>
-          </varlistentry>
-          <varlistentry>
-            <term><computeroutput><ulink url="http://httpd.apache.org/docs-2.0/mod/mod_dir.html#directoryindex">DirectoryIndex</ulink></computeroutput></term>
-            <listitem>
-              <para>Used to tell Apache what files are indexes. If you can
-              not add <filename>index.cgi</filename> to the list of valid files,
-              you'll need to set <computeroutput>$index_html</computeroutput> to
-              1 in <filename>localconfig</filename> so
-              <command>./checksetup.pl</command> will create an
-              <filename>index.html</filename> that redirects to
-              <filename>index.cgi</filename>.
-              </para>
-            </listitem>
-          </varlistentry>
-          <varlistentry>
-            <term><computeroutput><ulink url="http://httpd.apache.org/docs-2.0/mod/core.html#scriptinterpretersource">ScriptInterpreterSource</ulink></computeroutput></term>
-            <listitem>
-              <para>Used when running Apache on windows so the shebang line
-              doesn't have to be changed in every Bugzilla script.
-              </para>
-            </listitem>
-          </varlistentry>
-        </variablelist>
-
-        <para>For more information about how to configure Apache for Bugzilla,
-        see <xref linkend="http-apache"/>.
-        </para>
-      </glossdef>
-    </glossentry>
-  </glossdiv>
-
-  <glossdiv id="gloss-b">
-    <title>B</title>
-
-    <glossentry>
-      <glossterm>Bug</glossterm>
-
-      <glossdef>
-        <para>A 
-        <quote>bug</quote>
-
-        in Bugzilla refers to an issue entered into the database which has an
-        associated number, assignments, comments, etc. Some also refer to a 
-        <quote>tickets</quote>
-        or 
-        <quote>issues</quote>; 
-        in the context of Bugzilla, they are synonymous.</para>
-      </glossdef>
-    </glossentry>
-
-    <glossentry>
-      <glossterm>Bug Number</glossterm>
-
-      <glossdef>
-        <para>Each Bugzilla bug is assigned a number that uniquely identifies
-        that bug. The bug associated with a bug number can be pulled up via a
-        query, or easily from the very front page by typing the number in the
-        "Find" box.</para>
-      </glossdef>
-    </glossentry>
-
-    <glossentry id="gloss-bugzilla">
-      <glossterm>Bugzilla</glossterm>
-
-      <glossdef>
-        <para>Bugzilla is the world-leading free software bug tracking system.
-        </para>
-      </glossdef>
-    </glossentry>
-  </glossdiv>
-
-  <glossdiv id="gloss-c">
-    <title>C</title>
-
-    <glossentry id="gloss-cgi">
-      <glossterm>Common Gateway Interface</glossterm>
-      <acronym>CGI</acronym>
-      <glossdef>
-        <para><acronym>CGI</acronym> is an acronym for Common Gateway Interface. This is
-        a standard for interfacing an external application with a web server. Bugzilla
-        is an example of a <acronym>CGI</acronym> application.
-        </para>
-      </glossdef>
-    </glossentry>
-
-    <glossentry id="gloss-component">
-      <glossterm>Component</glossterm>
-
-      <glossdef>
-        <para>A Component is a subsection of a Product. It should be a narrow
-        category, tailored to your organization. All Products must contain at
-        least one Component (and, as a matter of fact, creating a Product
-        with no Components will create an error in Bugzilla).</para>
-      </glossdef>
-    </glossentry>
-
-    <glossentry id="gloss-cpan">
-      <glossterm>Comprehensive Perl Archive Network</glossterm>
-      <acronym>CPAN</acronym>
-
-      <!-- TODO: Rewrite def for CPAN -->
-      <glossdef>
-        <para>
-        <acronym>CPAN</acronym>
-
-        stands for the 
-        <quote>Comprehensive Perl Archive Network</quote>. 
-        CPAN maintains a large number of extremely useful 
-        <glossterm>Perl</glossterm>
-        modules - encapsulated chunks of code for performing a
-        particular task.</para>
-      </glossdef>
-    </glossentry>
-
-    <glossentry id="gloss-contrib">
-      <glossterm><filename class="directory">contrib</filename></glossterm>
-
-      <glossdef>
-        <para>The <filename class="directory">contrib</filename> directory is
-        a location to put scripts that have been contributed to Bugzilla but
-        are not a part of the official distribution. These scripts are written
-        by third parties and may be in languages other than perl. For those
-        that are in perl, there may be additional modules or other requirements
-        than those of the official distribution.
-        <note>
-          <para>Scripts in the <filename class="directory">contrib</filename>
-          directory are not officially supported by the Bugzilla team and may
-          break in between versions.
-          </para>
-        </note>
-        </para>
-      </glossdef>
-    </glossentry>
-  </glossdiv>
-
-  <glossdiv id="gloss-d">
-    <title>D</title>
-
-    <glossentry id="gloss-daemon">
-      <glossterm>daemon</glossterm>
-
-      <glossdef>
-        <para>A daemon is a computer program which runs in the background. In
-        general, most daemons are started at boot time via System V init
-        scripts, or through RC scripts on BSD-based systems. 
-        <glossterm>mysqld</glossterm>, 
-        the MySQL server, and 
-        <glossterm>apache</glossterm>, 
-        a web server, are generally run as daemons.</para>
-      </glossdef>
-    </glossentry>
-    
-    <glossentry id="gloss-dos">
-      <glossterm>DOS Attack</glossterm>
-      
-      <glossdef>
-        <para>A DOS, or Denial of Service attack, is when a user attempts to
-        deny access to a web server by repeatedly accessing a page or sending
-        malformed requests to a webserver. A D-DOS, or
-        Distributed Denial of Service attack, is when these requests come
-        from multiple sources at the same time. Unfortunately, these are much
-        more difficult to defend against.
-        </para>
-      </glossdef>
-    </glossentry>
-    
-  </glossdiv>
-
-  <glossdiv id="gloss-g">
-    <title>G</title>
-
-    <glossentry id="gloss-groups">
-      <glossterm>Groups</glossterm>
-
-      <glossdef>
-        <para>The word 
-        <quote>Groups</quote>
-
-        has a very special meaning to Bugzilla. Bugzilla's main security
-        mechanism comes by placing users in groups, and assigning those
-        groups certain privileges to view bugs in particular
-        <glossterm>Products</glossterm>
-        in the 
-        <glossterm>Bugzilla</glossterm>
-        database.</para>
-      </glossdef>
-    </glossentry>
-  </glossdiv>
-
-  <glossdiv id="gloss-j">
-    <title>J</title>
-
-    <glossentry id="gloss-javascript">
-      <glossterm>JavaScript</glossterm>
-      <glossdef>
-        <para>JavaScript is cool, we should talk about it.
-        </para>
-      </glossdef>
-    </glossentry>
-  </glossdiv>
-
-  <glossdiv id="gloss-m">
-    <title>M</title>
-
-    <glossentry id="gloss-mta">
-      <glossterm>Message Transport Agent</glossterm>
-      <acronym>MTA</acronym>
-
-      <glossdef>
-        <para>A Message Transport Agent is used to control the flow of email on a system.
-        The <ulink url="http://search.cpan.org/dist/Email-Send/lib/Email/Send.pm">Email::Send</ulink>
-        Perl module, which Bugzilla uses to send email, can be configured to
-        use many different underlying implementations for actually sending the
-        mail using the <option>mail_delivery_method</option> parameter.
-        Implementations other than <literal>sendmail</literal> require that the
-        <option>sendmailnow</option> param be set to <literal>on</literal>.
-        </para>
-      </glossdef>
-    </glossentry>
-
-    <glossentry id="gloss-mysql">
-      <glossterm>MySQL</glossterm>
-
-      <glossdef>
-        <para>MySQL is currently the required
-        <glossterm linkend="gloss-rdbms">RDBMS</glossterm> for Bugzilla. MySQL
-        can be downloaded from <ulink url="http://www.mysql.com"/>. While you
-        should familiarize yourself with all of the documentation, some high
-        points are:
-        </para>
-        <variablelist>
-          <varlistentry>
-            <term><ulink url="http://www.mysql.com/doc/en/Backup.html">Backup</ulink></term>
-            <listitem>
-              <para>Methods for backing up your Bugzilla database.
-              </para>
-            </listitem>
-          </varlistentry>
-          <varlistentry>
-            <term><ulink url="http://www.mysql.com/doc/en/Option_files.html">Option Files</ulink></term>
-            <listitem>
-              <para>Information about how to configure MySQL using
-              <filename>my.cnf</filename>.
-              </para>
-            </listitem>
-          </varlistentry>
-          <varlistentry>
-            <term><ulink url="http://www.mysql.com/doc/en/Privilege_system.html">Privilege System</ulink></term>
-            <listitem>
-              <para>Much more detailed information about the suggestions in
-              <xref linkend="security-mysql"/>.
-              </para>
-            </listitem>
-          </varlistentry>
-        </variablelist>
-      </glossdef>
-    </glossentry>
-  </glossdiv>
-
-  <glossdiv id="gloss-p">
-    <title>P</title>
-
-    <glossentry id="gloss-ppm">
-      <glossterm>Perl Package Manager</glossterm>
-      <acronym>PPM</acronym>
-
-      <glossdef>
-        <para><ulink url="http://aspn.activestate.com/ASPN/Downloads/ActivePerl/PPM/"/>
-        </para>
-      </glossdef>
-    </glossentry>
-
-    <glossentry>
-      <glossterm id="gloss-product">Product</glossterm>
-
-      <glossdef>
-        <para>A Product is a broad category of types of bugs, normally
-        representing a single piece of software or entity. In general,
-        there are several Components to a Product. A Product may define a
-        group (used for security) for all bugs entered into
-        its Components.</para>
-      </glossdef>
-    </glossentry>
-
-    <glossentry>
-      <glossterm>Perl</glossterm>
-
-      <glossdef>
-        <para>First written by Larry Wall, Perl is a remarkable program
-        language. It has the benefits of the flexibility of an interpreted
-        scripting language (such as shell script), combined with the speed
-        and power of a compiled language, such as C. 
-        <glossterm>Bugzilla</glossterm>
-
-        is maintained in Perl.</para>
-      </glossdef>
-    </glossentry>
-  </glossdiv>
-
-  <glossdiv id="gloss-q">
-    <title>Q</title>
-
-    <glossentry>
-      <glossterm>QA</glossterm>
-
-      <glossdef>
-        <para>
-        <quote>QA</quote>, 
-        <quote>Q/A</quote>, and 
-        <quote>Q.A.</quote>
-        are short for 
-        <quote>Quality Assurance</quote>. 
-        In most large software development organizations, there is a team
-        devoted to ensuring the product meets minimum standards before
-        shipping. This team will also generally want to track the progress of
-        bugs over their life cycle, thus the need for the 
-        <quote>QA Contact</quote>
-
-        field in a bug.</para>
-      </glossdef>
-    </glossentry>
-  </glossdiv>
-
-  <glossdiv id="gloss-r">
-    <title>R</title>
-
-    <glossentry id="gloss-rdbms">
-      <glossterm>Relational DataBase Management System</glossterm>
-      <acronym>RDBMS</acronym>
-
-      <glossdef>
-        <para>A relational database management system is a database system
-        that stores information in tables that are related to each other.
-        </para>
-      </glossdef>
-    </glossentry>
-
-    <glossentry id="gloss-regexp">
-      <glossterm>Regular Expression</glossterm>
-      <acronym>regexp</acronym>
-
-      <glossdef>
-          <para>A regular expression is an expression used for pattern matching.
-              <ulink url="http://perldoc.com/perl5.6/pod/perlre.html#Regular-Expressions">Documentation</ulink>
-        </para>
-      </glossdef>
-    </glossentry>
-  </glossdiv>
-
-  <glossdiv id="gloss-s">
-    <title>S</title>
-
-    <glossentry id="gloss-service">
-      <glossterm>Service</glossterm>
-      
-      <glossdef>
-        <para>In Windows NT environment, a boot-time background application
-        is referred to as a service. These are generally managed through the
-        control panel while logged in as an account with
-        <quote>Administrator</quote> level capabilities. For more
-        information, consult your Windows manual or the MSKB.
-        </para>
-      </glossdef>
-    </glossentry>
-
-    <glossentry>
-      <glossterm>
-        <acronym>SGML</acronym>
-      </glossterm>
-
-      <glossdef>
-        <para>
-        <acronym>SGML</acronym>
-
-        stands for 
-        <quote>Standard Generalized Markup Language</quote>. 
-        Created in the 1980's to provide an extensible means to maintain
-        documentation based upon content instead of presentation, 
-        <acronym>SGML</acronym>
-
-        has withstood the test of time as a robust, powerful language. 
-        <glossterm>
-          <acronym>XML</acronym>
-        </glossterm>
-
-        is the 
-        <quote>baby brother</quote>
-
-        of SGML; any valid 
-        <acronym>XML</acronym>
-
-        document it, by definition, a valid 
-        <acronym>SGML</acronym>
-
-        document. The document you are reading is written and maintained in 
-        <acronym>SGML</acronym>, 
-        and is also valid 
-        <acronym>XML</acronym>
-
-        if you modify the Document Type Definition.</para>
-      </glossdef>
-    </glossentry>
-  </glossdiv>
-
-  <glossdiv id="gloss-t">
-    <title>T</title>
-
-    <glossentry id="gloss-target-milestone" xreflabel="Target Milestone">
-      <glossterm>Target Milestone</glossterm>
-
-      <glossdef>
-        <para>Target Milestones are Product goals. They are configurable on a
-        per-Product basis. Most software development houses have a concept of
-        
-        <quote>milestones</quote>
-
-        where the people funding a project expect certain functionality on
-        certain dates. Bugzilla facilitates meeting these milestones by
-        giving you the ability to declare by which milestone a bug will be
-        fixed, or an enhancement will be implemented.</para>
-      </glossdef>
-    </glossentry>
-
-    <glossentry id="gloss-tcl">
-      <glossterm>Tool Command Language</glossterm>
-      <acronym>TCL</acronym>
-      <glossdef>
-        <para>TCL is an open source scripting language available for Windows,
-        Macintosh, and Unix based systems. Bugzilla 1.0 was written in TCL but
-        never released. The first release of Bugzilla was 2.0, which was when
-        it was ported to perl.
-        </para>
-      </glossdef>
-    </glossentry>
-  </glossdiv>
-
-  <glossdiv id="gloss-z">
-    <title>Z</title>
-
-    <glossentry id="gloss-zarro">
-      <glossterm>Zarro Boogs Found</glossterm>
-
-      <glossdef>
-        <para>This is just a goofy way of saying that there were no bugs
-        found matching your query. When asked to explain this message,
-        Terry had the following to say:
-        </para>
-
-        <blockquote>
-          <attribution>Terry Weissman</attribution>
-          <para>I've been asked to explain this ... way back when, when
-          Netscape released version 4.0 of its browser, we had a release
-          party.  Naturally, there had been a big push to try and fix every
-          known bug before the release. Naturally, that hadn't actually
-          happened.  (This is not unique to Netscape or to 4.0; the same thing
-          has happened with every software project I've ever seen.)  Anyway,
-          at the release party, T-shirts were handed out that said something
-          like "Netscape 4.0: Zarro Boogs". Just like the software, the
-          T-shirt had no known bugs.  Uh-huh.
-          </para>
-
-          <para>So, when you query for a list of bugs, and it gets no results,
-          you can think of this as a friendly reminder.  Of *course* there are
-          bugs matching your query, they just aren't in the bugsystem yet...
-          </para>
-        </blockquote>
-
-      </glossdef>
-    </glossentry>
-  </glossdiv>
-</glossary>
-
-<!-- Keep this comment at the end of the file
-Local variables:
-mode: sgml
-sgml-always-quote-attributes:t
-sgml-auto-insert-required-elements:t
-sgml-balanced-tag-edit:t
-sgml-exposed-tags:nil
-sgml-general-insert-case:lower
-sgml-indent-data:t
-sgml-indent-step:2
-sgml-local-catalogs:nil
-sgml-local-ecat-files:nil
-sgml-minimize-attributes:nil
-sgml-namecase-general:t
-sgml-omittag:t
-sgml-parent-document:("Bugzilla-Guide.xml" "book" "chapter")
-sgml-shorttag:t
-sgml-tag-region-if-active:t
-End:
--->

mozilla/webtools/bugzilla/docs/en/xml/index.xml

@@ -1,21 +0,0 @@
-<!-- Keep this comment at the end of the file
-Local variables:
-mode: sgml
-sgml-always-quote-attributes:t
-sgml-auto-insert-required-elements:t
-sgml-balanced-tag-edit:t
-sgml-exposed-tags:nil
-sgml-general-insert-case:lower
-sgml-indent-data:t
-sgml-indent-step:2
-sgml-local-catalogs:nil
-sgml-local-ecat-files:nil
-sgml-minimize-attributes:nil
-sgml-namecase-general:t
-sgml-omittag:t
-sgml-parent-document:("Bugzilla-Guide.xml" "book" "chapter")
-sgml-shorttag:t
-sgml-tag-region-if-active:t
-End:
--->
-

mozilla/webtools/bugzilla/docs/en/xml/integration.xml

@@ -1,124 +0,0 @@
-<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
-                      "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
-    <!ENTITY % myents SYSTEM "bugzilla.ent">
-    %myents;
-]>
-<!-- Keep these tools listings in alphabetical order please. -MPB -->
-<section id="integration">
-  <title>Integrating Bugzilla with Third-Party Tools</title>
-
-  <section id="bonsai"
-  xreflabel="Bonsai, the Mozilla automated CVS management system">
-    <title>Bonsai</title>
-
-    <para>Bonsai is a web-based tool for managing 
-    <xref linkend="cvs" />
-
-    . Using Bonsai, administrators can control open/closed status of trees,
-    query a fast relational database back-end for change, branch, and comment
-    information, and view changes made since the last time the tree was
-    closed. Bonsai
-    also integrates with  
-    <xref linkend="tinderbox" />.
-    </para>
-  </section>
-
-  <section id="cvs" xreflabel="CVS, the Concurrent Versioning System">
-    <title>CVS</title>
-
-    <para>CVS integration is best accomplished, at this point, using the
-    Bugzilla Email Gateway.</para>
-
-    <para>Follow the instructions in this Guide for enabling Bugzilla e-mail
-    integration. Ensure that your check-in script sends an email to your
-    Bugzilla e-mail gateway with the subject of 
-    <quote>[Bug XXXX]</quote>, 
-    and you can have CVS check-in comments append to your Bugzilla bug. If
-    you  want to have the bug be closed automatically, you'll have to modify
-    the <filename>contrib/bugzilla_email_append.pl</filename> script.
-    </para>
-
-    <para>There is also a CVSZilla project, based upon somewhat dated 
-    Bugzilla code, to integrate CVS and Bugzilla through CVS' ability to 
-    email. Check it out at: <ulink url="http://www.cvszilla.org/"/>.
-    </para>
-
-    <para>Another system capable of CVS integration with Bugzilla is
-    Scmbug. This system provides generic integration of Source code
-    Configuration Management with Bugtracking. Check it out at: <ulink
-    url="http://freshmeat.net/projects/scmbug/"/>.
-    </para>
-
-  </section>
-
-  <section id="scm"
-  xreflabel="Perforce SCM (Fast Software Configuration Management System, a powerful commercial alternative to CVS">
-
-    <title>Perforce SCM</title>
-
-    <para>You can find the project page for Bugzilla and Teamtrack Perforce
-    integration (p4dti) at: 
-    <ulink url="http://www.ravenbrook.com/project/p4dti/"/>
-
-    . 
-    <quote>p4dti</quote>
-
-    is now an officially supported product from Perforce, and you can find
-    the "Perforce Public Depot" p4dti page at 
-    <ulink url="http://public.perforce.com/public/perforce/p4dti/index.html"/>
-
-    .</para>
-
-    <para>Integration of Perforce with Bugzilla, once patches are applied, is
-    seamless. Perforce replication information will appear below the comments
-    of each bug. Be certain you have a matching set of patches for the
-    Bugzilla version you are installing. p4dti is designed to support
-    multiple defect trackers, and maintains its own documentation for it.
-    Please consult the pages linked above for further information.</para>
-  </section>
-
-  <section id="svn"
-  xreflabel="Subversion, a compelling replacement for CVS">
-     <title>Subversion</title>
-     <para>Subversion is a free/open-source version control system,
-     designed to overcome various limitations of CVS. Integration of
-     Subversion with Bugzilla is possible using Scmbug, a system
-     providing generic integration of Source Code Configuration
-     Management with Bugtracking. Scmbug is available at <ulink
-     url="http://freshmeat.net/projects/scmbug/"/>.</para>
-  </section>
-
-  <section id="tinderbox"
-  xreflabel="Tinderbox, the Mozilla automated build management system">
-    <title>Tinderbox/Tinderbox2</title>
-
-    <para>Tinderbox is a continuous-build system which can integrate with
-    Bugzilla - see
-    <ulink url="http://www.mozilla.org/projects/tinderbox"/> for details
-    of Tinderbox, and 
-    <ulink url="http://tinderbox.mozilla.org/showbuilds.cgi"/> to see it
-    in action.</para>
-  </section>
-</section>
-
-<!-- Keep this comment at the end of the file
-Local variables:
-mode: sgml
-sgml-always-quote-attributes:t
-sgml-auto-insert-required-elements:t
-sgml-balanced-tag-edit:t
-sgml-exposed-tags:nil
-sgml-general-insert-case:lower
-sgml-indent-data:t
-sgml-indent-step:2
-sgml-local-catalogs:nil
-sgml-local-ecat-files:nil
-sgml-minimize-attributes:nil
-sgml-namecase-general:t
-sgml-omittag:t
-sgml-parent-document:("Bugzilla-Guide.xml" "book" "chapter")
-sgml-shorttag:t
-sgml-tag-region-if-active:t
-End:
--->
-

mozilla/webtools/bugzilla/docs/en/xml/introduction.xml

@@ -1,121 +0,0 @@
-<chapter id="introduction">
-  <title>Introduction</title>
-
-  <section id="what-is-bugzilla">
-    <title>What is Bugzilla?</title>
-
-    <para>
-    Bugzilla is a bug- or issue-tracking system. Bug-tracking
-    systems allow individual or groups of developers effectively to keep track
-    of outstanding problems with their products. 
-    </para>
-    
-    <para><emphasis>Do we need more here?</emphasis></para>
-    
-  </section>
-
-  <section id="why-tracking">
-    <title>Why use a bug-tracking system?</title>
-    
-    <para>Those who do not use a bug-tracking system tend to rely on
-    shared lists, email, spreadsheets and/or Post-It notes to monitor the 
-    status of defects. This procedure
-    is usually error-prone and tends to cause those bugs judged least 
-    significant by developers to be dropped or ignored.</para>
-
-    <para>Integrated defect-tracking systems make sure that nothing gets
-    swept under the carpet; they provide a method of creating, storing,
-    arranging and processing defect reports and enhancement requests.</para>
-    
-  </section>
-    
-  <section id="why-bugzilla">
-    <title>Why use Bugzilla?</title>
-
-    <para>Bugzilla is the leading open-source/free software bug tracking 
-    system. It boasts many advanced features, including: 
-    <itemizedlist>
-      <listitem>
-        <para>Powerful searching</para>
-      </listitem>
-
-      <listitem>
-        <para>User-configurable email notifications of bug changes</para>
-      </listitem>
-
-      <listitem>
-        <para>Full change history</para>
-      </listitem>
-
-      <listitem>
-        <para>Inter-bug dependency tracking and graphing</para>
-      </listitem>
-
-      <listitem>
-        <para>Excellent attachment management</para>
-      </listitem>
-
-      <listitem>
-        <para>Integrated, product-based, granular security schema</para>
-      </listitem>
-
-      <listitem>
-        <para>Fully security-audited, and runs under Perl's taint mode</para>
-      </listitem>
-
-      <listitem>
-        <para>A robust, stable RDBMS back-end</para>
-      </listitem>
-
-      <listitem>
-        <para>Completely customizable and/or localizable web user
-        interface</para>
-      </listitem>
-
-      <listitem>
-        <para>Additional XML, email and console interfaces</para>
-      </listitem>
-
-      <listitem>
-        <para>Extensive configurability</para>
-      </listitem>
-
-      <listitem>
-        <para>Smooth upgrade pathway between versions</para>
-      </listitem>
-    </itemizedlist>
-    </para>
-    
-    <para>Bugzilla is very adaptable to various situations. Known uses
-    currently include IT support queues, Systems Administration deployment
-    management, chip design and development problem tracking (both
-    pre-and-post fabrication), and software and hardware bug tracking for
-    luminaries such as Redhat, NASA, Linux-Mandrake, and VA Systems.
-    Combined with systems such as 
-    <ulink url="http://www.cvshome.org">CVS</ulink>, 
-    <ulink url="http://www.mozilla.org/bonsai.html">Bonsai</ulink>, or 
-    <ulink url="http://www.perforce.com">Perforce SCM</ulink>, Bugzilla
-    provides a powerful, easy-to-use configuration management solution.</para>
-  </section>
-</chapter>
-
-<!-- Keep this comment at the end of the file
-Local variables:
-mode: sgml
-sgml-always-quote-attributes:t
-sgml-auto-insert-required-elements:t
-sgml-balanced-tag-edit:t
-sgml-exposed-tags:nil
-sgml-general-insert-case:lower
-sgml-indent-data:t
-sgml-indent-step:2
-sgml-local-catalogs:nil
-sgml-local-ecat-files:nil
-sgml-minimize-attributes:nil
-sgml-namecase-general:t
-sgml-omittag:t
-sgml-parent-document:("Bugzilla-Guide.xml" "book" "chapter")
-sgml-shorttag:t
-sgml-tag-region-if-active:t
-End:
--->

mozilla/webtools/bugzilla/docs/en/xml/modules.xml

@@ -1,197 +0,0 @@
-<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
-                      "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
-    <!ENTITY % myents SYSTEM "bugzilla.ent">
-    %myents;
-]>
-<appendix id="install-perlmodules-manual">
-  <title>Manual Installation of Perl Modules</title>
-  
-  <section id="modules-manual-instructions">
-    <title>Instructions</title>
-    <para>
-      If you need to install Perl modules manually, here's how it's done.
-      Download the module using the link given in the next section, and then
-      apply this magic incantation, as root:
-    </para>
-
-    <para>  
-      <screen><prompt>bash#</prompt> tar -xzvf &lt;module&gt;.tar.gz
-<prompt>bash#</prompt> cd &lt;module&gt;
-<prompt>bash#</prompt> perl Makefile.PL
-<prompt>bash#</prompt> make
-<prompt>bash#</prompt> make test
-<prompt>bash#</prompt> make install</screen>
-    </para>
-    <note>
-      <para>
-        In order to compile source code under Windows you will need to obtain
-        a 'make' utility.  The <command>nmake</command> utility provided with
-        Microsoft Visual C++ may be used.  As an alternative, there is a
-        utility called <command>dmake</command> available from CPAN which is
-        written entirely in Perl.
-      </para>
-      <para>
-        As described in <xref linkend="modules-manual-download" />, however, most
-        packages already exist and are available from ActiveState or theory58S.
-        We highly recommend that you install them using the ppm GUI available with
-        ActiveState and to add the theory58S repository to your list of repositories.
-      </para>
-    </note>
-  </section>
-    
-  <section id="modules-manual-download">
-    <title>Download Locations</title>
-    
-    <note>
-      <para>
-        Running Bugzilla on Windows requires the use of ActiveState
-        Perl 5.8.1 or higher. Many modules already exist in the core
-        distribution of ActiveState Perl. Additional modules can be downloaded
-        from <ulink url="http://theoryx5.uwinnipeg.ca/ppms/" /> if you use
-        Perl 5.8.x or from <ulink url="http://cpan.uwinnipeg.ca/PPMPackages/10xx/" />
-        if you use Perl 5.10.x.
-      </para>
-    </note>
-
-    <para>
-      CGI:
-      <literallayout>
-        CPAN Download Page: <ulink url="http://search.cpan.org/dist/CGI.pm/"/>
-        Documentation: <ulink url="http://perldoc.perl.org/CGI.html"/>
-      </literallayout>
-    </para>
-
-    <para>
-      Data-Dumper:
-      <literallayout>
-        CPAN Download Page: <ulink url="http://search.cpan.org/dist/Data-Dumper/"/>
-        Documentation: <ulink url="http://search.cpan.org/dist/Data-Dumper/Dumper.pm"/>
-      </literallayout>
-    </para>
-    
-    <para>
-      Date::Format (part of TimeDate):
-      <literallayout>
-        CPAN Download Page: <ulink url="http://search.cpan.org/dist/TimeDate/"/>
-        Documentation: <ulink url="http://search.cpan.org/dist/TimeDate/lib/Date/Format.pm"/>
-      </literallayout>
-    </para>
-
-    <para>
-      DBI:
-      <literallayout>
-        CPAN Download Page: <ulink url="http://search.cpan.org/dist/DBI/"/>
-        Documentation: <ulink url="http://dbi.perl.org/docs/"/>
-      </literallayout>
-    </para>
-
-    <para>
-      DBD::mysql:
-      <literallayout>
-        CPAN Download Page: <ulink url="http://search.cpan.org/dist/DBD-mysql/"/>
-        Documentation: <ulink url="http://search.cpan.org/dist/DBD-mysql/lib/DBD/mysql.pm"/>
-      </literallayout>
-    </para>
-
-    <para>
-      DBD::Pg:
-      <literallayout>
-        CPAN Download Page: <ulink url="http://search.cpan.org/dist/DBD-Pg/"/>
-        Documentation: <ulink url="http://search.cpan.org/dist/DBD-Pg/Pg.pm"/>
-      </literallayout>
-    </para>
-
-    <para>
-      File::Spec:
-      <literallayout>
-        CPAN Download Page: <ulink url="http://search.cpan.org/dist/File-Spec/"/>
-        Documentation: <ulink url="http://perldoc.perl.org/File/Spec.html"/>
-      </literallayout>
-    </para>
-
-    <para>
-      Template-Toolkit:
-      <literallayout>
-        CPAN Download Page: <ulink url="http://search.cpan.org/dist/Template-Toolkit/"/>
-        Documentation: <ulink url="http://www.template-toolkit.org/docs.html"/>
-      </literallayout>
-    </para>
-
-    <para>
-      GD:
-      <literallayout>
-        CPAN Download Page: <ulink url="http://search.cpan.org/dist/GD/"/>
-        Documentation: <ulink url="http://search.cpan.org/dist/GD/GD.pm"/>
-      </literallayout>
-    </para>
-
-    <para>
-      Template::Plugin::GD:
-      <literallayout>
-       CPAN Download Page: <ulink url="http://search.cpan.org/dist/Template-GD/" />
-       Documentation: <ulink url="http://www.template-toolkit.org/docs/aqua/Modules/index.html" />
-      </literallayout>
-    </para>
-
-    <para>
-      MIME::Parser (part of MIME-tools):
-      <literallayout>
-        CPAN Download Page: <ulink url="http://search.cpan.org/dist/MIME-tools/"/>
-        Documentation: <ulink url="http://search.cpan.org/dist/MIME-tools/lib/MIME/Parser.pm"/>
-      </literallayout>
-    </para>
-
-  </section>
-
-  <section id="modules-manual-optional">
-    <title>Optional Modules</title>
-
-    <para>
-      Chart::Base:
-      <literallayout>
-        CPAN Download Page: <ulink url="http://search.cpan.org/dist/Chart/"/>
-        Documentation: <ulink url="http://search.cpan.org/dist/Chart/Chart.pod"/>
-      </literallayout>
-    </para>
-
-     <para>
-      GD::Graph:
-      <literallayout>
-        CPAN Download Page: <ulink url="http://search.cpan.org/dist/GDGraph/"/>
-        Documentation: <ulink url="http://search.cpan.org/dist/GDGraph/Graph.pm"/>
-      </literallayout>
-    </para>
-
-    <para>
-      GD::Text::Align (part of GD::Text::Util):
-      <literallayout>
-        CPAN Download Page: <ulink url="http://search.cpan.org/dist/GDTextUtil/"/>
-        Documentation: <ulink url="http://search.cpan.org/dist/GDTextUtil/Text/Align.pm"/>
-      </literallayout>
-    </para>
-
-   <para>
-      XML::Twig:
-      <literallayout>
-        CPAN Download Page: <ulink url="http://search.cpan.org/dist/XML-Twig/"/>
-        Documentation: <ulink url="http://standards.ieee.org/resources/spasystem/twig/twig_stable.html"/>
-      </literallayout>
-    </para>
-
-    <para>
-      PatchReader:
-      <literallayout>
-        CPAN Download Page: <ulink url="http://search.cpan.org/author/JKEISER/PatchReader/"/>
-        Documentation: <ulink url="http://www.johnkeiser.com/mozilla/Patch_Viewer.html"/>
-      </literallayout>
-    </para>
-
-   <para>
-      Image::Magick:
-      <literallayout>
-        CPAN Download Page: <ulink url="http://search.cpan.org/dist/PerlMagick/"/>
-        Documentation: <ulink url="http://www.imagemagick.org/script/resources.php"/>
-      </literallayout>
-    </para>
-   </section>
-</appendix>

mozilla/webtools/bugzilla/docs/en/xml/patches.xml

@@ -1,135 +0,0 @@
-<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
-                      "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
-    <!ENTITY % myents SYSTEM "bugzilla.ent">
-    %myents;
-]>
-<appendix id="patches" xreflabel="Useful Patches and Utilities for Bugzilla">
-  <title>Contrib</title>
-
-  <para>
-    There are a number of unofficial Bugzilla add-ons in the 
-    <filename class="directory">$BUGZILLA_ROOT/contrib/</filename>
-    directory. This section documents them.
-  </para>
-
-  <section id="cmdline">
-    <title>Command-line Search Interface</title>
-
-    <para>
-      There are a suite of Unix utilities for searching Bugzilla from the 
-      command line. They live in the 
-      <filename class="directory">contrib/cmdline</filename> directory.
-      There are three files - <filename>query.conf</filename>,
-      <filename>buglist</filename> and <filename>bugs</filename>.
-    </para>
-
-    <warning>
-      <para>
-        These files pre-date the templatization work done as part of the
-        2.16 release, and have not been updated.
-      </para>
-    </warning>
-    
-    <para>
-      <filename>query.conf</filename> contains the mapping from
-      options to field names and comparison types. Quoted option names
-      are <quote>grepped</quote> for, so it should be easy to edit this
-      file. Comments (#) have no effect; you must make sure these lines
-      do not contain any quoted <quote>option</quote>.
-    </para>
-
-    <para>
-      <filename>buglist</filename> is a shell script that submits a
-      Bugzilla query and writes the resulting HTML page to stdout.
-      It supports both short options, (such as <quote>-Afoo</quote>
-      or <quote>-Rbar</quote>) and long options (such
-      as <quote>--assignedto=foo</quote> or <quote>--reporter=bar</quote>).
-      If the first character of an option is not <quote>-</quote>, it is
-      treated as if it were prefixed with <quote>--default=</quote>.
-    </para>
-
-    <para>
-      The column list is taken from the COLUMNLIST environment variable.
-      This is equivalent to the <quote>Change Columns</quote> option
-      that is available when you list bugs in buglist.cgi. If you have
-      already used Bugzilla, grep for COLUMNLIST in your cookies file
-      to see your current COLUMNLIST setting.
-    </para>
-
-    <para>
-      <filename>bugs</filename> is a simple shell script which calls
-      <filename>buglist</filename> and extracts the
-      bug numbers from the output. Adding the prefix
-      <quote>http://bugzilla.mozilla.org/buglist.cgi?bug_id=</quote>
-      turns the bug list into a working link if any bugs are found.
-      Counting bugs is easy. Pipe the results through 
-      <command>sed -e 's/,/ /g' | wc | awk '{printf $2 "\n"}'</command>
-    </para>
-
-    <para>
-      Akkana Peck says she has good results piping 
-      <filename>buglist</filename> output through 
-      <command>w3m -T text/html -dump</command>
-    </para>
-
-  </section>
-
-  <section id="cmdline-bugmail">
-    <title>Command-line 'Send Unsent Bug-mail' tool</title>
-
-    <para>
-      Within the <filename class="directory">contrib</filename> directory
-      exists a utility with the descriptive (if compact) name
-      of <filename>sendunsentbugmail.pl</filename>. The purpose of this
-      script is, simply, to send out any bug-related mail that should
-      have been sent by now, but for one reason or another has not.
-    </para>
-
-    <para>
-      To accomplish this task, <filename>sendunsentbugmail.pl</filename> uses
-      the same mechanism as the <filename>sanitycheck.cgi</filename> script;
-      it scans through the entire database looking for bugs with changes that
-      were made more than 30 minutes ago, but where there is no record of
-      anyone related to that bug having been sent mail. Having compiled a list,
-      it then uses the standard rules to determine who gets mail, and sends it
-      out.
-    </para>
-
-    <para>
-      As the script runs, it indicates the bug for which it is currently
-      sending mail; when it has finished, it gives a numerical count of how
-      many mails were sent and how many people were excluded. (Individual
-      user names are not recorded or displayed.) If the script produces
-      no output, that means no unsent mail was detected.
-    </para>
-
-    <para>
-      <emphasis>Usage</emphasis>: move the sendunsentbugmail.pl script
-      up into the main directory, ensure it has execute permission, and run it
-      from the command line (or from a cron job) with no parameters.
-    </para>
-  </section>
-
-</appendix>
-
-<!-- Keep this comment at the end of the file
-Local variables:
-mode: sgml
-sgml-always-quote-attributes:t
-sgml-auto-insert-required-elements:t
-sgml-balanced-tag-edit:t
-sgml-exposed-tags:nil
-sgml-general-insert-case:lower
-sgml-indent-data:t
-sgml-indent-step:2
-sgml-local-catalogs:nil
-sgml-local-ecat-files:nil
-sgml-minimize-attributes:nil
-sgml-namecase-general:t
-sgml-omittag:t
-sgml-parent-document:("Bugzilla-Guide.xml" "book" "chapter")
-sgml-shorttag:t
-sgml-tag-region-if-active:t
-End:
--->
-

mozilla/webtools/bugzilla/docs/en/xml/requiredsoftware.xml

@@ -1,77 +0,0 @@
-<!-- <!DOCTYPE appendix PUBLIC "-//OASIS//DTD DocBook V4.1//EN"> -->
-<appendix id="downloadlinks">
-  <title>Software Download Links</title>
-
-  <para>All of these sites are current as of April, 2001. Hopefully they'll
-  stay current for a while.</para>
-
-  <para>Apache Web Server: 
-  <ulink url="http://www.apache.org/"/>
-
-  Optional web server for Bugzilla, but recommended because of broad user
-  base and support.</para>
-
-  <para>Bugzilla: 
-  <ulink url="http://www.bugzilla.org/"/>
-  </para>
-
-  <para>MySQL: 
-  <ulink url="http://www.mysql.com/"/>
-  </para>
-
-  <para>Perl: 
-  <ulink url="http://www.perl.org/"/>
-  </para>
-
-  <para>CPAN: 
-  <ulink url="http://www.cpan.org/"/>
-  </para>
-
-  <para>DBI Perl module: 
-  <ulink url="http://www.cpan.org/modules/by-module/DBI/"/>
-  </para>
-
-  <para>MySQL related Perl modules: 
-  <ulink url="http://www.cpan.org/modules/by-module/Mysql/"/>
-  </para>
-
-  <para>TimeDate Perl module collection: 
-  <ulink url="http://www.cpan.org/modules/by-module/Date/"/>
-  </para>
-
-  <para>GD Perl module: 
-  <ulink url="http://www.cpan.org/modules/by-module/GD/"/>
-
-  Alternately, you should be able to find the latest version of GD at 
-  <ulink url="http://www.boutell.com/gd/"/>
-  </para>
-
-  <para>Chart::Base module: 
-  <ulink url="http://www.cpan.org/modules/by-module/Chart/"/>
-  </para>
-
-  <para>(But remember, Bundle::Bugzilla will install all the modules for you.)
-  </para>
-</appendix>
-
-<!-- Keep this comment at the end of the file
-Local variables:
-mode: sgml
-sgml-always-quote-attributes:t
-sgml-auto-insert-required-elements:t
-sgml-balanced-tag-edit:t
-sgml-exposed-tags:nil
-sgml-general-insert-case:lower
-sgml-indent-data:t
-sgml-indent-step:2
-sgml-local-catalogs:nil
-sgml-local-ecat-files:nil
-sgml-minimize-attributes:nil
-sgml-namecase-general:t
-sgml-omittag:t
-sgml-parent-document:("Bugzilla-Guide.xml" "book" "chapter")
-sgml-shorttag:t
-sgml-tag-region-if-active:t
-End:
--->
-

mozilla/webtools/bugzilla/docs/en/xml/security.xml

@@ -1,364 +0,0 @@
-<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
-                      "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
-    <!ENTITY % myents SYSTEM "bugzilla.ent">
-    %myents;
-]>
-<!-- $Id: security.xml,v 1.19.2.1 2008-07-13 16:44:28 mozilla%colinogilvie.co.uk Exp $ -->
-
-<chapter id="security">
-<title>Bugzilla Security</title>
-
-  <para>While some of the items in this chapter are related to the operating
-  system Bugzilla is running on or some of the support software required to
-  run Bugzilla, it is all related to protecting your data. This is not
-  intended to be a comprehensive guide to securing Linux, Apache, MySQL, or
-  any other piece of software mentioned. There is no substitute for active
-  administration and monitoring of a machine. The key to good security is
-  actually right in the middle of the word: <emphasis>U R It</emphasis>.
-  </para>
-  
-  <para>While programmers in general always strive to write secure code,
-  accidents can and do happen. The best approach to security is to always
-  assume that the program you are working with isn't 100% secure and restrict
-  its access to other parts of your machine as much as possible.
-  </para>
- 
-  <section id="security-os">
-  <title>Operating System</title>
-  
-    <section id="security-os-ports">
-    <title>TCP/IP Ports</title>
-    
-      <!-- TODO: Get exact number of ports -->
-      <para>The TCP/IP standard defines more than 65,000 ports for sending
-      and receiving traffic. Of those, Bugzilla needs exactly one to operate
-      (different configurations and options may require up to 3). You should
-      audit your server and make sure that you aren't listening on any ports
-      you don't need to be. It's also highly recommended that the server
-      Bugzilla resides on, along with any other machines you administer, be
-      placed behind some kind of firewall.
-      </para>
-    
-    </section>
-    
-    <section id="security-os-accounts">
-    <title>System User Accounts</title>
-    
-      <para>Many <glossterm linkend="gloss-daemon">daemons</glossterm>, such
-      as Apache's <filename>httpd</filename> or MySQL's
-      <filename>mysqld</filename>, run as either <quote>root</quote> or
-      <quote>nobody</quote>. This is even worse on Windows machines where the
-      majority of <glossterm linkend="gloss-service">services</glossterm>
-      run as <quote>SYSTEM</quote>. While running as <quote>root</quote> or
-      <quote>SYSTEM</quote> introduces obvious security concerns, the
-      problems introduced by running everything as <quote>nobody</quote> may
-      not be so obvious. Basically, if you run every daemon as
-      <quote>nobody</quote> and one of them gets compromised it can
-      compromise every other daemon running as <quote>nobody</quote> on your
-      machine. For this reason, it is recommended that you create a user
-      account for each daemon.
-      </para>
-    
-      <note>
-        <para>You will need to set the <option>webservergroup</option> option
-        in <filename>localconfig</filename> to the group your web server runs
-        as. This will allow <filename>./checksetup.pl</filename> to set file
-        permissions on Unix systems so that nothing is world-writable.
-        </para>
-      </note>
-    
-    </section>
-    
-    <section id="security-os-chroot">
-    <title>The <filename>chroot</filename> Jail</title>
-    
-      <para>
-        If your system supports it, you may wish to consider running
-        Bugzilla inside of a <filename>chroot</filename> jail. This option
-        provides unprecedented security by restricting anything running
-        inside the jail from accessing any information outside of it. If you
-        wish to use this option, please consult the documentation that came
-        with your system.
-      </para>
-      
-    </section>
-  
-  </section>
-  
-  
-  
-  <section id="security-mysql">
-  <title>MySQL</title>
-  
-    <section id="security-mysql-account">
-    <title>The MySQL System Account</title>
-    
-      <para>As mentioned in <xref linkend="security-os-accounts"/>, the MySQL
-      daemon should run as a non-privileged, unique user. Be sure to consult
-      the MySQL documentation or the documentation that came with your system
-      for instructions.
-      </para>
-    </section>
-    
-    <section id="security-mysql-root">
-    <title>The MySQL <quote>root</quote> and <quote>anonymous</quote> Users</title>
-    
-      <para>By default, MySQL comes with a <quote>root</quote> user with a
-      blank password and an <quote>anonymous</quote> user, also with a blank
-      password. In order to protect your data, the <quote>root</quote> user
-      should be given a password and the anonymous user should be disabled.
-      </para>
-      
-      <example id="security-mysql-account-root">
-      <title>Assigning the MySQL <quote>root</quote> User a Password</title>
-      
-        <screen>
-<prompt>bash$</prompt> mysql mysql
-<prompt>mysql&gt;</prompt> UPDATE user SET password = password('<replaceable>new_password</replaceable>') WHERE user = 'root';
-<prompt>mysql&gt;</prompt> FLUSH PRIVILEGES;
-        </screen>
-      </example>
-      
-      <example id="security-mysql-account-anonymous">
-      <title>Disabling the MySQL <quote>anonymous</quote> User</title>
-        <screen>
-<prompt>bash$</prompt> mysql -u root -p mysql           <co id="security-mysql-account-anonymous-mysql"/>
-<prompt>Enter Password:</prompt> <replaceable>new_password</replaceable>
-<prompt>mysql&gt;</prompt> DELETE FROM user WHERE user = '';
-<prompt>mysql&gt;</prompt> FLUSH PRIVILEGES;
-        </screen>
-        <calloutlist>
-          <callout arearefs="security-mysql-account-anonymous-mysql">
-            <para>This command assumes that you have already completed
-            <xref linkend="security-mysql-account-root"/>.
-            </para>
-          </callout>
-        </calloutlist>
-      </example>
-          
-    </section>
-    
-    <section id="security-mysql-network">
-    <title>Network Access</title>
-    
-      <para>If MySQL and your web server both run on the same machine and you
-      have no other reason to access MySQL remotely, then you should disable
-      the network access. This, along with the suggestion in
-      <xref linkend="security-os-ports"/>, will help protect your system from
-      any remote vulnerabilities in MySQL.
-      </para>
-      
-      <example id="security-mysql-network-ex">
-      <title>Disabling Networking in MySQL</title>
-      
-        <para>Simply enter the following in <filename>/etc/my.cnf</filename>:
-        <screen>
-[mysqld]
-# Prevent network access to MySQL.
-skip-networking
-        </screen>
-        </para>
-      </example>
-      
-    </section>
-
-
-<!-- For possible addition in the future: How to better control the bugs user
-    <section id="security-mysql-bugs">
-    <title>The bugs User</title>
-    
-    </section>
--->
-  
-  </section>
-  
-  
-  
-  <section id="security-webserver">
-  <title>Web server</title>
-
-    <section id="security-webserver-access">
-    <title>Disabling Remote Access to Bugzilla Configuration Files</title>
-    
-      <para>
-        There are many files that are placed in the Bugzilla directory
-        area that should not be accessible from the web server. Because of the way
-        Bugzilla is currently layed out, the list of what should and should not
-        be accessible is rather complicated. A quick way is to run
-        <filename>testserver.pl</filename> to check if your web server serves
-        Bugzilla files as expected. If not, you may want to follow the few
-        steps below.
-      </para>
-      
-      <tip>
-        <para>Bugzilla ships with the ability to create
-        <glossterm linkend="gloss-htaccess"><filename>.htaccess</filename></glossterm>
-        files that enforce these rules. Instructions for enabling these
-        directives in Apache can be found in <xref linkend="http-apache"/>
-        </para>
-      </tip>
-        
-      <itemizedlist spacing="compact">
-        <listitem>
-          <para>In the main Bugzilla directory, you should:</para>
-          <itemizedlist spacing="compact">
-            <listitem>
-              <para>Block:
-              <simplelist type="inline">
-                <member><filename>*.pl</filename></member>
-                <member><filename>*localconfig*</filename></member>
-              </simplelist>
-              </para>
-            </listitem>
-          </itemizedlist>
-        </listitem>
-
-        <listitem>
-          <para>In <filename class="directory">data</filename>:</para>
-          <itemizedlist spacing="compact">
-            <listitem>
-              <para>Block everything</para>
-            </listitem>
-          </itemizedlist>
-        </listitem>
-
-        <listitem>
-          <para>In <filename class="directory">data/webdot</filename>:</para>
-          <itemizedlist spacing="compact">
-            <listitem>
-              <para>If you use a remote webdot server:</para>
-              <itemizedlist spacing="compact">
-                <listitem>
-                  <para>Block everything</para>
-                </listitem>
-                <listitem>
-                  <para>But allow
-                  <simplelist type="inline">
-                    <member><filename>*.dot</filename></member>
-                  </simplelist>
-                  only for the remote webdot server</para>
-                </listitem>
-              </itemizedlist>
-            </listitem>
-            <listitem>
-              <para>Otherwise, if you use a local GraphViz:</para>
-              <itemizedlist spacing="compact">
-                <listitem>
-                  <para>Block everything</para>
-                </listitem>
-                <listitem>
-                  <para>But allow:
-                  <simplelist type="inline">
-                    <member><filename>*.png</filename></member>
-                    <member><filename>*.gif</filename></member>
-                    <member><filename>*.jpg</filename></member>
-                    <member><filename>*.map</filename></member>
-                  </simplelist>
-                  </para>
-                </listitem>
-              </itemizedlist>
-            </listitem>
-            <listitem>
-              <para>And if you don't use any dot:</para>
-              <itemizedlist spacing="compact">
-                <listitem>
-                  <para>Block everything</para>
-                </listitem>
-              </itemizedlist>
-            </listitem>
-          </itemizedlist>
-        </listitem>
-
-        <listitem>
-          <para>In <filename class="directory">Bugzilla</filename>:</para>
-          <itemizedlist spacing="compact">
-            <listitem>
-              <para>Block everything</para>
-            </listitem>
-          </itemizedlist>
-        </listitem>
-
-        <listitem>
-          <para>In <filename class="directory">template</filename>:</para>
-          <itemizedlist spacing="compact">
-            <listitem>
-              <para>Block everything</para>
-            </listitem>
-          </itemizedlist>
-        </listitem>
-      </itemizedlist>
-
-      <para>Be sure to test that data that should not be accessed remotely is
-      properly blocked. Of particular interest is the localconfig file which
-      contains your database password. Also, be aware that many editors
-      create temporary and backup files in the working directory and that
-      those should also not be accessible. For more information, see
-      <ulink url="http://bugzilla.mozilla.org/show_bug.cgi?id=186383">bug 186383</ulink>
-      or
-      <ulink url="http://online.securityfocus.com/bid/6501">Bugtraq ID 6501</ulink>.
-      To test, simply run <filename>testserver.pl</filename>, as said above.
-      </para>
-      
-      <tip>
-        <para>Be sure to check <xref linkend="http"/> for instructions
-        specific to the web server you use.
-        </para>
-      </tip>
-    
-    </section>
-
-      
-  </section>
-  
-  
-  <section id="security-bugzilla">
-  <title>Bugzilla</title>
-
-    <section id="security-bugzilla-charset">
-    <title>Prevent users injecting malicious Javascript</title>
-
-      <para>If you installed Bugzilla version 2.22 or later from scratch,
-      then the <emphasis>utf8</emphasis> parameter is switched on by default.
-      This makes Bugzilla explicitly set the character encoding, following
-      <ulink
-      url="http://www.cert.org/tech_tips/malicious_code_mitigation.html#3">a
-      CERT advisory</ulink> recommending exactly this.
-      The following therefore does not apply to you; just keep
-      <emphasis>utf8</emphasis> turned on.
-      </para>
-
-      <para>If you've upgraded from an older version, then it may be possible
-      for a Bugzilla user to take advantage of character set encoding
-      ambiguities to inject HTML into Bugzilla comments.
-      This could include malicious scripts. 
-      This is because due to internationalization concerns, we are unable to
-      turn the <emphasis>utf8</emphasis> parameter on by default for upgraded
-      installations.
-      Turning it on manually will prevent this problem.
-      </para>
-    </section>    
-    
-  </section>
-
-</chapter> 
-
-<!-- Keep this comment at the end of the file 
-Local variables: 
-mode: sgml 
-sgml-always-quote-attributes:t
-sgml-auto-insert-required-elements:t
-sgml-balanced-tag-edit:t
-sgml-exposed-tags:nil
-sgml-general-insert-case:lower
-sgml-indent-data:t 
-sgml-indent-step:2 
-sgml-local-catalogs:nil
-sgml-local-ecat-files:nil 
-sgml-minimize-attributes:nil
-sgml-namecase-general:t 
-sgml-omittag:t
-sgml-parent-document:("Bugzilla-Guide.xml" "book" "chapter")
-sgml-shorttag:t 
-sgml-tag-region-if-active:t 
-End: -->
-

mozilla/webtools/bugzilla/docs/en/xml/troubleshooting.xml

@@ -1,311 +0,0 @@
-<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
-                      "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
-     <!ENTITY % myents SYSTEM "bugzilla.ent">
-     %myents;
- ]>
-<!-- $Id: troubleshooting.xml,v 1.13.4.1 2008-07-13 16:44:28 mozilla%colinogilvie.co.uk Exp $ -->
-
-<appendix id="troubleshooting">
-<title>Troubleshooting</title>
-
-  <para>This section gives solutions to common Bugzilla installation
-  problems. If none of the section headings seems to match your
-  problem, read the general advice.
-  </para>
-    
-  <section id="general-advice">
-  <title>General Advice</title>
-    <para>If you can't get <filename>checksetup.pl</filename> to run to 
-    completion, it normally explains what's wrong and how to fix it.
-    If you can't work it out, or if it's being uncommunicative, post 
-    the errors in the 
-    <ulink url="news://news.mozilla.org/mozilla.support.bugzilla">mozilla.support.bugzilla</ulink>
-    newsgroup.
-    </para>
-
-    <para>If you have made it all the way through
-    <xref linkend="installation"/> (Installation) and
-    <xref linkend="configuration"/> (Configuration) but accessing the Bugzilla
-    URL doesn't work, the first thing to do is to check your web server error
-    log. For Apache, this is often located at
-    <filename>/etc/logs/httpd/error_log</filename>. The error messages
-    you see may be self-explanatory enough to enable you to diagnose and
-    fix the problem. If not, see below for some commonly-encountered 
-    errors. If that doesn't help, post the errors to the newsgroup.
-    </para>
-
-    <para>
-      Bugzilla can also log all user-based errors (and many code-based errors)
-      that occur, without polluting the web server's error log.  To enable
-      Bugzilla error logging, create a file that Bugzilla can write to, named
-      <filename>errorlog</filename>, in the Bugzilla <filename>data</filename>
-      directory.  Errors will be logged as they occur, and will include the type
-      of the error, the IP address and username (if available) of the user who
-      triggered the error, and the values of all environment variables; if a
-      form was being submitted, the data in the form will also be included.
-      To disable error logging, delete or rename the
-      <filename>errorlog</filename> file.
-    </para>
-  </section>
-        
-  <section id="trbl-testserver">
-  <title>The Apache web server is not serving Bugzilla pages</title>
-    <para>After you have run <command>checksetup.pl</command> twice,
-    run <command>testserver.pl http://yoursite.yourdomain/yoururl</command>
-    to confirm that your web server is configured properly for
-    Bugzilla.
-    </para>
-    <programlisting>
-<prompt>bash$</prompt> ./testserver.pl http://landfill.bugzilla.org/bugzilla-tip
-TEST-OK Webserver is running under group id in $webservergroup.
-TEST-OK Got ant picture.
-TEST-OK Webserver is executing CGIs.
-TEST-OK Webserver is preventing fetch of http://landfill.bugzilla.org/bugzilla-tip/localconfig.
-</programlisting>
-  </section>
-
-  <section id="trbl-perlmodule">
-  <title>I installed a Perl module, but 
-      <filename>checksetup.pl</filename> claims it's not installed!</title>
-      
-    <para>This could be caused by one of two things:</para>
-    <orderedlist>
-      <listitem>
-        <para>You have two versions of Perl on your machine. You are installing
-        modules into one, and Bugzilla is using the other. Rerun the CPAN
-        commands (or manual compile) using the full path to Perl from the 
-        top of <filename>checksetup.pl</filename>. This will make sure you 
-        are installing the modules in the right place.
-        </para>
-      </listitem>
-      <listitem>
-        <para>The permissions on your library directories are set incorrectly.
-        They must, at the very least, be readable by the web server user or
-        group. It is recommended that they be world readable.
-        </para>
-      </listitem>
-    </orderedlist>
-  </section>
-
-  <section id="trbl-dbdSponge">
-  <title>DBD::Sponge::db prepare failed</title>
-      
-    <para>The following error message may appear due to a bug in DBD::mysql
-    (over which the Bugzilla team have no control):
-    </para>
-      
-<programlisting><![CDATA[ DBD::Sponge::db prepare failed: Cannot determine NUM_OF_FIELDS at D:/Perl/site/lib/DBD/mysql.pm line 248.
-  SV = NULL(0x0) at 0x20fc444
-  REFCNT = 1
-  FLAGS = (PADBUSY,PADMY)
-]]></programlisting>
-
-    <para>To fix this, go to 
-    <filename>&lt;path-to-perl&gt;/lib/DBD/sponge.pm</filename> 
-    in your Perl installation and replace
-    </para>
-        
-<programlisting><![CDATA[ my $numFields;
- if ($attribs->{'NUM_OF_FIELDS'}) {
-     $numFields = $attribs->{'NUM_OF_FIELDS'};
- } elsif ($attribs->{'NAME'}) {
-     $numFields = @{$attribs->{NAME}};
-]]></programlisting>
-
-    <para>with</para>
-
-<programlisting><![CDATA[ my $numFields;
- if ($attribs->{'NUM_OF_FIELDS'}) {
-     $numFields = $attribs->{'NUM_OF_FIELDS'};
- } elsif ($attribs->{'NAMES'}) {
-     $numFields = @{$attribs->{NAMES}};
-]]></programlisting>
-
-     <para>(note the S added to NAME.)</para>
-  </section>
-    
-  <section id="paranoid-security">
-  <title>cannot chdir(/var/spool/mqueue)</title>
-
-    <para>If you are installing Bugzilla on SuSE Linux, or some other
-    distributions with <quote>paranoid</quote> security options, it is
-    possible that the checksetup.pl script may fail with the error: 
-<programlisting><![CDATA[cannot chdir(/var/spool/mqueue): Permission denied
-]]></programlisting>
-    </para>
-      
-    <para>This is because your <filename>/var/spool/mqueue</filename>
-    directory has a mode of <computeroutput>drwx------</computeroutput>.
-    Type <command>chmod 755 <filename>/var/spool/mqueue</filename></command>
-    as root to fix this problem. This will allow any process running on your
-    machine the ability to <emphasis>read</emphasis> the
-    <filename>/var/spool/mqueue</filename> directory.
-    </para>
-  </section>    
-
-  <section id="trbl-relogin-everyone">
-  <title>Everybody is constantly being forced to relogin</title>
-  
-  <para>The most-likely cause is that the <quote>cookiepath</quote> parameter
-  is not set correctly in the Bugzilla configuration.  You can change this (if
-  you're a Bugzilla administrator) from the editparams.cgi page via the web interface.
-  </para>
-
-  <para>The value of the cookiepath parameter should be the actual directory
-  containing your Bugzilla installation, <emphasis>as seen by the end-user's
-  web browser</emphasis>. Leading and trailing slashes are mandatory. You can
-  also set the cookiepath to any directory which is a parent of the Bugzilla
-  directory (such as '/', the root directory). But you can't put something
-  that isn't at least a partial match or it won't work. What you're actually
-  doing is restricting the end-user's browser to sending the cookies back only
-  to that directory.
-  </para>
-
-  <para>How do you know if you want your specific Bugzilla directory or the
-  whole site?
-  </para>
-
-  <para>If you have only one Bugzilla running on the server, and you don't
-  mind having other applications on the same server with it being able to see
-  the cookies (you might be doing this on purpose if you have other things on
-  your site that share authentication with Bugzilla), then you'll want to have
-  the cookiepath set to "/", or to a sufficiently-high enough directory that
-  all of the involved apps can see the cookies.
-  </para>
-
-  <example id="trbl-relogin-everyone-share">
-  <title>Examples of urlbase/cookiepath pairs for sharing login cookies</title>
-
-    <blockquote>
-      <literallayout>
-        urlbase is <ulink url="http://bugzilla.mozilla.org/"/>
-        cookiepath is /
-
-        urlbase is <ulink url="http://tools.mysite.tld/bugzilla/"/>
-                but you have http://tools.mysite.tld/someotherapp/ which shares
-                authentication with your Bugzilla
-        cookiepath is /
-      </literallayout>
-    </blockquote>
-  </example>
-          
-   <para>On the other hand, if you have more than one Bugzilla running on the
-   server (some people do - we do on landfill) then you need to have the
-   cookiepath restricted enough so that the different Bugzillas don't
-   confuse their cookies with one another.
-   </para>
-
-
-   <example id="trbl-relogin-everyone-restrict">
-   <title>Examples of urlbase/cookiepath pairs to restrict the login cookie</title>
-      <blockquote>
-        <literallayout>
-        urlbase is <ulink url="http://landfill.bugzilla.org/bugzilla-tip/"/>
-        cookiepath is /bugzilla-tip/
-
-        urlbase is <ulink url="http://landfill.bugzilla.org/bugzilla-2.16-branch/"/>
-        cookiepath is /bugzilla-2.16-branch/
-        </literallayout>
-      </blockquote>
-    </example>
-
-    <para>If you had cookiepath set to <quote>/</quote> at any point in the
-    past and need to set it to something more restrictive
-    (i.e. <quote>/bugzilla/</quote>), you can safely do this without
-    requiring users to delete their Bugzilla-related cookies in their
-    browser (this is true starting with Bugzilla 2.18 and Bugzilla 2.16.5).
-    </para>
-  </section>
-
-  <section id="trbl-relogin-some">
-  <title>Some users are constantly being forced to relogin</title>
-
-    <para>First, make sure cookies are enabled in the user's browser.
-    </para>
-
-    <para>If that doesn't fix the problem, it may be that the user's ISP
-     implements a rotating proxy server. This causes the user's effective IP
-     address (the address which the Bugzilla server perceives him coming from)
-     to change periodically. Since Bugzilla cookies are tied to a specific IP
-     address, each time the effective address changes, the user will have to
-     log in again.
-     </para>
-
-     <para>If you are using 2.18 (or later), there is a
-     parameter called <quote>loginnetmask</quote>, which you can use to set
-     the number of bits of the user's IP address to require to be matched when
-     authenticating the cookies. If you set this to something less than 32,
-     then the user will be given a checkbox for <quote>Restrict this login to
-     my IP address</quote> on the login screen, which defaults to checked. If
-     they leave the box checked, Bugzilla will behave the same as it did
-     before, requiring an exact match on their IP address to remain logged in.
-     If they uncheck the box, then only the left side of their IP address (up
-     to the number of bits you specified in the parameter) has to match to
-     remain logged in.
-     </para>
-
-   </section>
-
-  <section id="trbl-index">
-  <title><filename>index.cgi</filename> doesn't show up unless specified in the URL</title>
-    <para>
-      You probably need to set up your web server in such a way that it
-      will serve the index.cgi page as an index page.
-    </para>
-    <para>
-      If you are using Apache, you can do this by adding 
-      <filename>index.cgi</filename> to the end of the 
-      <computeroutput>DirectoryIndex</computeroutput> line
-      as mentioned in <xref linkend="http-apache"/>.
-    </para>
-
-  </section>
-
-  <section id="trbl-passwd-encryption">
-    <title>
-      checksetup.pl reports "Client does not support authentication protocol
-      requested by server..."
-    </title>
-
-    <para>
-      This error is occurring because you are using the new password
-      encryption that comes with MySQL 4.1, while your
-      <filename>DBD::mysql</filename> module was compiled against an
-      older version of MySQL. If you recompile <filename>DBD::mysql</filename>
-      against the current MySQL libraries (or just obtain a newer version
-      of this module) then the error may go away.
-    </para>
-
-    <para>
-      If that does not fix the problem, or if you cannot recompile the
-      existing module (e.g. you're running Windows) and/or don't want to
-      replace it (e.g. you want to keep using a packaged version), then a
-      workaround is available from the MySQL docs:
-      <ulink url="http://dev.mysql.com/doc/mysql/en/Old_client.html"/>
-    </para>
-
-  </section>
-
-</appendix> 
-
-<!-- Keep this comment at the end of the file 
-Local variables: 
-mode: sgml 
-sgml-always-quote-attributes:t
-sgml-auto-insert-required-elements:t
-sgml-balanced-tag-edit:t
-sgml-exposed-tags:nil
-sgml-general-insert-case:lower
-sgml-indent-data:t 
-sgml-indent-step:2 
-sgml-local-catalogs:nil
-sgml-local-ecat-files:nil 
-sgml-minimize-attributes:nil
-sgml-namecase-general:t 
-sgml-omittag:t
-sgml-parent-document:("Bugzilla-Guide.xml" "book" "chapter")
-sgml-shorttag:t 
-sgml-tag-region-if-active:t 
-End: -->
-
-

mozilla/webtools/bugzilla/docs/makedocs.pl

@@ -1,217 +0,0 @@
-#!/usr/bin/perl -w
-# -*- Mode: perl; indent-tabs-mode: nil -*-
-#
-# The contents of this file are subject to the Mozilla Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/MPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is the Bugzilla Bug Tracking System.
-#
-# The Initial Developer of the Original Code is Netscape Communications
-# Corporation. Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): Matthew Tuck <matty@chariot.net.au>
-#                 Jacob Steenhagen <jake@bugzilla.org>
-#                 Colin Ogilvie <colin.ogilvie@gmail.com>
-#                 Max Kanat-Alexander <mkanat@bugzilla.org>
-
-# This script compiles all the documentation.
-
-use strict;
-use Cwd;
-
-# We need to be in this directory to use our libraries.
-BEGIN {
-    require File::Basename;
-    import File::Basename qw(dirname);
-    chdir dirname($0);
-}
-
-use lib qw(.. ../lib lib);
-
-# We only compile our POD if Pod::Simple is installed. We do the checks
-# this way so that if there's a compile error in Pod::Simple::HTML::Bugzilla,
-# makedocs doesn't just silently fail, but instead actually tells us there's
-# a compile error.
-my $pod_simple;
-if (eval { require Pod::Simple }) {
-    require Pod::Simple::HTMLBatch::Bugzilla;
-    require Pod::Simple::HTML::Bugzilla;
-    $pod_simple = 1;
-};
-
-use Bugzilla::Install::Requirements 
-    qw(REQUIRED_MODULES OPTIONAL_MODULES);
-use Bugzilla::Constants qw(DB_MODULE BUGZILLA_VERSION);
-
-###############################################################################
-# Generate minimum version list
-###############################################################################
-
-my $modules = REQUIRED_MODULES;
-my $opt_modules = OPTIONAL_MODULES;
-
-open(ENTITIES, '>', 'bugzilla.ent') or die('Could not open bugzilla.ent: ' . $!);
-print ENTITIES <<END_ENTITIES;
-<?xml version="1.0" encoding="UTF-8" ?>
-
-<!ENTITY bz-ver "3.3">
-<!ENTITY bz-nextver "4.0">
-<!ENTITY bz-date "2008-05-20">
-<!ENTITY current-year "2008">
-
-<!ENTITY landfillbase "http://landfill.bugzilla.org/bugzilla-tip/">
-<!ENTITY bz "http://www.bugzilla.org/">
-<!ENTITY bzg-bugs "<ulink url='https://bugzilla.mozilla.org/enter_bug.cgi?product=Bugzilla&amp;component=Documentation'>Bugzilla Documentation</ulink>">
-<!ENTITY mysql "http://www.mysql.com/">
-
-<!ENTITY min-perl-ver "5.8.1">
-
-
-<!-- Module Versions -->
-END_ENTITIES
-foreach my $module (@$modules, @$opt_modules)
-{
-    my $name = $module->{'module'};
-    $name =~ s/::/-/g;
-    $name = lc($name);
-    #This needs to be a string comparison, due to the modules having
-    #version numbers like 0.9.4
-    my $version = $module->{'version'} eq 0 ? 'any' : $module->{'version'};
-    print ENTITIES '<!ENTITY min-' . $name . '-ver "'.$version.'">' . "\n";
-}
-
-# CGI is a special case, because for Perl versions below 5.10, it has an
-# optional version *and* a required version.
-# We check @opt_modules first, then @modules, and pick the first we get.
-# We'll get the optional one then, if it is given, otherwise the required one.
-my ($cgi_opt) = grep($_->{module} eq 'CGI', @$opt_modules, @$modules);
-print ENTITIES '<!ENTITY min-mp-cgi-ver "' . $cgi_opt->{version} . '">' . "\n";
-
-print ENTITIES "\n <!-- Database Versions --> \n";
-
-my $db_modules = DB_MODULE;
-foreach my $db (keys %$db_modules) {
-    my $dbd  = $db_modules->{$db}->{dbd};
-    my $name = $dbd->{module};
-    $name =~ s/::/-/g;
-    $name = lc($name);
-    my $version    = $dbd->{version} || 'any';
-    my $db_version = $db_modules->{$db}->{'db_version'};
-    print ENTITIES '<!ENTITY min-' . $name . '-ver "'.$version.'">' . "\n";
-    print ENTITIES '<!ENTITY min-' . lc($db) . '-ver "'.$db_version.'">' . "\n";
-}
-close(ENTITIES);
-
-###############################################################################
-# Subs
-###############################################################################
-
-sub MakeDocs {
-
-    my ($name, $cmdline) = @_;
-
-    print "Creating $name documentation ...\n" if defined $name;
-    print "$cmdline\n\n";
-    system $cmdline;
-    print "\n";
-
-}
-
-sub make_pod {
-
-    print "Creating API documentation...\n";
-
-    my $converter = Pod::Simple::HTMLBatch::Bugzilla->new;
-    # Don't output progress information.
-    $converter->verbose(0);
-    $converter->html_render_class('Pod::Simple::HTML::Bugzilla');
-
-    my $doctype      = Pod::Simple::HTML::Bugzilla->DOCTYPE;
-    my $content_type = Pod::Simple::HTML::Bugzilla->META_CT;
-    my $bz_version   = BUGZILLA_VERSION;
-
-    my $contents_start = <<END_HTML;
-$doctype
-<html>
-  <head>
-    $content_type
-    <title>Bugzilla $bz_version API Documentation</title>
-  </head>
-  <body class="contentspage">
-    <h1>Bugzilla $bz_version API Documentation</h1>
-END_HTML
-
-    $converter->contents_page_start($contents_start);
-    $converter->contents_page_end("</body></html>");
-    $converter->add_css('./../../../style.css');
-    $converter->javascript_flurry(0);
-    $converter->css_flurry(0);
-    $converter->batch_convert(['../../'], 'html/api/');
-
-    print "\n";
-}
-
-###############################################################################
-# Make the docs ...
-###############################################################################
-
-my @langs;
-# search for sub directories which have a 'xml' sub-directory
-opendir(LANGS, './');
-foreach my $dir (readdir(LANGS)) {
-    next if (($dir eq '.') || ($dir eq '..') || (! -d $dir));
-    if (-d "$dir/xml") {
-        push(@langs, $dir);
-    }
-}
-closedir(LANGS);
-
-my $docparent = getcwd();
-foreach my $lang (@langs) {
-    chdir "$docparent/$lang";
-    MakeDocs(undef, 'cp ../bugzilla.ent ./xml/');
-
-    if (!-d 'txt') {
-        unlink 'txt';
-        mkdir 'txt', 0755;
-    }
-    if (!-d 'pdf') {
-        unlink 'pdf';
-        mkdir 'pdf', 0755;
-    }
-    if (!-d 'html') {
-        unlink 'html';
-        mkdir 'html', 0755;
-    }
-    if (!-d 'html/api') {
-        unlink 'html/api';
-        mkdir 'html/api', 0755;
-    }
-
-	MakeDocs(undef, 'cp ../style.css html/api/');
-
-    make_pod() if $pod_simple;
-
-    MakeDocs('separate HTML', 'xmlto -m ../xsl/chunks.xsl -o html html ' .
-             'xml/Bugzilla-Guide.xml');
-    MakeDocs('big HTML', 'xmlto -m ../xsl/nochunks.xsl -o html html-nochunks ' .
-             'xml/Bugzilla-Guide.xml');
-    MakeDocs('big text', "lynx -dump -justify=off -nolist html/Bugzilla-Guide.html " .
-        "> txt/Bugzilla-Guide.txt");
-
-    if (! grep($_ eq "--with-pdf", @ARGV)) {
-        next;
-    }
-	
-    MakeDocs('PDF', 'xmlto -m ../xsl/pdf.xsl -o pdf pdf xml/Bugzilla-Guide.xml');
-}
-

mozilla/webtools/bugzilla/docs/style.css

@@ -1,112 +0,0 @@
-/* The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- *
- * The Original Code is the Bugzilla Bug Tracking System.
- *
- * The Initial Developer of the Original Code is Everything Solved.
- * Portions created by Everything Solved are Copyright (C) 2006 
- * Everything Solved. All Rights Reserved.
- *
- * Contributor(s): Max Kanat-Alexander <mkanat@bugzilla.org>
- */
-
-body {
-  background: white;
-  color: #111;
-  padding: 0 1em;
-  margin: 0;
-  font-family: Verdana, Arial, sans-serif;
-  font-size: small;
-}
-
-td, th {
-  font-family: Verdana, Arial, sans-serif;
-  font-size: small;
-}
-
-a:link, a:active { color: #36415c; }
-a:visited { color: #666; }
-a:hover   { color: #888; }
-
-h1 {
-  font-size: 150%;
-  font-weight: bold;
-  border-bottom: 2px solid #ccc;
-}
-h2 {
-  font-size: 125%;
-  font-weight: bold;
-  border-bottom: 1px solid #ccc;
-  margin-bottom: 8px;
-}
-h3 {
-  font-size: 115%;
-  font-weight: bold;
-  margin-bottom: 0;
-  padding-bottom: 0;
-}
-
-/* This makes Description/Params/Returns look nice. */
-dd   { margin-top: .2em; }
-dd p { margin-top: 0; }
-dl   { margin-bottom: 1em; }
-
-/* This makes the names of functions slightly larger, in Gecko. */
-body > dl > dt code { font-size: 1.35em; }
-
-#pod h1 a, #pod h2 a, #pod h3 a {
-  color: #36415c;
-  text-decoration: none;
-}
-
-pre, code, tt, kbd, samp {
-  /* Unfortunately, the default monospace fonts on most browsers
-     look odd with relative sizing. */
-  font-size: 12px;
-}
-
-.code {
-  background: #eed;
-  border: 1px solid #ccc;
-}
-
-pre.code {
-  margin-left: 10px;
-  width: 90%;
-  padding: 10px;
-}
-
-/* Special styles for the Contents page */
-
-.contentspage dt {
-  font-size: large;
-  font-weight: bold;
-}
-
-.pod_desc_table {
-  border-collapse: collapse;
-  table-layout: auto;
-  border: 1px solid #ccc;
-}
-
-.pod_desc_table th {
-  text-align: left;
-}
-
-.pod_desc_table td, .pod_desc_table th {
-  padding: .25em;
-  border-top: 1px solid #ccc;
-}
-
-.pod_desc_table .odd th, .pod_desc_table .odd td {
-  background-color: #eee;
-}
-
-.pod_desc_table 

mozilla/webtools/bugzilla/docs/xsl/bugzilla-docs.xsl

@@ -1,102 +0,0 @@
-<?xml version="1.0" encoding="iso-8859-1"?>
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
-
-<!-- Nicer Filenames -->
-<xsl:param name="use.id.as.filename" select="1"/>
-
-<!-- Label sections if they aren't automatically labeled -->
-<xsl:param name="section.autolabel" select="1"/>
-
-<!-- Table of Contents Depth -->
-<xsl:param name="toc.section.depth">1</xsl:param>
-
-<!-- Set chunk parameters -->
-<xsl:param name="chunk.section.depth" select="1"/>
-<xsl:param name="chunk.first.sections" select="1"/>
-<xsl:param name="chunker.output.encoding" select="UTF-8"/>
-
-<!-- Show titles of next/previous page -->
-<xsl:param name="navig.showtitles">1</xsl:param>
-
-<!-- Tidy up the HTML a bit... -->
-<xsl:param name="html.cleanup" select="1"/>
-<xsl:param name="make.valid.html" select="1"/>
-<xsl:param name="html.stylesheet">api/style.css</xsl:param>
-<!-- make links nicer... -->
-<xsl:param name="refentry.generate.title" select="1"/>
-<xsl:param name="refentry.generate.name" select="0"/>
-
-<!-- Use Graphics, specify their Path and Extension -->
-<xsl:param name="admon.graphics" select="1"/>
-<xsl:param name="admon.graphics.path">../images/</xsl:param>
-<xsl:param name="admon.graphics.extension">.gif</xsl:param>
-
-<xsl:param name="qanda.inherit.numeration" select="0" />
-
-<!--
-****
-CODE BELOW HERE IS EXTRACTED AND EDITED FROM THE DOCBOOK XSL SOURCES
-****
--->
-
-<xsl:template match="simplelist[@type='inline']/member">
-    <xsl:apply-templates/>
-</xsl:template>
-
-<!--
-To generate valid HTML, we need to redefine this section... Code extracted from
-http://cvs.sourceforge.net/viewcvs.py/docbook/xsl/html/qandaset.xsl?rev=1.19&view=log
-
-and modified below. Basic change: Remove the colspan attribute of the tr tags - no
-other changes have been made to the document.
--->
-
-<xsl:template match="qandadiv">
-  <xsl:variable name="preamble" select="*[name(.) != 'title'
-                                          and name(.) != 'titleabbrev'
-                                          and name(.) != 'qandadiv'
-                                          and name(.) != 'qandaentry']"/>
-
-  <xsl:if test="blockinfo/title|title">
-    <tr class="qandadiv">
-      <td align="left" valign="top" colspan="2">
-        <xsl:call-template name="anchor">
-          <xsl:with-param name="conditional" select="0"/>
-        </xsl:call-template>
-        <xsl:apply-templates select="(blockinfo/title|title)[1]"/>
-      </td>
-    </tr>
-  </xsl:if>
-
-  <xsl:variable name="toc">
-    <xsl:call-template name="dbhtml-attribute">
-      <xsl:with-param name="pis"
-                      select="processing-instruction('dbhtml')"/>
-      <xsl:with-param name="attribute" select="'toc'"/>
-    </xsl:call-template>
-  </xsl:variable>
-
-  <xsl:variable name="toc.params">
-    <xsl:call-template name="find.path.params">
-      <xsl:with-param name="table" select="normalize-space($generate.toc)"/>
-    </xsl:call-template>
-  </xsl:variable>
-
-  <xsl:if test="(contains($toc.params, 'toc') and $toc != '0') or $toc = '1'">
-    <tr class="toc">
-      <td align="left" valign="top" colspan="2">
-        <xsl:call-template name="process.qanda.toc"/>
-      </td>
-    </tr>
-  </xsl:if>
-  <xsl:if test="$preamble">
-    <tr class="toc"	>
-      <td align="left" valign="top" colspan="2">
-        <xsl:apply-templates select="$preamble"/>
-      </td>
-    </tr>
-  </xsl:if>
-  <xsl:apply-templates select="qandadiv|qandaentry"/>
-</xsl:template>
-</xsl:stylesheet>
-

mozilla/webtools/bugzilla/docs/xsl/chunks.xsl

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="iso-8859-1"?>
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
-	<!-- Include default bugzilla XSL -->
-	<xsl:include href="bugzilla-docs.xsl"/>
-	<!-- Set Chunk Specific XSL Params -->
-	<xsl:param name="chunker.output.doctype-public">-//W3C//DTD HTML 4.01 Transitional//EN</xsl:param>
-	<xsl:param name="chunker.output.doctype-system">http://www.w3.org/TR/html4/loose.dtd</xsl:param>
-	<xsl:param name="chunk.section.depth" select="1"/>
-	<xsl:param name="chunk.first.sections" select="1"/>
-	<!-- Don't output filename list - mimic old behaviour-->
-	<xsl:param name="chunk.quietly" select="0" />
-</xsl:stylesheet>		

mozilla/webtools/bugzilla/docs/xsl/nochunks.xsl

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="iso-8859-1"?>
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
-	<!-- Include default bugzilla XSL -->
-	<xsl:include href="bugzilla-docs.xsl"/>
-	<!-- No other params necessary -->
-</xsl:stylesheet>		

mozilla/webtools/bugzilla/docs/xsl/pdf.xsl

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="iso-8859-1"?>
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:fo="http://www.w3.org/1999/XSL/Format" version="1.0">
-    <!-- Enable passivetex extensions -->
-	<xsl:param name="passivetex.extensions" select="1"/>
-    <xsl:param name="tablecolumns.extensions" select="1"/>
-    
-	<!-- Show <ulink>s as footnotes -->
-    <xsl:param name="ulink.footnotes" select="1" />
-	<xsl:param name="ulink.show" select="1" />
-	
-	<!-- Don't use Graphics -->
-	<xsl:param name="admon.graphics" select="0"/>
-	<xsl:param name="callout.graphics" select="'0'"/>
-	
-	<xsl:template match="simplelist[@type='inline']/member">
-        <xsl:apply-templates/>
-    </xsl:template>
-
-</xsl:stylesheet>

mozilla/xpcom/Makefile.in

@@ -0,0 +1,40 @@
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#
+
+DEPTH		= ..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+DIRS		= typelib base ds io components threads reflect proxy build tools sample
+
+ifdef ENABLE_TESTS
+DIRS		+= \
+	typelib/xpt/tests \
+	reflect/xptinfo/tests \
+	reflect/xptcall/tests \
+	proxy/tests
+endif
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/xpcom/appshell/Makefile.in

@@ -0,0 +1,32 @@
+#
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/MPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is the Mozilla browser.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications, Inc.  Portions created by Netscape are
+# Copyright (C) 1999, Mozilla.  All Rights Reserved.
+#
+# Contributor(s):
+#   Travis Bogard <travis@netscape.com>
+#
+
+DEPTH		= ../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+DIRS		= eventloop nativeApp
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/xpcom/appshell/eventloop/Makefile.in

@@ -0,0 +1,36 @@
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#
+
+DEPTH		= ../../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+DIRS		= xp
+
+ifneq (,$(filter gtk photon,$(MOZ_WIDGET_TOOLKIT)))
+DIRS		+= $(MOZ_WIDGET_TOOLKIT)
+endif
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/xpcom/appshell/eventloop/makefile.win

@@ -0,0 +1,27 @@
+#!nmake
+# 
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/MPL/
+# 
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+# 
+# The Original Code is the Mozilla browser.
+# 
+# The Initial Developer of the Original Code is Netscape
+# Communications, Inc.  Portions created by Netscape are
+# Copyright (C) 1999, Mozilla.  All Rights Reserved.
+# 
+# Contributor(s):
+#   Travis Bogard <travis@netscape.com>
+
+DEPTH=..\..\..
+
+DIRS=xp windows
+
+include <$(DEPTH)\config\rules.mak>
+include <$(DEPTH)\config\config.mak>

mozilla/xpcom/appshell/eventloop/photon/Makefile.in

@@ -0,0 +1,55 @@
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#   Jerry Kirk <Jerry.Kirk@NexwareCorp.com>
+#
+
+DEPTH		= ../../../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE		= xpcom_eventloop_photon
+LIBRARY_NAME	= eventloop
+IS_COMPONENT	= 1
+
+
+CPPSRCS		= \
+		nsCPhEvent.cpp \
+		nsCEvent.cpp \
+		nsCEventFilter.cpp \
+		nsCPlatformBaseLoop.cpp \
+		nsCAppLoop.cpp \
+		$(NULL)
+
+LOCAL_INCLUDES	= -I. -I../xp
+
+SHARED_LIBRARY_LIBS = ../xp/libxp_eventloop.a
+
+EXTRA_DSO_LDOPTS = \
+		$(TOOLKIT_DSO_LDOPTS) \
+		$(TK_LIBS) \
+		$(NULL)
+
+include $(topsrcdir)/config/rules.mk
+
+CXXFLAGS	+= $(TK_CFLAGS)
+

mozilla/xpcom/appshell/eventloop/photon/nsCAppLoop.cpp

@@ -0,0 +1,73 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#include "nsCAppLoop.h"
+#include "nsCPhFilter.h"
+#include "nsPhEventLog.h"
+
+//*****************************************************************************
+//***    nsCAppLoop: Object Management
+//*****************************************************************************
+
+nsCAppLoop::nsCAppLoop() : nsCBaseAppLoop()
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCAppLoop::nsCAppLoop m_PhThreadId=<%d>\n", m_PhThreadId)); 
+}
+
+nsCAppLoop::~nsCAppLoop()
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCAppLoop::~nsCAppLoop m_PhThreadId=<%d>\n", m_PhThreadId)); 
+
+}
+
+NS_METHOD nsCAppLoop::Create(nsISupports* aOuter, const nsIID& aIID, 
+	void** ppv)
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCAppLoop::Create\n")); 
+
+	NS_ENSURE_ARG_POINTER(ppv);
+	NS_ENSURE_NO_AGGREGATION(aOuter);
+
+	nsCAppLoop* app = new nsCAppLoop();
+	NS_ENSURE_TRUE(app, NS_ERROR_OUT_OF_MEMORY);
+
+	NS_ADDREF(app);
+	nsresult rv = app->QueryInterface(aIID, ppv);
+	NS_RELEASE(app);
+
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCAppLoop::Create the end rv=<%d>\n", rv)); 
+
+	return rv;
+}
+
+//*****************************************************************************
+// nsCAppLoop:: Internal Platform Implementations of nsIEventLoop 
+//							(Error checking is ensured above)
+//*****************************************************************************   
+
+nsresult nsCAppLoop::PlatformExit(PRInt32 exitCode)
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCAppLoop::PlatformExit exitCode=<%d>\n", exitCode)); 
+
+	PostQuitMessage(exitCode);
+	return NS_OK;
+}

mozilla/xpcom/appshell/eventloop/photon/nsCAppLoop.h

@@ -0,0 +1,43 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#ifndef nsCAppLoop_h__
+#define nsCAppLoop_h__
+
+
+#include "nsCBaseAppLoop.h"
+
+class nsCAppLoop : public nsCBaseAppLoop 
+{
+public:
+	static NS_METHOD Create(nsISupports* aOuter, const nsIID& aIID, void** ppv);
+
+protected:
+	nsCAppLoop();
+	virtual ~nsCAppLoop();
+
+	// Internal Platform Implementations of nsIEventLoop 
+	// (Error checking is ensured above)
+	nsresult PlatformExit(PRInt32 exitCode);
+};
+
+#endif /* nsCAppLoop_h__ */

mozilla/xpcom/appshell/eventloop/photon/nsCBreathLoop.h

@@ -0,0 +1,44 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#ifndef nsCBreathLoop_h__
+#define nsCBreathLoop_h__
+
+#include "nsCBaseBreathLoop.h"
+
+class nsCBreathLoop : public nsCBaseBreathLoop 
+{
+public:
+	static NS_METHOD Create(nsISupports* aOuter, const nsIID& aIID, void** ppv);
+
+protected:
+	nsCBreathLoop();
+	virtual ~nsCBreathLoop();
+
+	// Internal Platform Implementations of nsIEventLoop 
+	// (Error checking is ensured above)
+	nsresult PlatformExit(PRInt32 exitCode);
+
+	PRInt32 PlatformGetReturnCode(void* platformEventData);
+};
+
+#endif /* nsCBreathLoop_h__ */

mozilla/xpcom/appshell/eventloop/photon/nsCEvent.cpp

@@ -0,0 +1,103 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ *   Jerry Kirk    <Jerry.Kirk@NexwareCorp.com>
+ */
+
+#include "nsCRT.h"
+#include "nsCEvent.h"
+
+#include <prlog.h>
+PRLogModuleInfo  *PhEventLog =  PR_NewLogModule("PhEventLog");
+
+#include "nsPhEventLog.h"
+
+//*****************************************************************************
+//***    nsCEvent: Object Management
+//*****************************************************************************
+
+nsCEvent::nsCEvent(void* platformEventData)
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCEvent::nsCEvent platformEventData=<%p>\n", platformEventData));
+  
+	NS_INIT_REFCNT();
+	m_msg = new nsCPhEvent( (PhEvent_t *) platformEventData);
+}
+
+nsCEvent::~nsCEvent()
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCEvent::~nsCEvent\n"));
+
+  if (m_msg)
+  {
+	delete m_msg;
+  }	
+}
+
+//*****************************************************************************
+// nsCEvent::nsISupports
+//*****************************************************************************   
+
+NS_IMPL_ISUPPORTS1(nsCEvent, nsIEvent)
+
+//*****************************************************************************
+// nsCEvent::nsIEvent
+//*****************************************************************************   
+
+NS_IMETHODIMP nsCEvent::GetNativeData(nsNativeEventDataType dataType, 
+	void** data)
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCEvent::GetNativeData dataType=<%d> data=<%p>\n", dataType, data));
+
+
+	NS_ENSURE_ARG(nsNativeEventDataTypes::PhotonMsgStruct == dataType);
+	NS_ENSURE_ARG_POINTER(data);
+
+	*data = m_msg;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEvent::SetNativeData(nsNativeEventDataType dataType,
+	void* data)
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCEvent::SetNativeData dataType=<%d>\n", dataType));
+
+	NS_ENSURE_ARG(nsNativeEventDataTypes::PhotonMsgStruct == dataType);
+
+	if(!data)
+	{
+		/* Get rid of the Event */
+		if (m_msg)
+		  delete m_msg;
+	     m_msg = new nsCPhEvent(NULL);
+	}
+	else
+	{
+		/* Get rid of the Event */
+		if (m_msg)
+		  delete m_msg;
+
+		nsCPhEvent *aEvent = (nsCPhEvent *) data;
+        m_msg = new nsCPhEvent(aEvent->m_msg);
+ 	}
+
+	return NS_OK;
+}
+	

mozilla/xpcom/appshell/eventloop/photon/nsCEvent.h

@@ -0,0 +1,46 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ *   Jerry Kirk    <Jerry.Kirk@NexwareCorp.com>
+ */
+
+#ifndef nsCEvent_h__
+#define nsCEvent_h__
+
+#include "nsCPhEvent.h"
+#include "nsIEvent.h"
+
+class nsCEvent : public nsIEvent
+{
+public:
+	nsCEvent(void* platformEventData=nsnull);
+	
+	NS_DECL_ISUPPORTS
+
+	NS_DECL_NSIEVENT
+	 
+protected:
+	virtual ~nsCEvent();
+
+protected:
+	nsCPhEvent *m_msg;
+};
+
+#endif /* nsCEvent_h__ */

mozilla/xpcom/appshell/eventloop/photon/nsCEventFilter.cpp

@@ -0,0 +1,78 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ *   Jerry Kirk    <Jerry.Kirk@NexwareCorp.com>
+ */
+
+#include "nsCRT.h"
+
+#include "nsCEventFilter.h"
+
+//*****************************************************************************
+//***    nsCEventFilter: Object Management
+//*****************************************************************************
+
+nsCEventFilter::nsCEventFilter(void* platformFilterData)
+{
+	NS_INIT_REFCNT();
+
+	if(platformFilterData)
+		nsCRT::memcpy(&m_filter, platformFilterData, sizeof(m_filter));
+	else
+		nsCRT::memset(&m_filter, 0, sizeof(m_filter));
+}
+
+nsCEventFilter::~nsCEventFilter()
+{
+}
+
+//*****************************************************************************
+// nsCEventFilter::nsISupports
+//*****************************************************************************   
+
+NS_IMPL_ISUPPORTS1(nsCEventFilter, nsIEventFilter)
+
+//*****************************************************************************
+// nsCEventFilter::nsIEventFilter
+//*****************************************************************************   
+
+NS_IMETHODIMP nsCEventFilter::GetNativeData(nsNativeFilterDataType dataType, 
+	void** data)
+{
+	NS_ENSURE_ARG(nsNativeFilterDataTypes::PhotonFilter == dataType);
+	NS_ENSURE_ARG_POINTER(data);
+
+	*data = &m_filter;
+
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEventFilter::SetNativeData(nsNativeFilterDataType dataType,
+	void* data)
+{
+	NS_ENSURE_ARG(nsNativeFilterDataTypes::PhotonFilter == dataType);
+
+	if(!data)
+		nsCRT::memset(&m_filter, 0, sizeof(m_filter));
+	else
+		nsCRT::memcpy(&m_filter, data, sizeof(m_filter));
+
+	return NS_OK;
+}

mozilla/xpcom/appshell/eventloop/photon/nsCEventFilter.h

@@ -0,0 +1,46 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ *   Jerry Kirk    <Jerry.Kirk@NexwareCorp.com>
+ */
+
+#ifndef nsCEventFilter_h__
+#define nsCEventFilter_h__
+
+#include "nsIEventFilter.h"
+#include "nsCPhFilter.h"
+
+class nsCEventFilter : public nsIEventFilter
+{
+public:
+	nsCEventFilter(void* platformFilterData=nsnull);
+	
+	NS_DECL_ISUPPORTS
+
+	NS_DECL_NSIEVENTFILTER
+
+protected:
+	virtual ~nsCEventFilter();
+
+protected:
+	nsCPhFilter	m_filter;
+};
+
+#endif /* nsCEventFilter_h__ */

mozilla/xpcom/appshell/eventloop/photon/nsCPhEvent.cpp

@@ -0,0 +1,89 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Jerry Kirk    <Jerry.Kirk@NexwareCorp.com>
+ */
+
+#include "nsCRT.h"
+#include "nsCPhEvent.h"
+
+#include "nsPhEventLog.h"
+
+//*****************************************************************************
+//***    nsCPhEvent: Object Management
+//*****************************************************************************
+
+nsCPhEvent::nsCPhEvent(PhEvent_t* platformEventData)
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPhEvent::nsCPhEvent platformEventData=<%p>\n", platformEventData));
+  
+	if (platformEventData)
+	{
+		mEventBufferSz = PhGetMsgSize ( platformEventData );
+		m_msg = (PhEvent_t *) malloc( mEventBufferSz );
+		if (m_msg);
+		  nsCRT::memcpy(m_msg, platformEventData, mEventBufferSz);
+	}
+	else
+	{
+		mEventBufferSz = sizeof(PhEvent_t);
+		m_msg = (PhEvent_t *) malloc( mEventBufferSz );
+		if (m_msg);
+		  nsCRT::memset(m_msg, 0, mEventBufferSz);
+	}
+}
+
+nsCPhEvent::~nsCPhEvent()
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPhEvent::~nsCPhEvent\n"));
+
+  if (m_msg)
+  {
+    free(m_msg);
+    m_msg = nsnull;
+    mEventBufferSz = 0;
+  }	
+}
+
+unsigned long nsCPhEvent::GetEventBufferSize()
+{
+	return mEventBufferSz;
+}
+
+unsigned long nsCPhEvent::GetEventSize()
+{
+  unsigned long theEventSize = 0;
+  if (m_msg)
+  	theEventSize = PhGetMsgSize ( (PhEvent_t *) m_msg );
+
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPhEvent::GetEventSize theEventSize=<%d>\n", theEventSize));
+
+  return theEventSize;
+}
+
+nsresult nsCPhEvent::ResizeEvent(unsigned long aEventSize)
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPhEvent::ResizeEvent old_size=<%d> new_size=<%d>\n", mEventBufferSz, aEventSize));
+
+  mEventBufferSz = aEventSize;
+  m_msg = (PhEvent_t *) realloc( m_msg, mEventBufferSz );
+  NS_ENSURE_ARG_POINTER(m_msg);
+  return NS_OK;
+}
+	

mozilla/xpcom/appshell/eventloop/photon/nsCPhEvent.h

@@ -0,0 +1,43 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Jerry Kirk    <Jerry.Kirk@NexwareCorp.com>
+ */
+
+#ifndef nsCPhEvent_h__
+#define nsCPhEvent_h__
+
+#include "PhT.h"
+
+class nsCPhEvent
+{
+public:
+    nsCPhEvent(PhEvent_t *platformEventData=nsnull);
+	virtual ~nsCPhEvent();
+
+    unsigned long GetEventBufferSize();
+    unsigned long GetEventSize();
+    nsresult ResizeEvent(unsigned long aEventSize);
+	 
+public:
+	PhEvent_t      *m_msg;
+    unsigned long   mEventBufferSz;
+};
+
+#endif /* nsCPhEvent_h__ */

mozilla/xpcom/appshell/eventloop/photon/nsCPhFilter.h

@@ -0,0 +1,38 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ *   Jerry Kirk    <Jerry.Kirk@NexwareCorp.com>
+ */
+
+#ifndef nsCPhFilter_h__
+#define nsCPhFilter_h__
+
+//#include "PhT.h"
+
+class nsCPhFilter
+{
+public:
+//	HWND hWnd;
+//	UINT wMsgFilterMin;
+//	UINT wMsgFilterMax;
+//	UINT wRemoveFlags;	// fRemoveEvent flag passed to PeekEvent takes precedent
+};								// over PM_NOREMOVE and PM_REMOVE.
+
+#endif /* nsPhFilter_h__ */

mozilla/xpcom/appshell/eventloop/photon/nsCPlatformBaseLoop.cpp

@@ -0,0 +1,188 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ *   Jerry Kirk    <Jerry.Kirk@NexwareCorp.com>
+ */
+
+#include "nsCPlatformBaseLoop.h"
+#include "nsCPhEvent.h"
+#include "nsCPhFilter.h"
+
+#include "nsPhEventLog.h"
+#include <Pt.h>
+
+//*****************************************************************************
+//***    nsCPlatformBaseLoop: Object Management
+//*****************************************************************************
+
+nsCPlatformBaseLoop::nsCPlatformBaseLoop(nsEventLoopType type) : 
+	nsCBaseLoop(type)
+{
+	m_PhThreadId = pthread_self();
+
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPlatformBaseLoop::nsCPlatformBaseLoop nsEventLoopType=<%d> m_PhThreadId=<%d>\n", type, m_PhThreadId)); 
+}
+
+nsCPlatformBaseLoop::~nsCPlatformBaseLoop()
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPlatformBaseLoop::~nsCPlatformBaseLoop m_PhThreadId=<%d>\n", m_PhThreadId)); 
+}
+
+//*****************************************************************************
+// nsCPlatformBaseLoop:: Internal Platform Implementations of nsIEventLoop 
+//							(Error checking is ensured above)
+//*****************************************************************************   
+
+nsresult nsCPlatformBaseLoop::PlatformGetNextEvent(void* platformFilterData, 
+	void* platformEventData)
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPlatformBaseLoop::PlatformGetNextEvent platformFilterData=<%p>  platformEventData=<%p>\n", platformFilterData, platformEventData)); 
+
+	nsCPhFilter* filter=(nsCPhFilter*)platformFilterData;
+	nsCPhEvent* pEvent = (nsCPhEvent*) platformEventData;
+    PRBool done = PR_FALSE;
+
+	if(filter != NULL)
+    {
+      PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPlatformBaseLoop::PlatformGetNextEvent Filters not supported\n"));
+
+	  return NS_COMFALSE;
+	}
+	  	
+    while(!done)
+	{
+      switch( PhEventNext(pEvent->m_msg, pEvent->GetEventBufferSize()))
+  	  {
+ 	  case Ph_EVENT_MSG:
+        PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPlatformBaseLoop::PlatformGetNextEvent GetMessage\n"));
+		done = PR_TRUE;
+		break;
+      case Ph_RESIZE_MSG:
+        PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPlatformBaseLoop::PlatformGetNextEvent Resize Message from <%d> to <%d>\n", pEvent->GetEventBufferSize(), pEvent->GetEventSize()));
+		pEvent->ResizeEvent(pEvent->GetEventSize());
+		break;
+	  }
+	}
+	
+	return  NS_OK; 
+}
+
+nsresult nsCPlatformBaseLoop::PlatformPeekNextEvent(void* platformFilterData, 
+	void* platformEventData, PRBool fRemoveEvent)
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPlatformBaseLoop::PlatformPeekNextEvent platformFilterData=<%p>  platformEventData=<%p> fRemoveEvent=<%d>\n", platformFilterData, platformEventData, fRemoveEvent)); 
+
+	if(fRemoveEvent == PR_FALSE)
+    {
+      PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPlatformBaseLoop::PlatformPeekNextEvent Leaving the element on the queue is not supported\n"));
+	  return NS_COMFALSE;
+	}
+		  
+#if 0
+	nsCWinFilter* filter=(nsCWinFilter*)platformFilterData;
+	MSG* pMsg=(MSG*)platformEventData;
+	
+	if(fRemoveEvent)
+		filter->wRemoveFlags|= PM_REMOVE;
+	else
+		filter->wRemoveFlags&= ~PM_REMOVE;
+	if(::PeekMessage(pMsg, filter->hWnd, filter->wMsgFilterMin, 
+		filter->wMsgFilterMax, filter->wRemoveFlags))
+		return NS_OK;
+#endif
+	return NS_COMFALSE;
+}
+
+nsresult nsCPlatformBaseLoop::PlatformTranslateEvent(void* platformEventData)
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPlatformBaseLoop::PlatformTranslateEvent platformEventData=<%p>\n", platformEventData)); 
+
+#if 0
+	MSG* pMsg=(MSG*)platformEventData;
+	::TranslateMessage(pMsg);
+#endif
+
+	return NS_OK;
+}
+
+nsresult nsCPlatformBaseLoop::PlatformDispatchEvent(void* platformEventData)
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPlatformBaseLoop::PlatformDispatchEvent platformEventData=<%p>\n", platformEventData)); 
+
+#if 0
+	MSG* pMsg=(MSG*)platformEventData;
+	::DispatchMessage(pMsg);
+#endif
+
+	return NS_OK;
+}
+
+nsresult nsCPlatformBaseLoop::PlatformSendLoopEvent(void* platformEventData, PRInt32* result)
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPlatformBaseLoop::PlatformSendLoopEvent platformEventData=<%p>\n", platformEventData)); 
+
+#if 0
+	MSG* pMsg=(MSG*)platformEventData;
+	*result = ::SendMessage(pMsg->hwnd, pMsg->message, pMsg->wParam,pMsg->lParam);
+#endif
+
+	return NS_OK;
+}
+
+nsresult nsCPlatformBaseLoop::PlatformPostLoopEvent(void* platformEventData)
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPlatformBaseLoop::PlatformPostLoopEvent platformEventData=<%p>\n", platformEventData)); 
+
+#if 0
+	MSG* pMsg=(MSG*)platformEventData;
+	if(!pMsg->hwnd)
+		{
+		if(!::PostThreadMessage(m_WinThreadId, pMsg->message, pMsg->wParam,
+			pMsg->lParam))
+			return NS_ERROR_FAILURE;
+		}
+	else if(!::PostMessage(pMsg->hwnd, pMsg->message, pMsg->wParam, pMsg->lParam))
+		return NS_ERROR_FAILURE;
+#endif
+
+	return NS_OK;
+}
+
+nsNativeEventDataType nsCPlatformBaseLoop::PlatformGetEventType()
+{
+	return nsNativeEventDataTypes::PhotonMsgStruct;
+}
+
+nsNativeEventDataType nsCPlatformBaseLoop::PlatformGetFilterType()
+{
+	return nsNativeFilterDataTypes::PhotonFilter;
+}
+
+PRInt32 nsCPlatformBaseLoop::PlatformGetReturnCode(void* platformEventData)
+{
+  PR_LOG(PhEventLog, PR_LOG_DEBUG, ("nsCPlatformBaseLoop::PlatformGetReturnCode platformEventData=<%p>\n", platformEventData)); 
+
+#if 0
+	MSG* pMsg=(MSG*)platformEventData;
+	return pMsg->wParam;
+#endif
+
+    return -1;
+}

mozilla/xpcom/appshell/eventloop/photon/nsCPlatformBaseLoop.h

@@ -0,0 +1,57 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ *   Jerry Kirk    <Jerry.Kirk@NexwareCorp.com>
+ */
+
+#ifndef nsCPlatformBaseLoop_h__
+#define nsCPlatformBaseLoop_h__
+
+#include "PhT.h"
+
+#include "nsCBaseLoop.h"
+
+class nsCPlatformBaseLoop : public nsCBaseLoop 
+{
+protected:
+	nsCPlatformBaseLoop(nsEventLoopType type);
+	virtual ~nsCPlatformBaseLoop();
+
+	// Internal Platform Implementations of nsIEventLoop 
+	// (Error checking is ensured above)
+	// We can over-ride these at a high level because they are the same
+	// across all types of event loops.
+	nsresult PlatformGetNextEvent(void* platformFilterData, void* platformEventData);
+	nsresult PlatformPeekNextEvent(void* FilterData, void* platformEventData, 
+		PRBool fRemoveElement);
+	nsresult PlatformTranslateEvent(void* platformEventData);
+	nsresult PlatformDispatchEvent(void* platformEventData);
+	nsresult PlatformSendLoopEvent(void* platformEventData, PRInt32* result);
+	nsresult PlatformPostLoopEvent(void* platformEventData);
+	
+	nsNativeEventDataType PlatformGetEventType();
+	nsNativeFilterDataType PlatformGetFilterType();
+	PRInt32 PlatformGetReturnCode(void* platformEventData);
+	
+protected:
+	pthread_t m_PhThreadId;
+};
+
+#endif /* nsCAppLoop_h__ */

mozilla/xpcom/appshell/eventloop/photon/nsCThreadLoop.h

@@ -0,0 +1,44 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#ifndef nsCThreadLoop_h__
+#define nsCThreadLoop_h__
+
+#include "nsCBaseThreadLoop.h"
+
+class nsCThreadLoop : public nsCBaseThreadLoop 
+{
+public:
+	static NS_METHOD Create(nsISupports* aOuter, const nsIID& aIID, void** ppv);
+
+protected:
+	nsCThreadLoop();
+	virtual ~nsCThreadLoop();
+
+	// Internal Platform Implementations of nsIEventLoop 
+	// (Error checking is ensured above)
+	nsresult PlatformExit(PRInt32 exitCode);
+
+protected:
+};
+
+#endif /* nsCThreadLoop_h__ */

mozilla/xpcom/appshell/eventloop/photon/nsIPhEvent.idl

@@ -0,0 +1,12 @@
+#include "nsISupports.idl"
+#include "nsIEvent.idl"
+
+/**
+ * The nsIPhEvent defines what a message looks like on the Photon Platform.    
+ */						  
+
+[scriptable, uuid(2EFB5005-4508-11d3-AEDA-00A024FFC08C)]
+interface nsIPhEvent : nsIEvent
+{
+	//XXX Place the contents of a Photon PhEvent_t struct here.
+};

mozilla/xpcom/appshell/eventloop/photon/nsIPhEventFilter.idl

@@ -0,0 +1,14 @@
+#include "nsISupports.idl"
+#include "nsIEventFilter.idl"
+
+/**
+ * The nsIPhEventFilter defines what a message filter looks like on the Photon 
+ * Platform.    
+ */						  
+
+[scriptable, uuid(2EFB5006-4508-11d3-AEDA-00A024FFC08C)]
+interface nsIPhEventFilter : nsIEventFilter
+{
+	//XXX Place the contents of a Photon PhEvent_t struct here.
+	//As well as other needed filtering criteria.
+};

mozilla/xpcom/appshell/eventloop/photon/nsPhEventLog.h

@@ -0,0 +1,29 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ */
+ 
+/*
+ * Used for Logging in the xpcom/appshell/eventloop/photon directory.
+ */ 
+
+#include <prlog.h>
+
+extern PRLogModuleInfo *PhEventLog;

mozilla/xpcom/appshell/eventloop/windows/makefile.win

@@ -0,0 +1,62 @@
+#!nmake
+# 
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/MPL/
+# 
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+# 
+# The Original Code is the Mozilla browser.
+# 
+# The Initial Developer of the Original Code is Netscape
+# Communications, Inc.  Portions created by Netscape are
+# Copyright (C) 1999, Mozilla.  All Rights Reserved.
+# 
+# Contributor(s):
+#   Travis Bogard <travis@netscape.com>
+
+
+DEPTH=..\..\..\..
+MODULE=xpcom_eventloop_windows
+
+MAKE_OBJ_TYPE=DLL
+DLLNAME=evntloop
+DLL=.\$(OBJDIR)\$(DLLNAME).dll
+
+XPIDLSRCS=									\
+		.\nsIWinEvent.idl					\
+		.\nsIWinEventFilter.idl			\
+		$(NULL)
+
+CPP_OBJS=												\
+		.\..\xp\$(OBJDIR)\nsCLoopModule.obj		\
+		.\..\xp\$(OBJDIR)\nsCBaseLoop.obj		\
+		.\..\xp\$(OBJDIR)\nsCBaseAppLoop.obj	\
+		.\..\xp\$(OBJDIR)\nsCBaseBreathLoop.obj	\
+		.\..\xp\$(OBJDIR)\nsCBaseThreadLoop.obj	\
+		.\$(OBJDIR)\nsCPlatformBaseLoop.obj			\
+		.\$(OBJDIR)\nsCEvent.obj					\
+		.\$(OBJDIR)\nsCEventFilter.obj			\
+		.\$(OBJDIR)\nsCAppLoop.obj					\
+		.\$(OBJDIR)\nsCThreadLoop.obj				\
+		.\$(OBJDIR)\nsCBreathLoop.obj				\
+		$(NULL)
+
+LLIBS=												\
+        $(DIST)\lib\xpcom.lib					\
+        $(LIBNSPR)
+		  
+LINCS=												\
+			-I..\xp										\
+			$(NULL)  
+
+include <$(DEPTH)\config\config.mak>
+include <$(DEPTH)\config\rules.mak>
+
+install:: $(DLL)
+	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).dll $(DIST)\bin\components
+	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).lib $(DIST)\lib

mozilla/xpcom/appshell/eventloop/windows/nsCAppLoop.cpp

@@ -0,0 +1,62 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#include "nsCAppLoop.h"
+#include "nsCWinFilter.h"
+
+//*****************************************************************************
+//***    nsCAppLoop: Object Management
+//*****************************************************************************
+
+nsCAppLoop::nsCAppLoop() : nsCBaseAppLoop()
+{
+}
+
+nsCAppLoop::~nsCAppLoop()
+{
+}
+
+NS_METHOD nsCAppLoop::Create(nsISupports* aOuter, const nsIID& aIID, 
+	void** ppv)
+{
+	NS_ENSURE_ARG_POINTER(ppv);
+	NS_ENSURE_NO_AGGREGATION(aOuter);
+
+	nsCAppLoop* app = new nsCAppLoop();
+	NS_ENSURE_TRUE(app, NS_ERROR_OUT_OF_MEMORY);
+
+	NS_ADDREF(app);
+	nsresult rv = app->QueryInterface(aIID, ppv);
+	NS_RELEASE(app);
+	return rv;
+}
+
+//*****************************************************************************
+// nsCAppLoop:: Internal Platform Implementations of nsIEventLoop 
+//							(Error checking is ensured above)
+//*****************************************************************************   
+
+nsresult nsCAppLoop::PlatformExit(PRInt32 exitCode)
+{
+	PostQuitMessage(exitCode);
+	return NS_OK;
+}

mozilla/xpcom/appshell/eventloop/windows/nsCAppLoop.h

@@ -0,0 +1,44 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#ifndef nsCAppLoop_h__
+#define nsCAppLoop_h__
+
+#include "windows.h"
+
+#include "nsCBaseAppLoop.h"
+
+class nsCAppLoop : public nsCBaseAppLoop 
+{
+public:
+	static NS_METHOD Create(nsISupports* aOuter, const nsIID& aIID, void** ppv);
+
+protected:
+	nsCAppLoop();
+	virtual ~nsCAppLoop();
+
+	// Internal Platform Implementations of nsIEventLoop 
+	// (Error checking is ensured above)
+	nsresult PlatformExit(PRInt32 exitCode);
+};
+
+#endif /* nsCAppLoop_h__ */

mozilla/xpcom/appshell/eventloop/windows/nsCBreathLoop.cpp

@@ -0,0 +1,80 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#include "nsCBreathLoop.h"
+#include "nsCWinFilter.h"
+
+//*****************************************************************************
+//***    nsCBreathLoop: Object Management
+//*****************************************************************************
+
+nsCBreathLoop::nsCBreathLoop() : nsCBaseBreathLoop()
+{
+}
+
+nsCBreathLoop::~nsCBreathLoop()
+{
+}
+
+NS_METHOD nsCBreathLoop::Create(nsISupports* aOuter, const nsIID& aIID, 
+	void** ppv)
+{
+	NS_ENSURE_ARG_POINTER(ppv);
+	NS_ENSURE_NO_AGGREGATION(aOuter);
+
+	nsCBreathLoop* app = new nsCBreathLoop();
+	NS_ENSURE_TRUE(app, NS_ERROR_OUT_OF_MEMORY);
+
+	NS_ADDREF(app);
+	nsresult rv = app->QueryInterface(aIID, ppv);
+	NS_RELEASE(app);
+	return rv;
+}
+
+//*****************************************************************************
+// nsCBreathLoop:: Internal Platform Implementations of nsIEventLoop 
+//							(Error checking is ensured above)
+//*****************************************************************************   
+
+nsresult nsCBreathLoop::PlatformExit(PRInt32 exitCode)
+{
+	// XXX Not sure we can force PeekMessage out....
+	return NS_OK;
+}
+
+PRInt32 nsCBreathLoop::PlatformGetReturnCode(void* platformEventData)
+{
+	return 0;
+}
+
+nsresult nsCBreathLoop::PlatformRetrieveNextEvent(void* platformFilterData,
+	void* platformEventData)
+{
+	nsCWinFilter* filter=(nsCWinFilter*)platformFilterData;
+	MSG* pMsg=(MSG*)platformEventData;
+	
+	filter->wRemoveFlags|= PM_REMOVE;
+	if(::PeekMessage(pMsg, filter->hWnd, filter->wMsgFilterMin, 
+		filter->wMsgFilterMax, filter->wRemoveFlags))
+		return NS_OK;
+	return NS_COMFALSE;
+}

mozilla/xpcom/appshell/eventloop/windows/nsCBreathLoop.h

@@ -0,0 +1,48 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#ifndef nsCBreathLoop_h__
+#define nsCBreathLoop_h__
+
+#include "windows.h"
+
+#include "nsCBaseBreathLoop.h"
+
+class nsCBreathLoop : public nsCBaseBreathLoop 
+{
+public:
+	static NS_METHOD Create(nsISupports* aOuter, const nsIID& aIID, void** ppv);
+
+protected:
+	nsCBreathLoop();
+	virtual ~nsCBreathLoop();
+
+	// Internal Platform Implementations of nsIEventLoop 
+	// (Error checking is ensured above)
+	nsresult PlatformExit(PRInt32 exitCode);
+
+	PRInt32 PlatformGetReturnCode(void* platformEventData);
+	nsresult PlatformRetrieveNextEvent(void* platformFilterData, 
+		void* platformEventData);
+};
+
+#endif /* nsCBreathLoop_h__ */

mozilla/xpcom/appshell/eventloop/windows/nsCEvent.cpp

@@ -0,0 +1,180 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#include "nsCRT.h"
+
+#include "nsCEvent.h"
+
+//*****************************************************************************
+//***    nsCEvent: Object Management
+//*****************************************************************************
+
+nsCEvent::nsCEvent(void* platformEventData)
+{
+	NS_INIT_REFCNT();
+
+	if(platformEventData)
+		nsCRT::memcpy(&m_msg, platformEventData, sizeof(m_msg));
+	else
+		nsCRT::memset(&m_msg, 0, sizeof(m_msg));
+}
+
+nsCEvent::~nsCEvent()
+{
+}
+
+//*****************************************************************************
+// nsCEvent::nsISupports
+//*****************************************************************************   
+
+NS_IMPL_ISUPPORTS2(nsCEvent, nsIEvent, nsIWinEvent)
+
+//*****************************************************************************
+// nsCEvent::nsIEvent
+//*****************************************************************************   
+
+NS_IMETHODIMP nsCEvent::GetNativeData(nsNativeEventDataType dataType, 
+	void** data)
+{
+	NS_ENSURE_ARG(nsNativeEventDataTypes::WinMsgStruct == dataType);
+	NS_ENSURE_ARG_POINTER(data);
+
+	*data = &m_msg;
+
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEvent::SetNativeData(nsNativeEventDataType dataType,
+	void* data)
+{
+	NS_ENSURE_ARG(nsNativeEventDataTypes::WinMsgStruct == dataType);
+
+	if(!data)
+		nsCRT::memset(&m_msg, 0, sizeof(m_msg));
+	else
+		nsCRT::memcpy(&m_msg, data, sizeof(m_msg));
+
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEvent::GetIsExitEvent(PRBool* aIsExitEvent)
+{
+	NS_ENSURE_ARG_POINTER(aIsExitEvent);
+
+	*aIsExitEvent = m_msg.message == WM_QUIT ? PR_TRUE : PR_FALSE;
+
+	return NS_OK;
+}
+//*****************************************************************************
+// nsCEvent::nsIWinEvent
+//*****************************************************************************   
+
+NS_IMETHODIMP nsCEvent::GetHwnd(void** aHwnd)
+{
+	NS_ENSURE_ARG_POINTER(aHwnd);
+	*aHwnd = m_msg.hwnd;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEvent::SetHwnd(void* aHwnd)
+{
+	m_msg.hwnd = (HWND)aHwnd;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEvent::GetMessage(PRUint32*	aMessage)
+{
+	NS_ENSURE_ARG_POINTER(aMessage);
+	*aMessage = m_msg.message;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEvent::SetMessage(PRUint32 aMessage)
+{
+	m_msg.message = aMessage;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEvent::GetWParam(PRUint32* aWParam)
+{
+	NS_ENSURE_ARG_POINTER(aWParam);
+	*aWParam = m_msg.wParam;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEvent::SetWParam(PRUint32 aWParam)
+{
+	m_msg.wParam = aWParam;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEvent::GetLParam(PRUint32* aLParam)
+{
+	NS_ENSURE_ARG_POINTER(aLParam);
+	*aLParam = m_msg.lParam;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEvent::SetLParam(PRUint32 aLParam)
+{
+	m_msg.lParam = aLParam;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEvent::GetTime(PRUint32* aTime)
+{
+	NS_ENSURE_ARG_POINTER(aTime);
+	*aTime = m_msg.time;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEvent::SetTime(PRUint32 aTime)
+{
+	m_msg.time = aTime;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEvent::GetPointX(PRInt32* aPointX)
+{
+	NS_ENSURE_ARG_POINTER(aPointX);
+	*aPointX = m_msg.pt.x;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEvent::SetPointX(PRInt32 aPointX)
+{
+	m_msg.pt.x = aPointX;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEvent::GetPointY(PRInt32* aPointY)
+{
+	NS_ENSURE_ARG_POINTER(aPointY);
+	*aPointY = m_msg.pt.y;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEvent::SetPointY(PRInt32 aPointY)
+{
+	m_msg.pt.y = aPointY;
+	return NS_OK;
+}

mozilla/xpcom/appshell/eventloop/windows/nsCEvent.h

@@ -0,0 +1,46 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#ifndef nsCEvent_h__
+#define nsCEvent_h__
+
+#include "windows.h"
+#include "nsIWinEvent.h"
+
+class nsCEvent : public nsIWinEvent
+{
+public:
+	nsCEvent(void* platformEventData=nsnull);
+	
+	NS_DECL_ISUPPORTS
+
+	NS_DECL_NSIEVENT
+	NS_DECL_NSIWINEVENT
+
+protected:
+	virtual ~nsCEvent();
+
+protected:
+	MSG	m_msg;
+};
+
+#endif /* nsCEvent_h__ */

mozilla/xpcom/appshell/eventloop/windows/nsCEventFilter.cpp

@@ -0,0 +1,133 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#include "nsCRT.h"
+
+#include "nsCEventFilter.h"
+
+//*****************************************************************************
+//***    nsCEventFilter: Object Management
+//*****************************************************************************
+
+nsCEventFilter::nsCEventFilter(void* platformFilterData)
+{
+	NS_INIT_REFCNT();
+
+	if(platformFilterData)
+		nsCRT::memcpy(&m_filter, platformFilterData, sizeof(m_filter));
+	else
+		nsCRT::memset(&m_filter, 0, sizeof(m_filter));
+}
+
+nsCEventFilter::~nsCEventFilter()
+{
+}
+
+//*****************************************************************************
+// nsCEventFilter::nsISupports
+//*****************************************************************************   
+
+NS_IMPL_ISUPPORTS2(nsCEventFilter, nsIEventFilter, nsIWinEventFilter)
+
+//*****************************************************************************
+// nsCEventFilter::nsIEventFilter
+//*****************************************************************************   
+
+NS_IMETHODIMP nsCEventFilter::GetNativeData(nsNativeFilterDataType dataType, 
+	void** data)
+{
+	NS_ENSURE_ARG(nsNativeFilterDataTypes::WinFilter == dataType);
+	NS_ENSURE_ARG_POINTER(data);
+
+	*data = &m_filter;
+
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEventFilter::SetNativeData(nsNativeFilterDataType dataType,
+	void* data)
+{
+	NS_ENSURE_ARG(nsNativeFilterDataTypes::WinFilter == dataType);
+
+	if(!data)
+		nsCRT::memset(&m_filter, 0, sizeof(m_filter));
+	else
+		nsCRT::memcpy(&m_filter, data, sizeof(m_filter));
+
+	return NS_OK;
+}
+
+//*****************************************************************************
+// nsCEventFilter::nsIEventFilter
+//*****************************************************************************   
+
+NS_IMETHODIMP nsCEventFilter::GetHwnd(void** aHwnd)
+{
+	NS_ENSURE_ARG_POINTER(aHwnd);
+	*aHwnd = m_filter.hWnd;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEventFilter::SetHwnd(void* aHwnd)
+{
+	m_filter.hWnd = (HWND)aHwnd;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEventFilter::GetMsgFilterMin(PRUint32* aMsgFilterMin)
+{
+	NS_ENSURE_ARG_POINTER(aMsgFilterMin);
+	*aMsgFilterMin = m_filter.wMsgFilterMin;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEventFilter::SetMsgFilterMin(PRUint32 aMsgFilterMin)
+{
+	m_filter.wMsgFilterMin = aMsgFilterMin;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEventFilter::GetMsgFilterMax(PRUint32* aMsgFilterMax)
+{
+	NS_ENSURE_ARG_POINTER(aMsgFilterMax);
+	*aMsgFilterMax = m_filter.wMsgFilterMax;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEventFilter::SetMsgFilterMax(PRUint32 aMsgFilterMax)
+{
+	m_filter.wMsgFilterMax = aMsgFilterMax;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEventFilter::GetRemoveFlags(PRUint32* aRemoveFlags)
+{
+	NS_ENSURE_ARG_POINTER(aRemoveFlags);
+	*aRemoveFlags = m_filter.wRemoveFlags;
+	return NS_OK;
+}
+
+NS_IMETHODIMP nsCEventFilter::SetRemoveFlags(PRUint32 aRemoveFlags)
+{
+	m_filter.wRemoveFlags = aRemoveFlags;
+	return NS_OK;
+}

mozilla/xpcom/appshell/eventloop/windows/nsCEventFilter.h

@@ -0,0 +1,47 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#ifndef nsCEventFilter_h__
+#define nsCEventFilter_h__
+
+#include "windows.h"
+#include "nsIWinEventFilter.h"
+#include "nsCWinFilter.h"
+
+class nsCEventFilter : public nsIWinEventFilter
+{
+public:
+	nsCEventFilter(void* platformFilterData=nsnull);
+	
+	NS_DECL_ISUPPORTS
+
+	NS_DECL_NSIEVENTFILTER
+	NS_DECL_NSIWINEVENTFILTER
+
+protected:
+	virtual ~nsCEventFilter();
+
+protected:
+	nsCWinFilter	m_filter;
+};
+
+#endif /* nsCEventFilter_h__ */

mozilla/xpcom/appshell/eventloop/windows/nsCPlatformBaseLoop.cpp

@@ -0,0 +1,132 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#include "nsCPlatformBaseLoop.h"
+#include "nsCWinFilter.h"
+
+//*****************************************************************************
+//***    nsCPlatformBaseLoop: Object Management
+//*****************************************************************************
+
+nsCPlatformBaseLoop::nsCPlatformBaseLoop(nsEventLoopType type) : 
+	nsCBaseLoop(type)
+{
+	m_WinThreadId = ::GetCurrentThreadId();
+}
+
+nsCPlatformBaseLoop::~nsCPlatformBaseLoop()
+{
+}
+
+//*****************************************************************************
+// nsCPlatformBaseLoop:: Internal Platform Implementations of nsIEventLoop 
+//							(Error checking is ensured above)
+//*****************************************************************************   
+
+nsresult nsCPlatformBaseLoop::PlatformGetNextEvent(void* platformFilterData, 
+	void* platformEventData)
+{
+	nsCWinFilter* filter=(nsCWinFilter*)platformFilterData;
+	MSG* pMsg=(MSG*)platformEventData;
+	if(::GetMessage(pMsg, filter->hWnd, filter->wMsgFilterMin, 
+		filter->wMsgFilterMax))
+		return NS_OK;
+	return  NS_COMFALSE; 
+}
+
+nsresult nsCPlatformBaseLoop::PlatformPeekNextEvent(void* platformFilterData, 
+	void* platformEventData, PRBool fRemoveEvent)
+{
+	nsCWinFilter* filter=(nsCWinFilter*)platformFilterData;
+	MSG* pMsg=(MSG*)platformEventData;
+	
+	if(fRemoveEvent)
+		filter->wRemoveFlags|= PM_REMOVE;
+	else
+		filter->wRemoveFlags&= ~PM_REMOVE;
+	if(::PeekMessage(pMsg, filter->hWnd, filter->wMsgFilterMin, 
+		filter->wMsgFilterMax, filter->wRemoveFlags))
+		return NS_OK;
+	return NS_COMFALSE;
+}
+
+nsresult nsCPlatformBaseLoop::PlatformTranslateEvent(void* platformEventData)
+{
+	MSG* pMsg=(MSG*)platformEventData;
+	::TranslateMessage(pMsg);
+	return NS_OK;
+}
+
+nsresult nsCPlatformBaseLoop::PlatformDispatchEvent(void* platformEventData)
+{
+	MSG* pMsg=(MSG*)platformEventData;
+	::DispatchMessage(pMsg);
+	return NS_OK;
+}
+
+nsresult nsCPlatformBaseLoop::PlatformSendLoopEvent(void* platformEventData, PRInt32* result)
+{
+	MSG* pMsg=(MSG*)platformEventData;
+	*result = ::SendMessage(pMsg->hwnd, pMsg->message, pMsg->wParam,pMsg->lParam);
+	return NS_OK;
+}
+
+nsresult nsCPlatformBaseLoop::PlatformPostLoopEvent(void* platformEventData)
+{
+	MSG* pMsg=(MSG*)platformEventData;
+	if(!pMsg->hwnd)
+		{
+		if(!::PostThreadMessage(m_WinThreadId, pMsg->message, pMsg->wParam,
+			pMsg->lParam))
+			return NS_ERROR_FAILURE;
+		}
+	else if(!::PostMessage(pMsg->hwnd, pMsg->message, pMsg->wParam, pMsg->lParam))
+		return NS_ERROR_FAILURE;
+	return NS_OK;
+}
+
+nsNativeEventDataType nsCPlatformBaseLoop::PlatformGetEventType()
+{
+	return nsNativeEventDataTypes::WinMsgStruct;
+}
+
+nsNativeEventDataType nsCPlatformBaseLoop::PlatformGetFilterType()
+{
+	return nsNativeFilterDataTypes::WinFilter;
+}
+
+PRInt32 nsCPlatformBaseLoop::PlatformGetReturnCode(void* platformEventData)
+{
+	MSG* pMsg=(MSG*)platformEventData;
+	return pMsg->wParam;
+}
+
+nsresult nsCPlatformBaseLoop::PlatformRetrieveNextEvent(void* platformFilterData,
+	void* platformEventData)
+{
+	nsCWinFilter* filter=(nsCWinFilter*)platformFilterData;
+	MSG* pMsg=(MSG*)platformEventData;
+	if(::GetMessage(pMsg, filter->hWnd, filter->wMsgFilterMin, 
+		filter->wMsgFilterMax))
+		return NS_OK;
+	return  NS_COMFALSE; 
+}

mozilla/xpcom/appshell/eventloop/windows/nsCPlatformBaseLoop.h

@@ -0,0 +1,58 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#ifndef nsCPlatformBaseLoop_h__
+#define nsCPlatformBaseLoop_h__
+
+#include "windows.h"
+
+#include "nsCBaseLoop.h"
+
+class nsCPlatformBaseLoop : public nsCBaseLoop 
+{
+protected:
+	nsCPlatformBaseLoop(nsEventLoopType type);
+	virtual ~nsCPlatformBaseLoop();
+
+	// Internal Platform Implementations of nsIEventLoop 
+	// (Error checking is ensured above)
+	// We can over-ride these at a high level because they are the same
+	// across all types of event loops.
+	nsresult PlatformGetNextEvent(void* platformFilterData, void* platformEventData);
+	nsresult PlatformPeekNextEvent(void* FilterData, void* platformEventData, 
+		PRBool fRemoveElement);
+	nsresult PlatformTranslateEvent(void* platformEventData);
+	nsresult PlatformDispatchEvent(void* platformEventData);
+	nsresult PlatformSendLoopEvent(void* platformEventData, PRInt32* result);
+	nsresult PlatformPostLoopEvent(void* platformEventData);
+	
+	nsNativeEventDataType PlatformGetEventType();
+	nsNativeFilterDataType PlatformGetFilterType();
+	PRInt32 PlatformGetReturnCode(void* platformEventData);
+	nsresult PlatformRetrieveNextEvent(void* platformFilterData, 
+		void* platformEventData);
+	
+protected:
+	DWORD m_WinThreadId;  
+};
+
+#endif /* nsCAppLoop_h__ */

mozilla/xpcom/appshell/eventloop/windows/nsCThreadLoop.cpp

@@ -0,0 +1,62 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#include "nsCThreadLoop.h"
+#include "nsCWinFilter.h"
+
+//*****************************************************************************
+//***    nsCThreadLoop: Object Management
+//*****************************************************************************
+
+nsCThreadLoop::nsCThreadLoop() : nsCBaseThreadLoop()
+{
+}
+
+nsCThreadLoop::~nsCThreadLoop()
+{
+}
+
+NS_METHOD nsCThreadLoop::Create(nsISupports* aOuter, const nsIID& aIID, 
+	void** ppv)
+{
+	NS_ENSURE_ARG_POINTER(ppv);
+	NS_ENSURE_NO_AGGREGATION(aOuter);
+
+	nsCThreadLoop* app = new nsCThreadLoop();
+	NS_ENSURE_TRUE(app, NS_ERROR_OUT_OF_MEMORY);
+
+	NS_ADDREF(app);
+	nsresult rv = app->QueryInterface(aIID, ppv);
+	NS_RELEASE(app);
+	return rv;
+}
+
+//*****************************************************************************
+// nsCThreadLoop:: Internal Platform Implementations of nsIEventLoop 
+//							(Error checking is ensured above)
+//*****************************************************************************   
+
+nsresult nsCThreadLoop::PlatformExit(PRInt32 exitCode)
+{
+	::PostThreadMessage(m_WinThreadId, WM_QUIT, 0, 0);
+	return NS_OK;
+}

mozilla/xpcom/appshell/eventloop/windows/nsCThreadLoop.h

@@ -0,0 +1,46 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#ifndef nsCThreadLoop_h__
+#define nsCThreadLoop_h__
+
+#include "windows.h"
+
+#include "nsCBaseThreadLoop.h"
+
+class nsCThreadLoop : public nsCBaseThreadLoop 
+{
+public:
+	static NS_METHOD Create(nsISupports* aOuter, const nsIID& aIID, void** ppv);
+
+protected:
+	nsCThreadLoop();
+	virtual ~nsCThreadLoop();
+
+	// Internal Platform Implementations of nsIEventLoop 
+	// (Error checking is ensured above)
+	nsresult PlatformExit(PRInt32 exitCode);
+
+protected:
+};
+
+#endif /* nsCThreadLoop_h__ */

mozilla/xpcom/appshell/eventloop/windows/nsCWinFilter.h

@@ -0,0 +1,37 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is the Mozilla browser.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications, Inc.  Portions created by Netscape are
+ * Copyright (C) 1999, Mozilla.  All Rights Reserved.
+ * 
+ * Contributor(s):
+ *   Travis Bogard <travis@netscape.com>
+ */
+
+#ifndef nsCWinFilter_h__
+#define nsCWinFilter_h__
+
+#include "windows.h"
+
+class nsCWinFilter
+{
+public:
+	HWND hWnd;
+	UINT wMsgFilterMin;
+	UINT wMsgFilterMax;
+	UINT wRemoveFlags;	// fRemoveEvent flag passed to PeekEvent takes precedent
+};								// over PM_NOREMOVE and PM_REMOVE.
+
+#endif /* nsWinFilter_h__ */

mozilla/xpcom/appshell/eventloop/windows/nsIWinEvent.idl

@@ -0,0 +1,40 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ */
+
+#include "nsISupports.idl"
+#include "nsIEvent.idl"
+
+/**
+ * The nsIWinEvent defines what a message looks like on the Windows Platform.    
+ */						  
+
+[scriptable, uuid(2EFB5005-4508-11d3-AEDA-00A024FFC08C)]
+interface nsIWinEvent : nsIEvent
+{
+	[noscript] attribute voidPtr hwnd;
+	attribute unsigned long message;
+	attribute unsigned long wParam;
+	attribute unsigned long lParam;
+	attribute unsigned long time;
+	attribute long pointX;
+	attribute long pointY;
+};

mozilla/xpcom/appshell/eventloop/windows/nsIWinEventFilter.idl

@@ -0,0 +1,38 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is Mozilla Communicator client code.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s):
+ */
+
+#include "nsISupports.idl"
+#include "nsIEventFilter.idl"
+
+/**
+ * The nsIWinEventFilter defines what a message filter looks like on the Windows 
+ * Platform.    
+ */						  
+
+[scriptable, uuid(2EFB5006-4508-11d3-AEDA-00A024FFC08C)]
+interface nsIWinEventFilter : nsIEventFilter
+{
+	[noscript] attribute voidPtr hwnd;
+	attribute unsigned long MsgFilterMin;
+	attribute unsigned long MsgFilterMax;
+	attribute unsigned long RemoveFlags;
+};

mozilla/xpcom/appshell/eventloop/xp/Makefile.in

@@ -0,0 +1,63 @@
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#
+
+DEPTH		= ../../../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE		= xpcom_eventloop_xp
+LIBRARY_NAME	= xp_eventloop
+
+
+CPPSRCS		= \
+		nsCBaseAppLoop.cpp \
+		nsCBaseBreathLoop.cpp \
+		nsCBaseLoop.cpp \
+		nsCBaseThreadLoop.cpp \
+		nsCLoopModule.cpp \
+		$(NULL)
+
+XPIDLSRCS	= \
+		nsCEventLoop.idl \
+		nsIDispatchListener.idl \
+		nsIEvent.idl \
+		nsIEventFilter.idl \
+		nsIEventLoop.idl \
+		nsITranslateListener.idl \
+		nsPIEventLoop.idl \
+		$(NULL)
+
+LOCAL_INCLUDES	= -I.
+
+# we don't want the shared lib, but we want to force the creation of a static lib.
+override NO_SHARED_LIB=1
+override NO_STATIC_LIB=
+
+include $(topsrcdir)/config/rules.mk
+
+ifneq (,$(filter gtk photon,$(MOZ_WIDGET_TOOLKIT)))
+LOCAL_INCLUDES	+= -I../$(MOZ_WIDGET_TOOLKIT)
+CXXFLAGS	+= $(TK_CFLAGS)
+endif
+

mozilla/xpcom/appshell/eventloop/xp/makefile.win

@@ -0,0 +1,53 @@
+#!nmake
+# 
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/MPL/
+# 
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+# 
+# The Original Code is the Mozilla browser.
+# 
+# The Initial Developer of the Original Code is Netscape
+# Communications, Inc.  Portions created by Netscape are
+# Copyright (C) 1999, Mozilla.  All Rights Reserved.
+# 
+# Contributor(s):
+#   Travis Bogard <travis@netscape.com>
+
+DEPTH=..\..\..\..
+MODULE=xpcom_eventloop_xp
+
+LIBRARY_NAME= xp_eventloop
+
+XPIDLSRCS=									\
+		.\nsCEventLoop.idl				\
+		.\nsIDispatchListener.idl		\
+		.\nsIEventLoop.idl				\
+		.\nsIEventFilter.idl				\
+		.\nsIEvent.idl						\
+		.\nsITranslateListener.idl		\
+		.\nsPIEventLoop.idl				\
+		$(NULL)
+
+CPP_OBJS=											\
+		.\$(OBJDIR)\nsCLoopModule.obj			\
+		.\$(OBJDIR)\nsCBaseLoop.obj			\
+		.\$(OBJDIR)\nsCBaseAppLoop.obj		\
+		.\$(OBJDIR)\nsCBaseBreathLoop.obj	\
+		.\$(OBJDIR)\nsCBaseThreadLoop.obj	\
+		$(NULL)
+
+
+LINCS=						\
+			-I..\windows	\
+			$(NULL)  
+
+include <$(DEPTH)\config\rules.mak>
+include <$(DEPTH)\config\config.mak>
+
+install:: $(LIBRARY)