The Tor Browser: parser/htmlparser/src/nsHTMLEntities.cpp@6474c204b198 (annotated)

parser/htmlparser/src/nsHTMLEntities.cpp@6474c204b198 (annotated)

parser/htmlparser/src/nsHTMLEntities.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "mozilla/ArrayUtils.h"
 #include "nsHTMLEntities.h"
 #include "nsString.h"
 #include "nsCRT.h"
 #include "pldhash.h"
 using namespace mozilla;
 struct EntityNode {
   const char* mStr; // never owns buffer
   int32_t       mUnicode;
 };
 struct EntityNodeEntry : public PLDHashEntryHdr
 {
   const EntityNode* node;
 };
 static bool
   matchNodeString(PLDHashTable*, const PLDHashEntryHdr* aHdr,
                   const void* key)
 {
   const EntityNodeEntry* entry = static_cast<const EntityNodeEntry*>(aHdr);
   const char* str = static_cast<const char*>(key);
   return (nsCRT::strcmp(entry->node->mStr, str) == 0);
 }
 static bool
   matchNodeUnicode(PLDHashTable*, const PLDHashEntryHdr* aHdr,
                    const void* key)
 {
   const EntityNodeEntry* entry = static_cast<const EntityNodeEntry*>(aHdr);
   const int32_t ucode = NS_PTR_TO_INT32(key);
   return (entry->node->mUnicode == ucode);
 }
 static PLDHashNumber
   hashUnicodeValue(PLDHashTable*, const void* key)
 {
   // key is actually the unicode value
   return PLDHashNumber(NS_PTR_TO_INT32(key));
   }
 static const PLDHashTableOps EntityToUnicodeOps = {
   PL_DHashAllocTable,
   PL_DHashFreeTable,
   PL_DHashStringKey,
   matchNodeString,
   PL_DHashMoveEntryStub,
   PL_DHashClearEntryStub,
   PL_DHashFinalizeStub,
   nullptr,
 };
 static const PLDHashTableOps UnicodeToEntityOps = {
   PL_DHashAllocTable,
   PL_DHashFreeTable,
   hashUnicodeValue,
   matchNodeUnicode,
   PL_DHashMoveEntryStub,
   PL_DHashClearEntryStub,
   PL_DHashFinalizeStub,
   nullptr,
 };
 static PLDHashTable gEntityToUnicode = { 0 };
 static PLDHashTable gUnicodeToEntity = { 0 };
 static nsrefcnt gTableRefCnt = 0;
 #define HTML_ENTITY(_name, _value) { #_name, _value },
 static const EntityNode gEntityArray[] = {
 #include "nsHTMLEntityList.h"
 };
 #undef HTML_ENTITY
 #define NS_HTML_ENTITY_COUNT ((int32_t)ArrayLength(gEntityArray))
 nsresult
 nsHTMLEntities::AddRefTable(void)
 {
   if (!gTableRefCnt) {
     if (!PL_DHashTableInit(&gEntityToUnicode, &EntityToUnicodeOps,
                            nullptr, sizeof(EntityNodeEntry),
                            uint32_t(NS_HTML_ENTITY_COUNT / 0.75),
                            fallible_t())) {
       gEntityToUnicode.ops = nullptr;
       return NS_ERROR_OUT_OF_MEMORY;
     }
     if (!PL_DHashTableInit(&gUnicodeToEntity, &UnicodeToEntityOps,
                            nullptr, sizeof(EntityNodeEntry),
                            uint32_t(NS_HTML_ENTITY_COUNT / 0.75),
                            fallible_t())) {
       PL_DHashTableFinish(&gEntityToUnicode);
       gEntityToUnicode.ops = gUnicodeToEntity.ops = nullptr;
       return NS_ERROR_OUT_OF_MEMORY;
     }
     for (const EntityNode *node = gEntityArray,
                  *node_end = ArrayEnd(gEntityArray);
          node < node_end; ++node) {
       // add to Entity->Unicode table
       EntityNodeEntry* entry =
         static_cast<EntityNodeEntry*>
                    (PL_DHashTableOperate(&gEntityToUnicode,
                                             node->mStr,
                                             PL_DHASH_ADD));
       NS_ASSERTION(entry, "Error adding an entry");
       // Prefer earlier entries when we have duplication.
       if (!entry->node)
         entry->node = node;
       // add to Unicode->Entity table
       entry = static_cast<EntityNodeEntry*>
                          (PL_DHashTableOperate(&gUnicodeToEntity,
                                                   NS_INT32_TO_PTR(node->mUnicode),
                                                   PL_DHASH_ADD));
       NS_ASSERTION(entry, "Error adding an entry");
       // Prefer earlier entries when we have duplication.
       if (!entry->node)
         entry->node = node;
     }
 #ifdef DEBUG
     PL_DHashMarkTableImmutable(&gUnicodeToEntity);
     PL_DHashMarkTableImmutable(&gEntityToUnicode);
 #endif
   }
   ++gTableRefCnt;
   return NS_OK;
 }
 void
 nsHTMLEntities::ReleaseTable(void)
 {
   if (--gTableRefCnt != 0)
     return;
   if (gEntityToUnicode.ops) {
     PL_DHashTableFinish(&gEntityToUnicode);
     gEntityToUnicode.ops = nullptr;
   }
   if (gUnicodeToEntity.ops) {
     PL_DHashTableFinish(&gUnicodeToEntity);
     gUnicodeToEntity.ops = nullptr;
   }
 }
 int32_t
 nsHTMLEntities::EntityToUnicode(const nsCString& aEntity)
 {
   NS_ASSERTION(gEntityToUnicode.ops, "no lookup table, needs addref");
   if (!gEntityToUnicode.ops)
     return -1;
     //this little piece of code exists because entities may or may not have the terminating ';'.
     //if we see it, strip if off for this test...
     if(';'==aEntity.Last()) {
       nsAutoCString temp(aEntity);
       temp.Truncate(aEntity.Length()-1);
       return EntityToUnicode(temp);
     }
   EntityNodeEntry* entry =
     static_cast<EntityNodeEntry*>
                (PL_DHashTableOperate(&gEntityToUnicode, aEntity.get(), PL_DHASH_LOOKUP));
   if (!entry || PL_DHASH_ENTRY_IS_FREE(entry))
   return -1;
   return entry->node->mUnicode;
 }
 int32_t
 nsHTMLEntities::EntityToUnicode(const nsAString& aEntity) {
   nsAutoCString theEntity; theEntity.AssignWithConversion(aEntity);
   if(';'==theEntity.Last()) {
     theEntity.Truncate(theEntity.Length()-1);
   }
   return EntityToUnicode(theEntity);
 }
 const char*
 nsHTMLEntities::UnicodeToEntity(int32_t aUnicode)
 {
   NS_ASSERTION(gUnicodeToEntity.ops, "no lookup table, needs addref");
   EntityNodeEntry* entry =
     static_cast<EntityNodeEntry*>
                (PL_DHashTableOperate(&gUnicodeToEntity, NS_INT32_TO_PTR(aUnicode), PL_DHASH_LOOKUP));
   if (!entry || PL_DHASH_ENTRY_IS_FREE(entry))
   return nullptr;
   return entry->node->mStr;
 }
 #ifdef DEBUG
 #include <stdio.h>
 class nsTestEntityTable {
 public:
    nsTestEntityTable() {
      int32_t value;
      nsHTMLEntities::AddRefTable();
      // Make sure we can find everything we are supposed to
      for (int i = 0; i < NS_HTML_ENTITY_COUNT; ++i) {
        nsAutoString entity; entity.AssignWithConversion(gEntityArray[i].mStr);
        value = nsHTMLEntities::EntityToUnicode(entity);
        NS_ASSERTION(value != -1, "can't find entity");
        NS_ASSERTION(value == gEntityArray[i].mUnicode, "bad unicode value");
        entity.AssignWithConversion(nsHTMLEntities::UnicodeToEntity(value));
        NS_ASSERTION(entity.EqualsASCII(gEntityArray[i].mStr), "bad entity name");
      }
      // Make sure we don't find things that aren't there
      value = nsHTMLEntities::EntityToUnicode(nsAutoCString("@"));
      NS_ASSERTION(value == -1, "found @");
      value = nsHTMLEntities::EntityToUnicode(nsAutoCString("zzzzz"));
      NS_ASSERTION(value == -1, "found zzzzz");
      nsHTMLEntities::ReleaseTable();
    }
 };
 //nsTestEntityTable validateEntityTable;
 #endif

The Tor Browser / annotate

parser/htmlparser/src/nsHTMLEntities.cpp@6474c204b198 (annotated)

parser/htmlparser/src/nsHTMLEntities.cpp