Bommels05/Mozilla
Bommels05/Mozilla
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 299992, the part before the actual work: move pldhash and the templatized hashtables into the glue (and drop the minor dependencies on NSPR), and centralize our various in-tree nsINIParser classes into the glue (does not affect the ones used for the various installers) r=brendan/darin a=chase/cbeard

Browse Source 
git-svn-id: svn://10.0.0.236/trunk@177591 18797224-902f-48f8-a5cc-f745e15eee43
This commit is contained in:
bsmedberg%covad.net 2005-08-11 20:40:53 +00:00
parent c8e1a406bd
commit b80f390773
42 changed files with 842 additions and 4298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
mozilla/browser/components/migration/src/Makefile.in
View File

@ -71,7 +71,6 @@ CPPSRCS = nsProfileMigrator.cpp \
nsNetscapeProfileMigratorBase.cpp \
nsSeamonkeyProfileMigrator.cpp \
nsPhoenixProfileMigrator.cpp \
nsINIParser.cpp \
$(NULL)
ifneq ($(OS_ARCH),BeOS)

332
mozilla/browser/components/migration/src/nsINIParser.cpp
View File

@ -1,332 +0,0 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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 Communicator client code, released
* March 31, 1998.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Samir Gehani <sgehani@netscape.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsINIParser.h"
#include "nsCRT.h"
nsINIParser::nsINIParser(const char *aFilename)
{
FILE *fd = NULL;
long eofpos = 0;
int rd = 0;
mFileBuf = NULL;
mFileBufSize = 0;
mError = OK;
DUMP("nsINIParser");
/* param check */
if (!aFilename)
{
mError = E_PARAM;
return;
}
/* open the file */
fd = fopen(aFilename, "r");
if (!fd)
goto bail;
/* get file size */
if (fseek(fd, 0, SEEK_END) != 0)
goto bail;
eofpos = ftell(fd);
if (eofpos == 0)
goto bail;
/* malloc an internal buf the size of the file */
mFileBuf = (char *) malloc((eofpos+1) * sizeof(char));
if (!mFileBuf)
{
mError = E_MEM;
return;
}
mFileBufSize = eofpos;
/* read the file in one swoop */
if (fseek(fd, 0, SEEK_SET) != 0)
goto bail;
rd = fread((void *)mFileBuf, 1, eofpos, fd);
if (!rd)
goto bail;
mFileBuf[mFileBufSize] = '\0';
/* close file */
fclose(fd);
return;
bail:
mError = E_READ;
return;
}
nsINIParser::~nsINIParser()
{
if (mFileBuf) {
nsCRT::free(mFileBuf);
mFileBuf = nsnull;
}
DUMP("~nsINIParser");
}
int
nsINIParser::GetString( char *aSection, char *aKey,
char *aValBuf, int *aIOValBufSize )
{
char *secPtr = NULL;
mError = OK;
DUMP("GetString");
/* param check */
if ( !aSection || !aKey || !aValBuf ||
!aIOValBufSize || (*aIOValBufSize <= 0) )
return E_PARAM;
/* find the section if it exists */
mError = FindSection(aSection, &secPtr);
if (mError != OK)
return mError;
/* find the key if it exists in the valid section we found */
mError = FindKey(secPtr, aKey, aValBuf, aIOValBufSize);
return mError;
}
int
nsINIParser::GetStringAlloc( char *aSection, char *aKey,
char **aOutBuf, int *aOutBufSize )
{
char buf[MAX_VAL_SIZE];
int bufsize = MAX_VAL_SIZE;
mError = OK;
DUMP("GetStringAlloc");
mError = GetString(aSection, aKey, buf, &bufsize);
if (mError != OK)
return mError;
*aOutBuf = (char *) malloc(bufsize + 1);
strncpy(*aOutBuf, buf, bufsize);
*(*aOutBuf + bufsize) = 0;
*aOutBufSize = bufsize + 1;
return mError;
}
int
nsINIParser::GetError()
{
DUMP("GetError");
return mError;
}
char *
nsINIParser::ResolveName(char *aINIRoot)
{
char *resolved = NULL;
char *locale = NULL;
struct stat st_exists;
/* param check */
if (!aINIRoot)
return NULL;
locale = setlocale(LC_CTYPE, NULL);
if (!locale)
return NULL;
/* resolved string: "<root>.ini.<locale>\0" */
resolved = (char *) malloc(strlen(aINIRoot) + 5 + strlen(locale) + 1);
if (!resolved)
return NULL;
/* locale specific ini file name */
sprintf(resolved, "%s.ini.%s", aINIRoot, locale);
if (0 == stat(resolved, &st_exists))
return resolved;
/* fallback to general ini file name */
sprintf(resolved, "%s.ini", aINIRoot);
if (0 == stat(resolved, &st_exists))
return resolved;
/* neither existed so error returned */
return NULL;
}
int
nsINIParser::FindSection(char *aSection, char **aOutSecPtr)
{
char *currChar = mFileBuf;
char *nextSec = NULL;
char *secClose = NULL;
char *nextNL = NULL;
mError = E_NO_SEC;
DUMP("FindSection");
// param check
if (!aSection || !aOutSecPtr)
{
mError = E_PARAM;
return mError;
}
while (currChar < (mFileBuf + mFileBufSize))
{
// look for first '['
nextSec = NULL;
nextSec = strchr(currChar, '[');
if (!nextSec)
break;
currChar = nextSec + 1;
// extract section name till first ']'
secClose = NULL; nextNL = NULL;
secClose = strchr(currChar, ']');
nextNL = strchr(currChar, NL);
if ((!nextNL) || (nextNL < secClose))
{
currChar = nextNL;
continue;
}
// if section name matches we succeeded
if (strncmp(aSection, currChar, strlen(aSection)) == 0)
{
*aOutSecPtr = secClose + 1;
mError = OK;
break;
}
}
return mError;
}
int
nsINIParser::FindKey(char *aSecPtr, char *aKey, char *aVal, int *aIOValSize)
{
char *nextNL = NULL;
char *secEnd = NULL;
char *currLine = aSecPtr;
char *nextEq = NULL;
mError = E_NO_KEY;
DUMP("FindKey");
// param check
if (!aSecPtr || !aKey || !aVal || !aIOValSize || (*aIOValSize <= 0))
{
mError = E_PARAM;
return mError;
}
// determine the section end
secEnd = aSecPtr;
find_end:
if (secEnd)
secEnd = strchr(secEnd, '['); // search for next sec start
if (!secEnd)
{
secEnd = strchr(aSecPtr, '\0'); // else search for file end
if (!secEnd)
{
mError = E_SEC_CORRUPT; // else this data is corrupt
return mError;
}
}
// handle start section token ('[') in values for i18n
if (*secEnd == '[' && !(secEnd == aSecPtr || *(secEnd-1) == NL))
{
secEnd++;
goto find_end;
}
while (currLine < secEnd)
{
nextNL = NULL;
nextNL = strchr(currLine, NL);
if (!nextNL)
nextNL = mFileBuf + mFileBufSize;
// ignore commented lines (starting with ;)
if (currLine == strchr(currLine, ';'))
{
currLine = nextNL + 1;
continue;
}
// extract key before '='
nextEq = NULL;
nextEq = strchr(currLine, '=');
if (!nextEq || nextEq > nextNL)
{
currLine = nextNL + 1;
continue;
}
// if key matches we succeeded
if (strncmp(currLine, aKey, strlen(aKey)) == 0)
{
// extract the value and return
if (*aIOValSize < nextNL - nextEq)
{
mError = E_SMALL_BUF;
*aVal = '\0';
*aIOValSize = 0;
return mError;
}
*aIOValSize = nextNL - (nextEq + 1);
strncpy(aVal, (nextEq + 1), *aIOValSize);
*(aVal + *aIOValSize) = 0; // null terminate
mError = OK;
return mError;
}
else
{
currLine = nextNL + 1;
}
}
return mError;
}

163
mozilla/browser/components/migration/src/nsINIParser.h
View File

@ -1,163 +0,0 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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 Communicator client code, released
* March 31, 1998.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Samir Gehani <sgehani@netscape.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef _NS_INIPARSER_H_
#define _NS_INIPARSER_H_
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <locale.h>
class nsINIParser
{
public:
/**
* nsINIParser
*
* Construct a new INI parser for the file specified.
*
* @param aFilename path to INI file
*/
nsINIParser(const char *aFilename);
~nsINIParser();
/**
* GetString
*
* Gets the value of the specified key in the specified section
* of the INI file represented by this instance. The value is stored
* in the supplied buffer. The buffer size is provided as input and
* the actual bytes used by the value is set in the in/out size param.
*
* @param aSection section name
* @param aKey key name
* @param aValBuf user supplied buffer
* @param aIOValBufSize buf size on input; actual buf used on output
*
* @return mError operation success code
*/
int GetString( char *aSection, char *aKey,
char *aValBuf, int *aIOValBufSize );
/**
* GetStringAlloc
*
* Same as GetString() except the buffer is allocated to the exact
* size of the value. Useful when the buffer is allocated everytime
* rather than reusing the same buffer when calling this function
* multiple times.
*
* @param aSection section name
* @param aKey key name
* @param aOutBuf buffer to be allocated
* @param aOutBufSize size of newly allocated buffer
*
* @return mError operation success code
*/
int GetStringAlloc( char *aSection, char *aKey,
char **aOutBuf, int *aOutBufSize );
/**
* GetError
*
* Exposes the last error on this instance. Useful for checking
* the state of the object after construction since the INI file
* is parsed once at object-allocation time.
*
* @return mError last error on ops on this object
*/
int GetError();
/**
* ResolveName
*
* Given a "root" name we append the runtime locale of the
* current system to the <root>.ini. If such a file exists we
* return this as the name else simply return <root>.ini.
*
* NOTE: Returned string is allocated and caller is responsible
* ---- for its deallocation.
*
* @param aINIRoot the "root" of the INI file name
* @return resolved the resolved INI file name
* (NULL if neither exist)
*/
static char *ResolveName(char *aINIRoot);
/*--------------------------------------------------------------------*
* Errors
*--------------------------------------------------------------------*/
enum
{
OK = 0,
E_READ = -701,
E_MEM = -702,
E_PARAM = -703,
E_NO_SEC = -704,
E_NO_KEY = -705,
E_SEC_CORRUPT = -706,
E_SMALL_BUF = -707
};
private:
int FindSection(char *aSection, char **aOutSecPtr);
int FindKey(char *aSecPtr, char *aKey, char *aVal, int *aIOValSize);
char *mFileBuf;
int mFileBufSize;
int mError;
};
#define NL '\n'
#define MAX_VAL_SIZE 512
#if defined(DUMP)
#undef DUMP
#endif
#if defined(DEBUG_sgehani) || defined(DEBUG_druidd) || defined(DEBUG_root)
#define DUMP(_msg) printf("%s %d: %s \n", __FILE__, __LINE__, _msg);
#else
#define DUMP(_msg)
#endif
#endif /*_NS_INIPARSER_H_ */

175
mozilla/browser/components/migration/src/nsOperaProfileMigrator.cpp
View File

@ -367,15 +367,18 @@ nsOperaProfileMigrator::SetString(void* aTransform, nsIPrefBranch* aBranch)
nsresult
nsOperaProfileMigrator::CopyPreferences(PRBool aReplace)
{
nsresult rv;
nsCOMPtr<nsIFile> operaPrefs;
mOperaProfile->Clone(getter_AddRefs(operaPrefs));
operaPrefs->Append(OPERA_PREFERENCES_FILE_NAME);
nsCAutoString path;
operaPrefs->GetNativePath(path);
nsINIParser* parser = new nsINIParser(path.get());
if (!parser)
return NS_ERROR_OUT_OF_MEMORY;
nsCOMPtr<nsILocalFile> lf(do_QueryInterface(operaPrefs));
NS_ENSURE_TRUE(lf, NS_ERROR_UNEXPECTED);
nsINIParser parser;
rv = parser.Init(lf);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIPrefBranch> branch(do_GetService(NS_PREFSERVICE_CONTRACTID));
@ -383,7 +386,6 @@ nsOperaProfileMigrator::CopyPreferences(PRBool aReplace)
PrefTransform* transform;
PrefTransform* end = gTransforms + sizeof(gTransforms)/sizeof(PrefTransform);
PRInt32 length;
char* lastSectionName = nsnull;
for (transform = gTransforms; transform < end; ++transform) {
if (transform->sectionName)
@ -402,22 +404,22 @@ nsOperaProfileMigrator::CopyPreferences(PRBool aReplace)
nsCRT::free(colorString);
}
else {
nsXPIDLCString val;
PRInt32 err = parser->GetStringAlloc(lastSectionName, transform->keyName, getter_Copies(val), &length);
if (err == nsINIParser::OK) {
nsCAutoString val;
rv = parser.GetString(lastSectionName,
transform->keyName,
val);
if (NS_SUCCEEDED(rv)) {
PRInt32 strerr;
switch (transform->type) {
case _OPM(STRING):
transform->stringValue = ToNewCString(val);
break;
case _OPM(INT): {
nsCAutoString valStr; valStr = val;
transform->intValue = valStr.ToInteger(&strerr);
transform->intValue = val.ToInteger(&strerr);
}
break;
case _OPM(BOOL): {
nsCAutoString valStr; valStr = val;
transform->boolValue = valStr.ToInteger(&strerr) != 0;
transform->boolValue = val.ToInteger(&strerr) != 0;
}
break;
default:
@ -440,23 +442,22 @@ nsOperaProfileMigrator::CopyPreferences(PRBool aReplace)
if (aReplace)
CopyUserContentSheet(parser);
delete parser;
parser = nsnull;
return NS_OK;
}
nsresult
nsOperaProfileMigrator::CopyProxySettings(nsINIParser* aParser,
nsOperaProfileMigrator::CopyProxySettings(nsINIParser &aParser,
nsIPrefBranch* aBranch)
{
nsresult rv;
PRInt32 networkProxyType = 0;
const char* protocols[4] = { "HTTP", "HTTPS", "FTP", "GOPHER" };
const char* protocols_l[4] = { "http", "https", "ftp", "gopher" };
char toggleBuf[15], serverBuf[20], serverPrefBuf[20],
serverPortPrefBuf[25];
PRInt32 length, err, enabled;
PRInt32 enabled;
for (PRUint32 i = 0; i < 4; ++i) {
sprintf(toggleBuf, "Use %s", protocols[i]);
GetInteger(aParser, "Proxy", toggleBuf, &enabled);
@ -467,9 +468,9 @@ nsOperaProfileMigrator::CopyProxySettings(nsINIParser* aParser,
}
sprintf(serverBuf, "%s Server", protocols[i]);
nsXPIDLCString proxyServer;
err = aParser->GetStringAlloc("Proxy", serverBuf, getter_Copies(proxyServer), &length);
if (err != nsINIParser::OK)
nsCAutoString proxyServer;
rv = aParser.GetString("Proxy", serverBuf, proxyServer);
if (NS_FAILED(rv))
continue;
sprintf(serverPrefBuf, "network.proxy.%s", protocols_l[i]);
@ -480,16 +481,18 @@ nsOperaProfileMigrator::CopyProxySettings(nsINIParser* aParser,
GetInteger(aParser, "Proxy", "Use Automatic Proxy Configuration", &enabled);
if (enabled)
networkProxyType = 2;
nsXPIDLCString configURL;
err = aParser->GetStringAlloc("Proxy", "Automatic Proxy Configuration URL", getter_Copies(configURL), &length);
if (err == nsINIParser::OK)
aBranch->SetCharPref("network.proxy.autoconfig_url", configURL);
nsCAutoString configURL;
rv = aParser.GetString("Proxy", "Automatic Proxy Configuration URL",
configURL);
if (NS_SUCCEEDED(rv))
aBranch->SetCharPref("network.proxy.autoconfig_url", configURL.get());
GetInteger(aParser, "Proxy", "No Proxy Servers Check", &enabled);
if (enabled) {
nsXPIDLCString servers;
err = aParser->GetStringAlloc("Proxy", "No Proxy Servers", getter_Copies(servers), &length);
if (err == nsINIParser::OK)
nsCAutoString servers;
rv = aParser.GetString("Proxy", "No Proxy Servers", servers);
if (NS_SUCCEEDED(rv))
ParseOverrideServers(servers.get(), aBranch);
}
@ -499,28 +502,26 @@ nsOperaProfileMigrator::CopyProxySettings(nsINIParser* aParser,
}
nsresult
nsOperaProfileMigrator::GetInteger(nsINIParser* aParser,
nsOperaProfileMigrator::GetInteger(nsINIParser &aParser,
char* aSectionName,
char* aKeyName,
PRInt32* aResult)
{
char val[20];
PRInt32 length = 20;
nsCAutoString val;
PRInt32 err = aParser->GetString(aSectionName, aKeyName, val, &length);
if (err != nsINIParser::OK)
return NS_ERROR_FAILURE;
nsresult rv = aParser.GetString(aSectionName, aKeyName, val);
if (NS_FAILED(rv))
return rv;
nsCAutoString valueStr((char*)val);
PRInt32 stringErr;
*aResult = valueStr.ToInteger(&stringErr);
*aResult = val.ToInteger((PRInt32*) &rv);
return NS_OK;
return rv;
}
nsresult
nsOperaProfileMigrator::ParseColor(nsINIParser* aParser, char* aSectionName, char** aResult)
nsOperaProfileMigrator::ParseColor(nsINIParser &aParser,
char* aSectionName, char** aResult)
{
nsresult rv;
PRInt32 r, g, b;
@ -541,34 +542,37 @@ nsOperaProfileMigrator::ParseColor(nsINIParser* aParser, char* aSectionName, cha
}
nsresult
nsOperaProfileMigrator::CopyUserContentSheet(nsINIParser* aParser)
nsOperaProfileMigrator::CopyUserContentSheet(nsINIParser &aParser)
{
nsresult rv = NS_OK;
nsresult rv;
nsXPIDLCString userContentCSS;
PRInt32 size;
PRInt32 err = aParser->GetStringAlloc("User Prefs", "Local CSS File", getter_Copies(userContentCSS), &size);
if (err == nsINIParser::OK && userContentCSS.Length() > 0) {
// Copy the file
nsCOMPtr<nsILocalFile> userContentCSSFile(do_CreateInstance("@mozilla.org/file/local;1"));
if (!userContentCSSFile)
return NS_ERROR_OUT_OF_MEMORY;
nsCAutoString userContentCSS;
rv = aParser.GetString("User Prefs", "Local CSS File", userContentCSS);
if (NS_FAILED(rv) || userContentCSS.Length() == 0)
return NS_OK;
userContentCSSFile->InitWithNativePath(userContentCSS);
PRBool exists;
userContentCSSFile->Exists(&exists);
if (!exists)
return NS_OK;
// Copy the file
nsCOMPtr<nsILocalFile> userContentCSSFile;
rv = NS_NewNativeLocalFile(userContentCSS, PR_TRUE,
getter_AddRefs(userContentCSSFile));
if (NS_FAILED(rv))
return NS_OK;
nsCOMPtr<nsIFile> profileChromeDir;
NS_GetSpecialDirectory(NS_APP_USER_CHROME_DIR,
getter_AddRefs(profileChromeDir));
if (!profileChromeDir)
return NS_ERROR_OUT_OF_MEMORY;
PRBool exists;
rv = userContentCSSFile->Exists(&exists);
if (NS_FAILED(rv) || !exists)
return NS_OK;
rv = userContentCSSFile->CopyToNative(profileChromeDir, nsDependentCString("userContent.css"));
}
return rv;
nsCOMPtr<nsIFile> profileChromeDir;
NS_GetSpecialDirectory(NS_APP_USER_CHROME_DIR,
getter_AddRefs(profileChromeDir));
if (!profileChromeDir)
return NS_OK;
userContentCSSFile->CopyToNative(profileChromeDir,
NS_LITERAL_CSTRING("userContent.css"));
return NS_OK;
}
nsresult
@ -1051,17 +1055,20 @@ nsOperaProfileMigrator::CopySmartKeywords(nsIBookmarksService* aBMS,
nsIStringBundle* aBundle,
nsIRDFResource* aParentFolder)
{
nsresult rv = NS_OK;
nsresult rv;
nsCOMPtr<nsIFile> smartKeywords;
mOperaProfile->Clone(getter_AddRefs(smartKeywords));
smartKeywords->Append(NS_LITERAL_STRING("search.ini"));
nsCAutoString path;
smartKeywords->GetNativePath(path);
nsINIParser* parser = new nsINIParser(path.get());
if (!parser)
return NS_ERROR_OUT_OF_MEMORY;
nsCOMPtr<nsILocalFile> lf(do_QueryInterface(smartKeywords));
if (!lf)
return NS_OK;
nsINIParser parser;
rv = parser.Init(lf);
if (NS_FAILED(rv))
return NS_OK;
nsXPIDLString sourceNameOpera;
aBundle->GetStringFromName(NS_LITERAL_STRING("sourceNameOpera").get(),
@ -1078,31 +1085,32 @@ nsOperaProfileMigrator::CopySmartKeywords(nsIBookmarksService* aBMS,
aParentFolder, -1, getter_AddRefs(keywordsFolder));
PRInt32 sectionIndex = 1;
char section[35];
nsXPIDLCString name, url, keyword;
PRInt32 keyValueLength = 0;
nsCAutoString name, url, keyword;
do {
sprintf(section, "Search Engine %d", sectionIndex++);
PRInt32 err = parser->GetStringAlloc(section, "Name", getter_Copies(name), &keyValueLength);
if (err != nsINIParser::OK)
nsCAutoString section("Search Engine ");
section.AppendInt(sectionIndex++);
rv = parser.GetString(section.get(), "Name", name);
if (NS_FAILED(rv))
break;
err = parser->GetStringAlloc(section, "URL", getter_Copies(url), &keyValueLength);
if (err != nsINIParser::OK)
rv = parser.GetString(section.get(), "URL", url);
if (NS_FAILED(rv))
continue;
err = parser->GetStringAlloc(section, "Key", getter_Copies(keyword), &keyValueLength);
if (err != nsINIParser::OK)
rv = parser.GetString(section.get(), "Key", keyword);
if (NS_FAILED(rv))
continue;
PRInt32 post;
err = GetInteger(parser, section, "Is post", &post);
if (post)
rv = GetInteger(parser, section.get(), "Is post", &post);
if (NS_SUCCEEDED(rv) && post)
continue;
if (url.IsEmpty() || keyword.IsEmpty() || name.IsEmpty())
continue;
nsAutoString nameStr; nameStr.Assign(NS_ConvertUTF8toUCS2(name));
NS_ConvertUTF8toUCS2 nameStr(name);
PRUint32 length = nameStr.Length();
PRInt32 index = 0;
do {
@ -1152,11 +1160,6 @@ nsOperaProfileMigrator::CopySmartKeywords(nsIBookmarksService* aBMS,
}
while (1);
if (parser) {
delete parser;
parser = nsnull;
}
return rv;
}
#endif

8
mozilla/browser/components/migration/src/nsOperaProfileMigrator.h
View File

@ -92,10 +92,10 @@ public:
protected:
nsresult CopyPreferences(PRBool aReplace);
nsresult ParseColor(nsINIParser* aParser, char* aSectionName, char** aResult);
nsresult CopyUserContentSheet(nsINIParser* aParser);
nsresult CopyProxySettings(nsINIParser* aParser, nsIPrefBranch* aBranch);
nsresult GetInteger(nsINIParser* aParser, char* aSectionName,
nsresult ParseColor(nsINIParser &aParser, char* aSectionName, char** aResult);
nsresult CopyUserContentSheet(nsINIParser &aParser);
nsresult CopyProxySettings(nsINIParser &aParser, nsIPrefBranch* aBranch);
nsresult GetInteger(nsINIParser &aParser, char* aSectionName,
char* aKeyName, PRInt32* aResult);
nsresult CopyCookies(PRBool aReplace);

14
mozilla/js/src/jsdhash.c
View File

@ -207,7 +207,9 @@ JS_DHashTableInit(JSDHashTable *table, const JSDHashTableOps *ops, void *data,
table->data = data;
if (capacity < JS_DHASH_MIN_SIZE)
capacity = JS_DHASH_MIN_SIZE;
log2 = JS_CeilingLog2(capacity);
JS_CEILING_LOG2(log2, capacity);
capacity = JS_BIT(log2);
if (capacity >= JS_DHASH_SIZE_LIMIT)
return JS_FALSE;
@ -601,7 +603,7 @@ JS_PUBLIC_API(uint32)
JS_DHashTableEnumerate(JSDHashTable *table, JSDHashEnumerator etor, void *arg)
{
char *entryAddr, *entryLimit;
uint32 i, capacity, entrySize;
uint32 i, capacity, entrySize, ceiling;
JSBool didRemove;
JSDHashEntryHdr *entry;
JSDHashOperator op;
@ -643,9 +645,11 @@ JS_DHashTableEnumerate(JSDHashTable *table, JSDHashEnumerator etor, void *arg)
capacity += capacity >> 1;
if (capacity < JS_DHASH_MIN_SIZE)
capacity = JS_DHASH_MIN_SIZE;
(void) ChangeTable(table,
JS_CeilingLog2(capacity)
- (JS_DHASH_BITS - table->hashShift));
JS_CEILING_LOG2(ceiling, capacity);
ceiling -= JS_DHASH_BITS - table->hashShift;
(void) ChangeTable(table, ceiling);
}
return i;
}

2
mozilla/js/src/jsdhash.h
View File

@ -439,7 +439,7 @@ JS_DHashTableInit(JSDHashTable *table, const JSDHashTableOps *ops, void *data,
* we don't shrink on the very next remove after growing a table upon adding
* an entry that brings entryCount past maxAlpha * tableSize.
*/
JS_PUBLIC_API(void)
extern JS_PUBLIC_API(void)
JS_DHashTableSetAlphaBounds(JSDHashTable *table,
float maxAlpha,
float minAlpha);

6
mozilla/js/src/plify_jsdhash.sed
View File

@ -4,7 +4,7 @@
* GENERATED BY js/src/plify_jsdhash.sed -- DO NOT EDIT!!!
s/jsdhash_h___/pldhash_h___/
s/jsdhash\.bigdump/pldhash.bigdump/
s/jstypes\.h/prtypes.h/
s/jstypes\.h/nscore.h/
s/jsbit\.h/prbit.h/
s/jsdhash\.h/pldhash.h/
s/jsdhash\.c/pldhash.c/
@ -23,8 +23,8 @@ s/\([^U]\)int32/\1PRInt32/g
s/uint16/PRUint16/g
s/\([^U]\)int16/\1PRInt16/g
s/JSBool/PRBool/g
s/extern JS_PUBLIC_API/PR_EXTERN/
s/JS_PUBLIC_API/PR_IMPLEMENT/
s/extern JS_PUBLIC_API(\([^()]*\))/NS_COM_GLUE \1/
s/JS_PUBLIC_API(\([^()]*\))/\1/
s/JS_DLL_CALLBACK/PR_CALLBACK/
s/JS_STATIC_DLL_CALLBACK/PR_STATIC_CALLBACK/
s/JS_NewDHashTable/PL_NewDHashTable/

1
mozilla/layout/style/nsCSSStyleSheet.cpp
View File

@ -91,6 +91,7 @@
#include "nsITextContent.h"
#include "prlog.h"
#include "nsCOMPtr.h"
#include "nsHashKeys.h"
#include "nsStyleUtil.h"
#include "nsQuickSort.h"
#include "nsContentUtils.h"

1
mozilla/toolkit/profile/src/Makefile.in
View File

@ -60,7 +60,6 @@ LOCAL_INCLUDES = \
CPPSRCS = \
nsProfileLock.cpp \
nsToolkitProfileService.cpp \
nsINIParser.cpp \
$(NULL)
GARBAGE += nsProfileLock.cpp

269
mozilla/toolkit/profile/src/nsINIParser.cpp
View File

@ -1,269 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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 Communicator client code, released
* March 31, 1998.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Samir Gehani <sgehani@netscape.com>
* Benjamin Smedberg <bsmedberg@covad.net>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsINIParser.h"
#include "nsError.h"
#include "nsILocalFile.h"
#include <stdlib.h>
#include <stdio.h>
nsINIParser::nsINIParser() :
mFileBuf(nsnull),
mFileBufSize(0)
{ }
nsresult
nsINIParser::Init(nsILocalFile* aFile)
{
NS_ASSERTION(aFile, "Null param.");
nsresult rv;
FILE *fd;
long eofpos = 0;
int rd = 0;
/* open the file */
rv = aFile->OpenANSIFileDesc("r", &fd);
if (NS_FAILED(rv))
return rv;
/* get file size */
if (fseek(fd, 0, SEEK_END) != 0) {
rv = NS_BASE_STREAM_OSERROR;
goto bail;
}
eofpos = ftell(fd);
if (eofpos == 0) {
rv = NS_BASE_STREAM_OSERROR;
goto bail;
}
/* malloc an internal buf the size of the file */
mFileBuf = (char *) malloc((eofpos+1) * sizeof(char));
if (!mFileBuf) {
rv = NS_ERROR_OUT_OF_MEMORY;
goto bail;
}
mFileBufSize = eofpos;
/* read the file in one swoop */
if (fseek(fd, 0, SEEK_SET) != 0) {
rv = NS_BASE_STREAM_OSERROR;
goto bail;
}
rd = fread((void *)mFileBuf, 1, eofpos, fd);
if (!rd) {
rv = NS_BASE_STREAM_OSERROR;
goto bail;
}
mFileBuf[mFileBufSize] = '\0';
/* close file */
fclose(fd);
return NS_OK;
bail:
if (fd)
fclose(fd);
if (mFileBuf) {
free(mFileBuf);
mFileBuf = nsnull;
}
return NS_ERROR_FAILURE;
}
nsINIParser::~nsINIParser()
{
if (mFileBuf) {
free(mFileBuf);
mFileBuf = nsnull;
}
}
nsresult
nsINIParser::GetString(const char *aSection, const char *aKey,
char *aValBuf, PRUint32 aIOValBufSize)
{
NS_ASSERTION(aSection && aKey && aValBuf && aIOValBufSize,
"Null param!");
nsresult rv;
char *secPtr;
/* find the section if it exists */
rv = FindSection(aSection, &secPtr);
if (NS_FAILED(rv)) return rv;
/* find the key if it exists in the valid section we found */
rv = FindKey(secPtr, aKey, aValBuf, aIOValBufSize);
return rv;
}
nsresult
nsINIParser::FindSection(const char *aSection, char **aOutSecPtr)
{
char *currChar = mFileBuf;
char *nextSec = nsnull;
char *secClose = nsnull;
char *nextNL = nsnull;
int aSectionLen = strlen(aSection);
nsresult rv = NS_ERROR_FAILURE;
while (currChar < (mFileBuf + mFileBufSize))
{
// look for first '['
nextSec = NULL;
nextSec = strchr(currChar, '[');
if (!nextSec)
break;
currChar = nextSec + 1;
// extract section name till first ']'
secClose = NULL; nextNL = NULL;
secClose = strchr(currChar, ']');
nextNL = strchr(currChar, '\n');
if ((!nextNL) || (nextNL < secClose))
{
currChar = nextNL;
continue;
}
// if section name matches we succeeded
if (strncmp(aSection, currChar, aSectionLen) == 0
&& secClose-currChar == aSectionLen)
{
*aOutSecPtr = secClose + 1;
rv = NS_OK;
break;
}
}
return rv;
}
nsresult
nsINIParser::FindKey(const char *aSecPtr, const char *aKey, char *aVal, int aIOValSize)
{
const char *nextNL = nsnull;
const char *secEnd = nsnull;
const char *currLine = aSecPtr;
const char *nextEq = nsnull;
int aKeyLen = strlen(aKey);
// determine the section end
secEnd = aSecPtr;
find_end:
if (secEnd)
secEnd = strchr(secEnd, '['); // search for next sec start
if (!secEnd)
{
secEnd = strchr(aSecPtr, '\0'); // else search for file end
if (!secEnd)
{
return NS_ERROR_FILE_CORRUPTED;
}
}
// handle start section token ('[') in values for i18n
if (*secEnd == '[' && !(secEnd == aSecPtr || *(secEnd-1) == '\n'))
{
secEnd++;
goto find_end;
}
while (currLine < secEnd)
{
nextNL = NULL;
nextNL = strchr(currLine, '\n');
if (!nextNL)
nextNL = mFileBuf + mFileBufSize;
// ignore commented lines (starting with ;)
if (currLine == strchr(currLine, ';'))
{
currLine = nextNL + 1;
continue;
}
// extract key before '='
nextEq = NULL;
nextEq = strchr(currLine, '=');
if (!nextEq || nextEq > nextNL)
{
currLine = nextNL + 1;
continue;
}
// if key matches we succeeded
if (strncmp(currLine, aKey, aKeyLen) == 0
&& nextEq-currLine == aKeyLen)
{
// extract the value and return
if (aIOValSize < nextNL - nextEq)
{
*aVal = '\0';
return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA;
}
PRUint32 len = nextNL - (nextEq + 1);
// allows win32-style \r\n line endings
if ( *(nextEq + len) == '\r' )
--len;
strncpy(aVal, (nextEq + 1), len);
*(aVal + len) = 0; // null terminate
return NS_OK;
}
else
{
currLine = nextNL + 1;
}
}
return NS_ERROR_FAILURE;
}

111
mozilla/toolkit/profile/src/nsINIParser.h
View File

@ -1,111 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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 Communicator client code, released
* March 31, 1998.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Samir Gehani <sgehani@netscape.com>
* Benjamin Smedberg <bsmedberg@covad.net>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
// This file was shamelessly copied from mozilla/xpinstall/wizard/unix/src2
#ifndef nsINIParser_h__
#define nsINIParser_h__
#include "nscore.h"
// hack alert: in static builds, nsINIParser here conflicts with nsINIParser
// in browser/components/migration. So we use a #define to make the symbols
// unique.
#define nsINIParser nsINITParser
class nsILocalFile;
class nsINIParser
{
public:
nsINIParser();
~nsINIParser();
#if 0 // use nsresult instead
/**
* Errors
*/
enum INIResult
{
OK = 0,
E_READ = -701,
E_MEM = -702,
E_PARAM = -703,
E_NO_SEC = -704,
E_NO_KEY = -705,
E_SEC_CORRUPT = -706,
E_SMALL_BUF = -707
};
#endif
/**
* Initialize the INIParser with a nsILocalFile. If this method fails, no
* other methods should be called.
*/
nsresult Init(nsILocalFile* aFile);
/**
* GetString
*
* Gets the value of the specified key in the specified section
* of the INI file represented by this instance. The value is stored
* in the supplied buffer. The buffer size is provided as input and
* the actual bytes used by the value is set in the in/out size param.
*
* @param aSection section name
* @param aKey key name
* @param aValBuf user supplied buffer
* @param aIOValBufSize buf size on input; actual buf used on output
*
* @return mError operation success code
*/
nsresult GetString(const char *aSection, const char *aKey,
char *aValBuf, PRUint32 aIOValBufSize );
private:
nsresult FindSection(const char *aSection, char **aOutSecPtr);
nsresult FindKey(const char *aSecPtr, const char *aKey,
char *aVal, int aIOValSize);
char *mFileBuf;
int mFileBufSize;
};
#endif /* nsINIParser_h__ */

36
mozilla/toolkit/profile/src/nsToolkitProfileService.cpp
View File

@ -403,37 +403,37 @@ nsToolkitProfileService::Init()
nsINIParser parser;
rv = parser.Init(mListFile);
// Parsing errors are troublesome... we're gonna continue even on
// parsing errors, and let people manually re-locate their profile
// if something goes wacky
// Init does not fail on parsing errors, only on OOM/really unexpected
// conditions.
if (NS_FAILED(rv))
return rv;
char parserBuf[MAXPATHLEN];
rv = parser.GetString("General", "StartWithLastProfile", parserBuf, MAXPATHLEN);
if (NS_SUCCEEDED(rv) && strcmp("0", parserBuf) == 0)
nsCAutoString buffer;
rv = parser.GetString("General", "StartWithLastProfile", buffer);
if (NS_SUCCEEDED(rv) && buffer.EqualsLiteral("0"))
mStartWithLast = PR_FALSE;
nsToolkitProfile* currentProfile = nsnull;
nsCAutoString filePath;
unsigned int c = 0;
for (c = 0; PR_TRUE; ++c) {
char profileID[12];
sprintf(profileID, "Profile%u", c);
nsCAutoString profileID("Profile");
profileID.AppendInt(c);
rv = parser.GetString(profileID, "IsRelative", parserBuf, MAXPATHLEN);
rv = parser.GetString(profileID.get(), "IsRelative", buffer);
if (NS_FAILED(rv)) break;
PRBool isRelative = (strcmp(parserBuf, "1") == 0);
PRBool isRelative = buffer.EqualsLiteral("1");
rv = parser.GetString(profileID, "Path", parserBuf, MAXPATHLEN);
nsCAutoString filePath;
rv = parser.GetString(profileID.get(), "Path", filePath);
if (NS_FAILED(rv)) {
NS_ERROR("Malformed profiles.ini: Path= not found");
continue;
}
filePath = parserBuf;
rv = parser.GetString(profileID, "Name", parserBuf, MAXPATHLEN);
rv = parser.GetString(profileID.get(), "Name", buffer);
if (NS_FAILED(rv)) {
NS_ERROR("Malformed profiles.ini: Name= not found");
continue;
@ -462,13 +462,13 @@ nsToolkitProfileService::Init()
localDir = rootDir;
}
currentProfile = new nsToolkitProfile(nsDependentCString(parserBuf),
currentProfile = new nsToolkitProfile(buffer,
rootDir, localDir,
currentProfile);
NS_ENSURE_TRUE(currentProfile, NS_ERROR_OUT_OF_MEMORY);
rv = parser.GetString(profileID, "Default", parserBuf, MAXPATHLEN);
if (NS_SUCCEEDED(rv) && strcmp("1", parserBuf) == 0)
rv = parser.GetString(profileID.get(), "Default", buffer);
if (NS_SUCCEEDED(rv) && buffer.EqualsLiteral("1"))
mChosen = currentProfile;
}

16
mozilla/toolkit/xre/nsAppRunner.cpp
View File

@ -1647,21 +1647,20 @@ CheckCompatibility(nsIFile* aProfileDir, const nsCString& aVersion,
if (NS_FAILED(rv))
return PR_FALSE;
char buffer[MAXPATHLEN];
rv = parser.GetString("Compatibility", "LastVersion", buffer, sizeof(buffer));
nsCAutoString buf;
rv = parser.GetString("Compatibility", "LastVersion", buf);
if (NS_FAILED(rv))
return PR_FALSE;
if (!aVersion.Equals(buffer))
if (!aVersion.Equals(buf))
return PR_FALSE;
rv = parser.GetString("Compatibility", "LastPlatformDir",
buffer, sizeof(buffer));
rv = parser.GetString("Compatibility", "LastPlatformDir", buf);
if (NS_FAILED(rv))
return PR_FALSE;
nsCOMPtr<nsILocalFile> lf;
rv = NS_NewNativeLocalFile(nsDependentCString(buffer), PR_FALSE,
rv = NS_NewNativeLocalFile(buf, PR_FALSE,
getter_AddRefs(lf));
if (NS_FAILED(rv))
return PR_FALSE;
@ -1672,12 +1671,11 @@ CheckCompatibility(nsIFile* aProfileDir, const nsCString& aVersion,
return PR_FALSE;
if (aAppDir) {
rv = parser.GetString("Compatibility", "LastAppDir",
buffer, sizeof(buffer));
rv = parser.GetString("Compatibility", "LastAppDir", buf);
if (NS_FAILED(rv))
return PR_FALSE;
rv = NS_NewNativeLocalFile(nsDependentCString(buffer), PR_FALSE,
rv = NS_NewNativeLocalFile(buf, PR_FALSE,
getter_AddRefs(lf));
if (NS_FAILED(rv))
return PR_FALSE;

15
mozilla/toolkit/xre/nsXREDirProvider.cpp
View File

@ -314,7 +314,9 @@ LoadDirsIntoArray(nsIFile* aComponentsList, const char* aSection,
{
nsINIParser parser;
nsCOMPtr<nsILocalFile> lf(do_QueryInterface(aComponentsList));
parser.Init(lf);
nsresult rv = parser.Init(lf);
if (NS_FAILED(rv))
return;
NS_NAMED_LITERAL_CSTRING(platform, "platform");
NS_NAMED_LITERAL_CSTRING(osTarget, OS_TARGET);
@ -322,14 +324,13 @@ LoadDirsIntoArray(nsIFile* aComponentsList, const char* aSection,
NS_NAMED_LITERAL_CSTRING(targetOSABI, TARGET_OS_ABI);
#endif
nsresult rv;
char parserBuf[MAXPATHLEN];
char buf[18];
PRInt32 i = 0;
do {
sprintf(buf, "Extension%d", i++);
nsCAutoString buf("Extension");
buf.AppendInt(i++);
rv = parser.GetString(aSection, buf, parserBuf, MAXPATHLEN);
nsCAutoString path;
rv = parser.GetString(aSection, buf.get(), path);
if (NS_FAILED(rv))
break;
@ -341,7 +342,7 @@ LoadDirsIntoArray(nsIFile* aComponentsList, const char* aSection,
#ifdef TARGET_OS_ABI
nsCOMPtr<nsIFile> platformABIDir;
#endif
rv = dir->SetPersistentDescriptor(nsDependentCString(parserBuf));
rv = dir->SetPersistentDescriptor(path);
if (NS_FAILED(rv))
continue;

10
mozilla/xpcom/build/Makefile.in
View File

@ -73,9 +73,13 @@ ifneq (,$(filter mac cocoa,$(MOZ_WIDGET_TOOLKIT)))
REQUIRES += macmorefiles
endif
CPPSRCS = \
CSRCS = \
$(XPCOM_GLUE_SRC_LCSRCS) \
$(XPCOM_GLUENS_SRC_LCSRCS) \
$(NULL)
CPPSRCS = \
$(XPCOM_GLUE_SRC_LCPPSRCS) \
$(XPCOM_GLUENS_SRC_LCPPSRCS) \
nsXPComInit.cpp \
nsStringAPI.cpp \
$(NULL)
@ -178,5 +182,5 @@ EXTRA_DSO_LDOPTS += $(call EXPAND_LIBNAME,imagehlp)
endif
endif # WINNT
export:: $(XPCOM_GLUE_SRC_CSRCS) $(XPCOM_GLUENS_SRC_CSRCS)
export:: $(XPCOM_GLUE_SRC_CSRCS) $(XPCOM_GLUE_SRC_CPPSRCS) $(XPCOM_GLUENS_SRC_CPPSRCS)
$(INSTALL) $^ .

13
mozilla/xpcom/ds/Makefile.in
View File

@ -52,10 +52,6 @@ REQUIRES = \
string \
$(NULL)
CSRCS = \
pldhash.c \
$(NULL)
CPPSRCS = \
nsAtomTable.cpp \
nsAtomService.cpp \
@ -79,7 +75,6 @@ CPPSRCS = \
nsSupportsArray.cpp \
nsSupportsArrayEnumerator.cpp \
nsSupportsPrimitives.cpp \
nsTHashtable.cpp \
nsUnicharBuffer.cpp \
nsVariant.cpp \
nsVoidArray.cpp \
@ -94,37 +89,29 @@ CPPSRCS = \
EXPORTS = \
nsAtomService.h \
nsBaseHashtable.h \
nsCheapSets.h \
nsClassHashtable.h \
nsCppSharedAllocator.h \
nsCRT.h \
nsDataHashtable.h \
nsDeque.h \
nsDoubleHashtable.h \
nsEnumeratorUtils.h \
nsFixedSizeAllocator.h \
nsHashSets.h \
nsHashKeys.h \
nsHashtable.h \
nsIByteBuffer.h \
nsIUnicharBuffer.h \
nsInt64.h \
nsInterfaceHashtable.h \
nsObserverService.h \
nsQuickSort.h \
nsRecyclingAllocator.h \
nsRefPtrHashtable.h \
nsStaticNameTable.h \
nsStaticAtom.h \
nsSupportsArray.h \
nsSupportsPrimitives.h \
nsTHashtable.h \
nsTime.h \
nsUnitConversion.h \
nsVariant.h \
nsVoidArray.h \
pldhash.h \
nsTextFormatter.h \
nsValueArray.h \
nsArray.h \

458
mozilla/xpcom/ds/nsBaseHashtable.h
View File

@ -1,458 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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 C++ hashtable templates.
*
* The Initial Developer of the Original Code is
* Benjamin Smedberg.
* Portions created by the Initial Developer are Copyright (C) 2002
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef nsBaseHashtable_h__
#define nsBaseHashtable_h__
#include "nsTHashtable.h"
#include "prlock.h"
#include "nsDebug.h"
template<class KeyClass,class DataType,class UserDataType>
class nsBaseHashtable; // forward declaration
/**
* the private nsTHashtable::EntryType class used by nsBaseHashtable
* @see nsTHashtable for the specification of this class
* @see nsBaseHashtable for template parameters
*/
template<class KeyClass,class DataType>
class nsBaseHashtableET : public KeyClass
{
public:
DataType mData;
friend class nsTHashtable< nsBaseHashtableET<KeyClass,DataType> >;
private:
typedef typename KeyClass::KeyType KeyType;
typedef typename KeyClass::KeyTypePointer KeyTypePointer;
nsBaseHashtableET(KeyTypePointer aKey);
nsBaseHashtableET(nsBaseHashtableET<KeyClass,DataType>& toCopy);
~nsBaseHashtableET();
};
/**
* templated hashtable for simple data types
* This class manages simple data types that do not need construction or
* destruction. Thread-safety is optional, via a flag in Init()
*
* @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
* for a complete specification.
* @param DataType the datatype stored in the hashtable,
* for example, PRUint32 or nsCOMPtr. If UserDataType is not the same,
* DataType must implicitly cast to UserDataType
* @param UserDataType the user sees, for example PRUint32 or nsISupports*
*/
template<class KeyClass,class DataType,class UserDataType>
class nsBaseHashtable :
protected nsTHashtable< nsBaseHashtableET<KeyClass,DataType> >
{
public:
typedef typename KeyClass::KeyType KeyType;
typedef nsBaseHashtableET<KeyClass,DataType> EntryType;
// default constructor+destructor are fine
/**
* Initialize the object.
* @param initSize the initial number of buckets in the hashtable,
* default 16
* @param threadSafe whether to provide read/write
* locking on all class methods
* @return PR_TRUE if the object was initialized properly.
*/
PRBool Init(PRUint32 initSize = PL_DHASH_MIN_SIZE)
{ return nsTHashtable<EntryType>::Init(initSize); }
/**
* Check whether the table has been initialized.
* This function is especially useful for static hashtables.
* @return PR_TRUE if the table has been initialized.
*/
PRBool IsInitialized() const { return this->mTable.entrySize; }
/**
* Return the number of entries in the table.
* @return number of entries
*/
PRUint32 Count() const
{ return nsTHashtable<EntryType>::Count(); }
/**
* retrieve the value for a key.
* @param aKey the key to retreive
* @param pData data associated with this key will be placed at this
* pointer. If you only need to check if the key exists, pData
* may be null.
* @return PR_TRUE if the key exists. If key does not exist, pData is not
* modified.
*/
PRBool Get(KeyType aKey, UserDataType* pData) const
{
EntryType* ent = GetEntry(aKey);
if (!ent)
return PR_FALSE;
if (pData)
*pData = ent->mData;
return PR_TRUE;
}
/**
* put a new value for the associated key
* @param aKey the key to put
* @param aData the new data
* @return always PR_TRUE, unless memory allocation failed
*/
PRBool Put(KeyType aKey, UserDataType aData)
{
EntryType* ent = PutEntry(aKey);
if (!ent)
return PR_FALSE;
ent->mData = aData;
return PR_TRUE;
}
/**
* remove the data for the associated key
* @param aKey the key to remove from the hashtable
*/
void Remove(KeyType aKey) { RemoveEntry(aKey); }
/**
* function type provided by the application for enumeration.
* @param aKey the key being enumerated
* @param aData data being enumerated
* @parm userArg passed unchanged from Enumerate
* @return either
* @link PLDHashOperator::PL_DHASH_NEXT PL_DHASH_NEXT @endlink or
* @link PLDHashOperator::PL_DHASH_STOP PL_DHASH_STOP @endlink
*/
typedef PLDHashOperator
(*PR_CALLBACK EnumReadFunction)(KeyType aKey,
UserDataType aData,
void* userArg);
/**
* enumerate entries in the hashtable, without allowing changes
* this function read-locks the hashtable, so other threads may read keys
* at the same time in multi-thread environments.
* @param enumFunc enumeration callback
* @param userArg passed unchanged to the EnumReadFunction
*/
PRUint32 EnumerateRead(EnumReadFunction enumFunc, void* userArg) const
{
NS_ASSERTION(this->mTable.entrySize,
"nsBaseHashtable was not initialized properly.");
s_EnumReadArgs enumData = { enumFunc, userArg };
return PL_DHashTableEnumerate(NS_CONST_CAST(PLDHashTable*, &this->mTable),
s_EnumReadStub,
&enumData);
}
/**
* function type provided by the application for enumeration.
* @param aKey the key being enumerated
* @param aData Reference to data being enumerated, may be altered. e.g. for
* nsInterfaceHashtable this is an nsCOMPtr reference...
* @parm userArg passed unchanged from Enumerate
* @return bitflag combination of
* @link PLDHashOperator::PL_DHASH_REMOVE @endlink,
* @link PLDHashOperator::PL_DHASH_NEXT PL_DHASH_NEXT @endlink, or
* @link PLDHashOperator::PL_DHASH_STOP PL_DHASH_STOP @endlink
*/
typedef PLDHashOperator
(*PR_CALLBACK EnumFunction)(KeyType aKey,
DataType& aData,
void* userArg);
/**
* enumerate entries in the hashtable, allowing changes. This
* functions write-locks the hashtable.
* @param enumFunc enumeration callback
* @param userArg passed unchanged to the EnumFunction
*/
PRUint32 Enumerate(EnumFunction enumFunc, void* userArg)
{
NS_ASSERTION(this->mTable.entrySize,
"nsBaseHashtable was not initialized properly.");
s_EnumArgs enumData = { enumFunc, userArg };
return PL_DHashTableEnumerate(&this->mTable,
s_EnumStub,
&enumData);
}
/**
* reset the hashtable, removing all entries
*/
void Clear() { nsTHashtable<EntryType>::Clear(); }
protected:
/**
* used internally during EnumerateRead. Allocated on the stack.
* @param func the enumerator passed to EnumerateRead
* @param userArg the userArg passed to EnumerateRead
*/
struct s_EnumReadArgs
{
EnumReadFunction func;
void* userArg;
};
static PLDHashOperator s_EnumReadStub(PLDHashTable *table,
PLDHashEntryHdr *hdr,
PRUint32 number,
void *arg);
struct s_EnumArgs
{
EnumFunction func;
void* userArg;
};
static PLDHashOperator s_EnumStub(PLDHashTable *table,
PLDHashEntryHdr *hdr,
PRUint32 number,
void *arg);
};
/**
* This class is a thread-safe version of nsBaseHashtable.
*/
template<class KeyClass,class DataType,class UserDataType>
class nsBaseHashtableMT :
protected nsBaseHashtable<KeyClass,DataType,UserDataType>
{
public:
typedef typename
nsBaseHashtable<KeyClass,DataType,UserDataType>::EntryType EntryType;
typedef typename
nsBaseHashtable<KeyClass,DataType,UserDataType>::KeyType KeyType;
typedef typename
nsBaseHashtable<KeyClass,DataType,UserDataType>::EnumFunction EnumFunction;
typedef typename
nsBaseHashtable<KeyClass,DataType,UserDataType>::EnumReadFunction EnumReadFunction;
nsBaseHashtableMT() : mLock(nsnull) { }
~nsBaseHashtableMT();
PRBool Init(PRUint32 initSize = PL_DHASH_MIN_SIZE);
PRBool IsInitialized() const { return (PRBool) mLock; }
PRUint32 Count() const;
PRBool Get(KeyType aKey, UserDataType* pData) const;
PRBool Put(KeyType aKey, UserDataType aData);
void Remove(KeyType aKey);
PRUint32 EnumerateRead(EnumReadFunction enumFunc, void* userArg) const;
PRUint32 Enumerate(EnumFunction enumFunc, void* userArg);
void Clear();
protected:
PRLock* mLock;
};
//
// nsBaseHashtableET definitions
//
template<class KeyClass,class DataType>
nsBaseHashtableET<KeyClass,DataType>::nsBaseHashtableET(KeyTypePointer aKey) :
KeyClass(aKey)
{ }
template<class KeyClass,class DataType>
nsBaseHashtableET<KeyClass,DataType>::nsBaseHashtableET
(nsBaseHashtableET<KeyClass,DataType>& toCopy) :
KeyClass(toCopy),
mData(toCopy.mData)
{ }
template<class KeyClass,class DataType>
nsBaseHashtableET<KeyClass,DataType>::~nsBaseHashtableET()
{ }
//
// nsBaseHashtable definitions
//
template<class KeyClass,class DataType,class UserDataType>
PLDHashOperator
nsBaseHashtable<KeyClass,DataType,UserDataType>::s_EnumReadStub
(PLDHashTable *table, PLDHashEntryHdr *hdr, PRUint32 number, void* arg)
{
EntryType* ent = NS_STATIC_CAST(EntryType*, hdr);
s_EnumReadArgs* eargs = (s_EnumReadArgs*) arg;
PLDHashOperator res = (eargs->func)(ent->GetKey(), ent->mData, eargs->userArg);
NS_ASSERTION( !(res & PL_DHASH_REMOVE ),
"PL_DHASH_REMOVE return during const enumeration; ignoring.");
if (res & PL_DHASH_STOP)
return PL_DHASH_STOP;
return PL_DHASH_NEXT;
}
template<class KeyClass,class DataType,class UserDataType>
PLDHashOperator
nsBaseHashtable<KeyClass,DataType,UserDataType>::s_EnumStub
(PLDHashTable *table, PLDHashEntryHdr *hdr, PRUint32 number, void* arg)
{
EntryType* ent = NS_STATIC_CAST(EntryType*, hdr);
s_EnumArgs* eargs = (s_EnumArgs*) arg;
return (eargs->func)(ent->GetKey(), ent->mData, eargs->userArg);
}
//
// nsBaseHashtableMT definitions
//
template<class KeyClass,class DataType,class UserDataType>
nsBaseHashtableMT<KeyClass,DataType,UserDataType>::~nsBaseHashtableMT()
{
if (this->mLock)
PR_DestroyLock(this->mLock);
}
template<class KeyClass,class DataType,class UserDataType>
PRBool
nsBaseHashtableMT<KeyClass,DataType,UserDataType>::Init(PRUint32 initSize)
{
if (!nsTHashtable<EntryType>::IsInitialized() && !nsTHashtable<EntryType>::Init(initSize))
return PR_FALSE;
this->mLock = PR_NewLock();
NS_WARN_IF_FALSE(this->mLock, "Error creating lock during nsBaseHashtableL::Init()");
return (this->mLock != nsnull);
}
template<class KeyClass,class DataType,class UserDataType>
PRUint32
nsBaseHashtableMT<KeyClass,DataType,UserDataType>::Count() const
{
PR_Lock(this->mLock);
PRUint32 count = nsTHashtable<EntryType>::Count();
PR_Unlock(this->mLock);
return count;
}
template<class KeyClass,class DataType,class UserDataType>
PRBool
nsBaseHashtableMT<KeyClass,DataType,UserDataType>::Get(KeyType aKey,
UserDataType* pData) const
{
PR_Lock(this->mLock);
PRBool res =
nsBaseHashtable<KeyClass,DataType,UserDataType>::Get(aKey, pData);
PR_Unlock(this->mLock);
return res;
}
template<class KeyClass,class DataType,class UserDataType>
PRBool
nsBaseHashtableMT<KeyClass,DataType,UserDataType>::Put(KeyType aKey,
UserDataType aData)
{
PR_Lock(this->mLock);
PRBool res =
nsBaseHashtable<KeyClass,DataType,UserDataType>::Put(aKey, aData);
PR_Unlock(this->mLock);
return res;
}
template<class KeyClass,class DataType,class UserDataType>
void
nsBaseHashtableMT<KeyClass,DataType,UserDataType>::Remove(KeyType aKey)
{
PR_Lock(this->mLock);
nsBaseHashtable<KeyClass,DataType,UserDataType>::Remove(aKey);
PR_Unlock(this->mLock);
}
template<class KeyClass,class DataType,class UserDataType>
PRUint32
nsBaseHashtableMT<KeyClass,DataType,UserDataType>::EnumerateRead
(EnumReadFunction fEnumCall, void* userArg) const
{
PR_Lock(this->mLock);
PRUint32 count =
nsBaseHashtable<KeyClass,DataType,UserDataType>::EnumerateRead(fEnumCall, userArg);
PR_Unlock(this->mLock);
return count;
}
template<class KeyClass,class DataType,class UserDataType>
PRUint32
nsBaseHashtableMT<KeyClass,DataType,UserDataType>::Enumerate
(EnumFunction fEnumCall, void* userArg)
{
PR_Lock(this->mLock);
PRUint32 count =
nsBaseHashtable<KeyClass,DataType,UserDataType>::Enumerate(fEnumCall, userArg);
PR_Unlock(this->mLock);
return count;
}
template<class KeyClass,class DataType,class UserDataType>
void
nsBaseHashtableMT<KeyClass,DataType,UserDataType>::Clear()
{
PR_Lock(this->mLock);
nsBaseHashtable<KeyClass,DataType,UserDataType>::Clear();
PR_Unlock(this->mLock);
}
#endif // nsBaseHashtable_h__

149
mozilla/xpcom/ds/nsClassHashtable.h
View File

@ -1,149 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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 C++ hashtable templates.
*
* The Initial Developer of the Original Code is
* Benjamin Smedberg.
* Portions created by the Initial Developer are Copyright (C) 2002
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef nsClassHashtable_h__
#define nsClassHashtable_h__
#include "nsBaseHashtable.h"
#include "nsHashKeys.h"
#include "nsAutoPtr.h"
/**
* templated hashtable class maps keys to C++ object pointers.
* See nsBaseHashtable for complete declaration.
* @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
* for a complete specification.
* @param Class the class-type being wrapped
* @see nsInterfaceHashtable, nsClassHashtable
*/
template<class KeyClass,class T>
class nsClassHashtable :
public nsBaseHashtable< KeyClass, nsAutoPtr<T>, T* >
{
public:
typedef typename KeyClass::KeyType KeyType;
typedef T* UserDataType;
/**
* @copydoc nsBaseHashtable::Get
* @param pData if the key doesn't exist, pData will be set to nsnull.
*/
PRBool Get(KeyType aKey, UserDataType* pData) const;
};
/**
* Thread-safe version of nsClassHashtable
* @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
* for a complete specification.
* @param Class the class-type being wrapped
* @see nsInterfaceHashtable, nsClassHashtable
*/
template<class KeyClass,class T>
class nsClassHashtableMT :
public nsBaseHashtableMT< KeyClass, nsAutoPtr<T>, T* >
{
public:
typedef typename KeyClass::KeyType KeyType;
typedef T* UserDataType;
/**
* @copydoc nsBaseHashtable::Get
* @param pData if the key doesn't exist, pData will be set to nsnull.
*/
PRBool Get(KeyType aKey, UserDataType* pData) const;
};
//
// nsClassHashtable definitions
//
template<class KeyClass,class T>
PRBool
nsClassHashtable<KeyClass,T>::Get(KeyType aKey, T** retVal) const
{
typename nsBaseHashtable<KeyClass,nsAutoPtr<T>,T*>::EntryType* ent =
GetEntry(aKey);
if (ent)
{
if (retVal)
*retVal = ent->mData;
return PR_TRUE;
}
if (retVal)
*retVal = nsnull;
return PR_FALSE;
}
//
// nsClassHashtableMT definitions
//
template<class KeyClass,class T>
PRBool
nsClassHashtableMT<KeyClass,T>::Get(KeyType aKey, T** retVal) const
{
PR_Lock(this->mLock);
typename nsBaseHashtableMT<KeyClass,nsAutoPtr<T>,T*>::EntryType* ent =
GetEntry(aKey);
if (ent)
{
if (retVal)
*retVal = ent->mData;
PR_Unlock(this->mLock);
return PR_TRUE;
}
if (retVal)
*retVal = nsnull;
PR_Unlock(this->mLock);
return PR_FALSE;
}
#endif // nsClassHashtable_h__

62
mozilla/xpcom/ds/nsDataHashtable.h
View File

@ -1,62 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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 C++ hashtable templates.
*
* The Initial Developer of the Original Code is
* Benjamin Smedberg.
* Portions created by the Initial Developer are Copyright (C) 2002
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef nsDataHashtable_h__
#define nsDataHashtable_h__
#include "nsHashKeys.h"
#include "nsBaseHashtable.h"
/**
* templated hashtable class maps keys to simple datatypes.
* See nsBaseHashtable for complete declaration
* @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
* for a complete specification.
* @param DataType the simple datatype being wrapped
* @see nsInterfaceHashtable, nsClassHashtable
*/
template<class KeyClass,class DataType>
class nsDataHashtable :
public nsBaseHashtable<KeyClass,DataType,DataType>
{ };
template<class KeyClass,class DataType>
class nsDataHashtableMT :
public nsBaseHashtableMT<KeyClass,DataType,DataType>
{ };
#endif // nsDataHashtable_h__

2
mozilla/xpcom/ds/nsDoubleHashtable.h
View File

@ -45,7 +45,7 @@
#include "pldhash.h"
#include "nscore.h"
#include "nsString.h"
#include "nsReadableUtils.h"
#include "nsHashKeys.h"
/*
* This file provides several major things to make PLDHashTable easier to use:

315
mozilla/xpcom/ds/nsHashKeys.h
View File

@ -1,315 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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 C++ hashtable templates.
*
* The Initial Developer of the Original Code is
* Benjamin Smedberg.
* Portions created by the Initial Developer are Copyright (C) 2002
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef nsTHashKeys_h__
#define nsTHashKeys_h__
#include "nsAString.h"
#include "nsString.h"
#include "nsID.h"
#include "nsCRT.h"
#include "nsReadableUtils.h"
#include "nsISupports.h"
#include "nsCOMPtr.h"
#include "pldhash.h"
#include NEW_H
/** @file nsHashKeys.h
* standard HashKey classes for nsBaseHashtable and relatives. Each of these
* classes follows the nsTHashtable::EntryType specification
*
* Lightweight keytypes provided here:
* nsStringHashKey
* nsCStringHashKey
* nsUint32HashKey
* nsISupportsHashKey
* nsIDHashKey
* nsDepCharHashKey
*/
/**
* hashkey wrapper using nsAString KeyType
*
* @see nsTHashtable::EntryType for specification
*/
class NS_COM nsStringHashKey : public PLDHashEntryHdr
{
public:
typedef const nsAString& KeyType;
typedef const nsAString* KeyTypePointer;
nsStringHashKey(KeyTypePointer aStr) : mStr(*aStr) { }
nsStringHashKey(const nsStringHashKey& toCopy) : mStr(toCopy.mStr) { }
~nsStringHashKey() { }
KeyType GetKey() const { return mStr; }
KeyTypePointer GetKeyPointer() const { return &mStr; }
PRBool KeyEquals(const KeyTypePointer aKey) const
{
return mStr.Equals(*aKey);
}
static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
static PLDHashNumber HashKey(const KeyTypePointer aKey)
{
return HashString(*aKey);
}
enum { ALLOW_MEMMOVE = PR_TRUE };
private:
const nsString mStr;
};
/**
* hashkey wrapper using nsACString KeyType
*
* @see nsTHashtable::EntryType for specification
*/
class NS_COM nsCStringHashKey : public PLDHashEntryHdr
{
public:
typedef const nsACString& KeyType;
typedef const nsACString* KeyTypePointer;
nsCStringHashKey(const nsACString* aStr) : mStr(*aStr) { }
nsCStringHashKey(const nsCStringHashKey& toCopy) : mStr(toCopy.mStr) { }
~nsCStringHashKey() { }
KeyType GetKey() const { return mStr; }
KeyTypePointer GetKeyPointer() const { return &mStr; }
PRBool KeyEquals(KeyTypePointer aKey) const { return mStr.Equals(*aKey); }
static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
static PLDHashNumber HashKey(KeyTypePointer aKey)
{
return HashString(*aKey);
}
enum { ALLOW_MEMMOVE = PR_TRUE };
private:
const nsCString mStr;
};
/**
* hashkey wrapper using PRUint32 KeyType
*
* @see nsTHashtable::EntryType for specification
*/
class NS_COM nsUint32HashKey : public PLDHashEntryHdr
{
public:
typedef const PRUint32& KeyType;
typedef const PRUint32* KeyTypePointer;
nsUint32HashKey(KeyTypePointer aKey) : mValue(*aKey) { }
nsUint32HashKey(const nsUint32HashKey& toCopy) : mValue(toCopy.mValue) { }
~nsUint32HashKey() { }
KeyType GetKey() const { return mValue; }
KeyTypePointer GetKeyPointer() const { return &mValue; }
PRBool KeyEquals(KeyTypePointer aKey) const { return *aKey == mValue; }
static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
static PLDHashNumber HashKey(KeyTypePointer aKey) { return *aKey; }
enum { ALLOW_MEMMOVE = PR_TRUE };
private:
const PRUint32 mValue;
};
/**
* hashkey wrapper using nsISupports* KeyType
*
* @see nsTHashtable::EntryType for specification
*/
class NS_COM nsISupportsHashKey : public PLDHashEntryHdr
{
public:
typedef nsISupports* KeyType;
typedef const nsISupports* KeyTypePointer;
nsISupportsHashKey(const nsISupports* key) :
mSupports(NS_CONST_CAST(nsISupports*,key)) { }
nsISupportsHashKey(const nsISupportsHashKey& toCopy) :
mSupports(toCopy.mSupports) { }
~nsISupportsHashKey() { }
KeyType GetKey() const { return mSupports; }
KeyTypePointer GetKeyPointer() const { return mSupports; }
PRBool KeyEquals(KeyTypePointer aKey) const { return aKey == mSupports; }
static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
static PLDHashNumber HashKey(KeyTypePointer aKey)
{
return NS_PTR_TO_INT32(aKey) >>2;
}
enum { ALLOW_MEMMOVE = PR_TRUE };
private:
nsCOMPtr<nsISupports> mSupports;
};
/**
* hashkey wrapper using void* KeyType
*
* @see nsTHashtable::EntryType for specification
*/
class NS_COM nsVoidPtrHashKey : public PLDHashEntryHdr
{
public:
typedef const void* KeyType;
typedef const void* KeyTypePointer;
nsVoidPtrHashKey(const void* key) :
mKey(key) { }
nsVoidPtrHashKey(const nsVoidPtrHashKey& toCopy) :
mKey(toCopy.mKey) { }
~nsVoidPtrHashKey() { }
KeyType GetKey() const { return mKey; }
KeyTypePointer GetKeyPointer() const { return mKey; }
PRBool KeyEquals(KeyTypePointer aKey) const { return aKey == mKey; }
static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
static PLDHashNumber HashKey(KeyTypePointer aKey)
{
return NS_PTR_TO_INT32(aKey) >>2;
}
enum { ALLOW_MEMMOVE = PR_TRUE };
private:
const void* mKey;
};
/**
* hashkey wrapper using nsID KeyType
*
* @see nsTHashtable::EntryType for specification
*/
class NS_COM nsIDHashKey : public PLDHashEntryHdr
{
public:
typedef const nsID& KeyType;
typedef const nsID* KeyTypePointer;
nsIDHashKey(const nsID* id) : mID(*id) { }
nsIDHashKey(const nsIDHashKey& toCopy) : mID(toCopy.mID) { }
~nsIDHashKey() { }
KeyType GetKey() const { return mID; }
KeyTypePointer GetKeyPointer() const { return &mID; }
PRBool KeyEquals(KeyTypePointer aKey) const { return aKey->Equals(mID); }
static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
static PLDHashNumber HashKey(KeyTypePointer aKey);
enum { ALLOW_MEMMOVE = PR_TRUE };
private:
const nsID mID;
};
/**
* hashkey wrapper for "dependent" const char*; this class does not "own"
* its string pointer.
*
* This class must only be used if the strings have a lifetime longer than
* the hashtable they occupy. This normally occurs only for static
* strings or strings that have been arena-allocated.
*
* @see nsTHashtable::EntryType for specification
*/
class NS_COM nsDepCharHashKey : public PLDHashEntryHdr
{
public:
typedef const char* KeyType;
typedef const char* KeyTypePointer;
nsDepCharHashKey(const char* aKey) { mKey = aKey; }
nsDepCharHashKey(const nsDepCharHashKey& toCopy) { mKey = toCopy.mKey; }
~nsDepCharHashKey() { }
const char* GetKey() const { return mKey; }
const char* GetKeyPointer() const { return mKey; }
PRBool KeyEquals(const char* aKey) const
{
return !strcmp(mKey, aKey);
}
static const char* KeyToPointer(const char* aKey) { return aKey; }
static PLDHashNumber HashKey(const char* aKey) { return nsCRT::HashCode(aKey); }
enum { ALLOW_MEMMOVE = PR_TRUE };
private:
const char* mKey;
};
/**
* hashkey wrapper for const char*; at construction, this class duplicates
* a string pointed to by the pointer so that it doesn't matter whether or not
* the string lives longer than the hash table.
*/
class NS_COM nsCharPtrHashKey : public PLDHashEntryHdr
{
public:
typedef const char* KeyType;
typedef const char* KeyTypePointer;
nsCharPtrHashKey(const char* aKey) : mKey(strdup(aKey)) { }
nsCharPtrHashKey(const nsCharPtrHashKey& toCopy) : mKey(strdup(toCopy.mKey)) { }
~nsCharPtrHashKey() { if (mKey) free(NS_CONST_CAST(char *, mKey)); }
const char* GetKey() const { return mKey; }
const char* GetKeyPointer() const { return mKey; }
PRBool KeyEquals(KeyTypePointer aKey) const
{
return !strcmp(mKey, aKey);
}
static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
static PLDHashNumber HashKey(KeyTypePointer aKey) { return nsCRT::HashCode(aKey); }
enum { ALLOW_MEMMOVE = PR_TRUE };
private:
const char* mKey;
};
#endif // nsTHashKeys_h__

196
mozilla/xpcom/ds/nsInterfaceHashtable.h
View File

@ -1,196 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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 C++ hashtable templates.
*
* The Initial Developer of the Original Code is
* Benjamin Smedberg.
* Portions created by the Initial Developer are Copyright (C) 2002
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef nsInterfaceHashtable_h__
#define nsInterfaceHashtable_h__
#include "nsBaseHashtable.h"
#include "nsHashKeys.h"
#include "nsCOMPtr.h"
/**
* templated hashtable class maps keys to interface pointers.
* See nsBaseHashtable for complete declaration.
* @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
* for a complete specification.
* @param Interface the interface-type being wrapped
* @see nsDataHashtable, nsClassHashtable
*/
template<class KeyClass,class Interface>
class nsInterfaceHashtable :
public nsBaseHashtable< KeyClass, nsCOMPtr<Interface> , Interface* >
{
public:
typedef typename KeyClass::KeyType KeyType;
typedef Interface* UserDataType;
/**
* @copydoc nsBaseHashtable::Get
* @param pData This is an XPCOM getter, so pData is already_addrefed.
* If the key doesn't exist, pData will be set to nsnull.
*/
PRBool Get(KeyType aKey, UserDataType* pData) const;
/**
* Gets a weak reference to the hashtable entry.
* @param aFound If not nsnull, will be set to PR_TRUE if the entry is found,
* to PR_FALSE otherwise.
* @return The entry, or nsnull if not found. Do not release this pointer!
*/
Interface* GetWeak(KeyType aKey, PRBool* aFound = nsnull) const;
};
/**
* Thread-safe version of nsInterfaceHashtable
* @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
* for a complete specification.
* @param Interface the interface-type being wrapped
*/
template<class KeyClass,class Interface>
class nsInterfaceHashtableMT :
public nsBaseHashtableMT< KeyClass, nsCOMPtr<Interface> , Interface* >
{
public:
typedef typename KeyClass::KeyType KeyType;
typedef Interface* UserDataType;
/**
* @copydoc nsBaseHashtable::Get
* @param pData This is an XPCOM getter, so pData is already_addrefed.
* If the key doesn't exist, pData will be set to nsnull.
*/
PRBool Get(KeyType aKey, UserDataType* pData) const;
// GetWeak does not make sense on a multi-threaded hashtable, where another
// thread may remove the entry (and hence release it) as soon as GetWeak
// returns
};
//
// nsInterfaceHashtable definitions
//
template<class KeyClass,class Interface>
PRBool
nsInterfaceHashtable<KeyClass,Interface>::Get
(KeyType aKey, UserDataType* pInterface) const
{
typename nsBaseHashtable<KeyClass, nsCOMPtr<Interface>, Interface*>::EntryType* ent =
GetEntry(aKey);
if (ent)
{
if (pInterface)
{
*pInterface = ent->mData;
NS_IF_ADDREF(*pInterface);
}
return PR_TRUE;
}
// if the key doesn't exist, set *pInterface to null
// so that it is a valid XPCOM getter
if (pInterface)
*pInterface = nsnull;
return PR_FALSE;
}
template<class KeyClass,class Interface>
Interface*
nsInterfaceHashtable<KeyClass,Interface>::GetWeak
(KeyType aKey, PRBool* aFound) const
{
typename nsBaseHashtable<KeyClass, nsCOMPtr<Interface>, Interface*>::EntryType* ent =
GetEntry(aKey);
if (ent)
{
if (aFound)
*aFound = PR_TRUE;
return ent->mData;
}
// Key does not exist, return nsnull and set aFound to PR_FALSE
if (aFound)
*aFound = PR_FALSE;
return nsnull;
}
//
// nsInterfaceHashtableMT definitions
//
template<class KeyClass,class Interface>
PRBool
nsInterfaceHashtableMT<KeyClass,Interface>::Get
(KeyType aKey, UserDataType* pInterface) const
{
PR_Lock(this->mLock);
typename nsBaseHashtableMT<KeyClass, nsCOMPtr<Interface>, Interface*>::EntryType* ent =
GetEntry(aKey);
if (ent)
{
if (pInterface)
{
*pInterface = ent->mData;
NS_IF_ADDREF(*pInterface);
}
PR_Unlock(this->mLock);
return PR_TRUE;
}
// if the key doesn't exist, set *pInterface to null
// so that it is a valid XPCOM getter
if (pInterface)
*pInterface = nsnull;
PR_Unlock(this->mLock);
return PR_FALSE;
}
#endif // nsInterfaceHashtable_h__

1
mozilla/xpcom/ds/nsProperties.cpp
View File

@ -37,6 +37,7 @@
#include "nsProperties.h"
#include "nsString.h"
#include "nsCRT.h"
////////////////////////////////////////////////////////////////////////////////

197
mozilla/xpcom/ds/nsRefPtrHashtable.h
View File

@ -1,197 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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 C++ hashtable templates.
*
* The Initial Developer of the Original Code is
* Benjamin Smedberg.
* Portions created by the Initial Developer are Copyright (C) 2002
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Neil Rashbrook <neil@parkwaycc.co.uk>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef nsRefPtrHashtable_h__
#define nsRefPtrHashtable_h__
#include "nsBaseHashtable.h"
#include "nsHashKeys.h"
#include "nsAutoPtr.h"
/**
* templated hashtable class maps keys to reference pointers.
* See nsBaseHashtable for complete declaration.
* @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
* for a complete specification.
* @param RefPtr the reference-type being wrapped
* @see nsDataHashtable, nsClassHashtable
*/
template<class KeyClass, class RefPtr>
class nsRefPtrHashtable :
public nsBaseHashtable< KeyClass, nsRefPtr<RefPtr> , RefPtr* >
{
public:
typedef typename KeyClass::KeyType KeyType;
typedef RefPtr* UserDataType;
/**
* @copydoc nsBaseHashtable::Get
* @param pData This is an XPCOM getter, so pData is already_addrefed.
* If the key doesn't exist, pData will be set to nsnull.
*/
PRBool Get(KeyType aKey, UserDataType* pData) const;
/**
* Gets a weak reference to the hashtable entry.
* @param aFound If not nsnull, will be set to PR_TRUE if the entry is found,
* to PR_FALSE otherwise.
* @return The entry, or nsnull if not found. Do not release this pointer!
*/
RefPtr* GetWeak(KeyType aKey, PRBool* aFound = nsnull) const;
};
/**
* Thread-safe version of nsRefPtrHashtable
* @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
* for a complete specification.
* @param RefPtr the reference-type being wrapped
*/
template<class KeyClass, class RefPtr>
class nsRefPtrHashtableMT :
public nsBaseHashtableMT< KeyClass, nsRefPtr<RefPtr> , RefPtr* >
{
public:
typedef typename KeyClass::KeyType KeyType;
typedef RefPtr* UserDataType;
/**
* @copydoc nsBaseHashtable::Get
* @param pData This is an XPCOM getter, so pData is already_addrefed.
* If the key doesn't exist, pData will be set to nsnull.
*/
PRBool Get(KeyType aKey, UserDataType* pData) const;
// GetWeak does not make sense on a multi-threaded hashtable, where another
// thread may remove the entry (and hence release it) as soon as GetWeak
// returns
};
//
// nsRefPtrHashtable definitions
//
template<class KeyClass, class RefPtr>
PRBool
nsRefPtrHashtable<KeyClass,RefPtr>::Get
(KeyType aKey, UserDataType* pRefPtr) const
{
typename nsBaseHashtable<KeyClass, nsRefPtr<RefPtr>, RefPtr*>::EntryType* ent =
GetEntry(aKey);
if (ent)
{
if (pRefPtr)
{
*pRefPtr = ent->mData;
NS_IF_ADDREF(*pRefPtr);
}
return PR_TRUE;
}
// if the key doesn't exist, set *pRefPtr to null
// so that it is a valid XPCOM getter
if (pRefPtr)
*pRefPtr = nsnull;
return PR_FALSE;
}
template<class KeyClass, class RefPtr>
RefPtr*
nsRefPtrHashtable<KeyClass,RefPtr>::GetWeak
(KeyType aKey, PRBool* aFound) const
{
typename nsBaseHashtable<KeyClass, nsRefPtr<RefPtr>, RefPtr*>::EntryType* ent =
GetEntry(aKey);
if (ent)
{
if (aFound)
*aFound = PR_TRUE;
return ent->mData;
}
// Key does not exist, return nsnull and set aFound to PR_FALSE
if (aFound)
*aFound = PR_FALSE;
return nsnull;
}
//
// nsRefPtrHashtableMT definitions
//
template<class KeyClass, class RefPtr>
PRBool
nsRefPtrHashtableMT<KeyClass,RefPtr>::Get
(KeyType aKey, UserDataType* pRefPtr) const
{
PR_Lock(this->mLock);
typename nsBaseHashtableMT<KeyClass, nsRefPtr<RefPtr>, RefPtr*>::EntryType* ent =
GetEntry(aKey);
if (ent)
{
if (pRefPtr)
{
*pRefPtr = ent->mData;
NS_IF_ADDREF(*pRefPtr);
}
PR_Unlock(this->mLock);
return PR_TRUE;
}
// if the key doesn't exist, set *pRefPtr to null
// so that it is a valid XPCOM getter
if (pRefPtr)
*pRefPtr = nsnull;
PR_Unlock(this->mLock);
return PR_FALSE;
}
#endif // nsRefPtrHashtable_h__

429
mozilla/xpcom/ds/nsTHashtable.h
View File

@ -1,429 +0,0 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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 C++ hashtable templates.
*
* The Initial Developer of the Original Code is
* Benjamin Smedberg.
* Portions created by the Initial Developer are Copyright (C) 2002
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef nsTHashtable_h__
#define nsTHashtable_h__
#include "nscore.h"
#include "pldhash.h"
#include "nsDebug.h"
#include NEW_H
// helper function for nsTHashtable::Clear()
PR_EXTERN(PLDHashOperator) PR_CALLBACK
PL_DHashStubEnumRemove(PLDHashTable *table,
PLDHashEntryHdr *entry,
PRUint32 ordinal,
void *userArg);
/**
* a base class for templated hashtables.
*
* Clients will rarely need to use this class directly. Check the derived
* classes first, to see if they will meet your needs.
*
* @param EntryType the templated entry-type class that is managed by the
* hashtable. <code>EntryType</code> must extend the following declaration,
* and <strong>must not declare any virtual functions or derive from classes
* with virtual functions.</strong> Any vtable pointer would break the
* PLDHashTable code.
*<pre> class EntryType : public PLDHashEntryHdr
* {
* public: or friend nsTHashtable<EntryType>;
* // KeyType is what we use when Get()ing or Put()ing this entry
* // this should either be a simple datatype (PRUint32, nsISupports*) or
* // a const reference (const nsAString&)
* typedef something KeyType;
* // KeyTypePointer is the pointer-version of KeyType, because pldhash.h
* // requires keys to cast to <code>const void*</code>
* typedef const something* KeyTypePointer;
*
* EntryType(KeyTypePointer aKey);
*
* // the copy constructor must be defined, even if AllowMemMove() == true
* // or you will cause link errors!
* EntryType(const EntryType& aEnt);
*
* // the destructor must be defined... or you will cause link errors!
* ~EntryType();
*
* // return the key of this entry
* const KeyTypePointer GetKeyPointer() const;
*
* // KeyEquals(): does this entry match this key?
* PRBool KeyEquals(KeyTypePointer aKey) const;
*
* // KeyToPointer(): Convert KeyType to KeyTypePointer
* static KeyTypePointer KeyToPointer(KeyType aKey);
*
* // HashKey(): calculate the hash number
* static PLDHashNumber HashKey(KeyTypePointer aKey);
*
* // ALLOW_MEMMOVE can we move this class with memmove(), or do we have
* // to use the copy constructor?
* enum { ALLOW_MEMMOVE = PR_(TRUE or FALSE) };
* }</pre>
*
* @see nsInterfaceHashtable
* @see nsDataHashtable
* @see nsClassHashtable
* @author "Benjamin Smedberg <bsmedberg@covad.net>"
*/
template<class EntryType>
class nsTHashtable
{
public:
/**
* A dummy constructor; you must call Init() before using this class.
*/
nsTHashtable();
/**
* destructor, cleans up and deallocates
*/
~nsTHashtable();
/**
* Initialize the table. This function must be called before any other
* class operations. This can fail due to OOM conditions.
* @param initSize the initial number of buckets in the hashtable, default 16
* @return PR_TRUE if the class was initialized properly.
*/
PRBool Init(PRUint32 initSize = PL_DHASH_MIN_SIZE);
/**
* Check whether the table has been initialized. This can be useful for static hashtables.
* @return the initialization state of the class.
*/
PRBool IsInitialized() const { return mTable.entrySize; }
/**
* KeyType is typedef'ed for ease of use.
*/
typedef typename EntryType::KeyType KeyType;
/**
* KeyTypePointer is typedef'ed for ease of use.
*/
typedef typename EntryType::KeyTypePointer KeyTypePointer;
/**
* Return the number of entries in the table.
* @return number of entries
*/
PRUint32 Count() const { return mTable.entryCount; }
/**
* Get the entry associated with a key.
* @param aKey the key to retrieve
* @return pointer to the entry class, if the key exists; nsnull if the
* key doesn't exist
*/
EntryType* GetEntry(KeyType aKey) const
{
NS_ASSERTION(mTable.entrySize, "nsTHashtable was not initialized properly.");
EntryType* entry =
NS_REINTERPRET_CAST(EntryType*,
PL_DHashTableOperate(
NS_CONST_CAST(PLDHashTable*,&mTable),
EntryType::KeyToPointer(aKey),
PL_DHASH_LOOKUP));
return PL_DHASH_ENTRY_IS_BUSY(entry) ? entry : nsnull;
}
/**
* Get the entry associated with a key, or create a new entry,
* @param aKey the key to retrieve
* @return pointer to the entry class retreived; nsnull only if memory
can't be allocated
*/
EntryType* PutEntry(KeyType aKey)
{
NS_ASSERTION(mTable.entrySize, "nsTHashtable was not initialized properly.");
return NS_STATIC_CAST(EntryType*,
PL_DHashTableOperate(
&mTable,
EntryType::KeyToPointer(aKey),
PL_DHASH_ADD));
}
/**
* Remove the entry associated with a key.
* @param aKey of the entry to remove
*/
void RemoveEntry(KeyType aKey)
{
NS_ASSERTION(mTable.entrySize, "nsTHashtable was not initialized properly.");
PL_DHashTableOperate(&mTable,
EntryType::KeyToPointer(aKey),
PL_DHASH_REMOVE);
}
/**
* Remove the entry associated with a key, but don't resize the hashtable.
* This is a low-level method, and is not recommended unless you know what
* you're doing and you need the extra performance. This method can be used
* during enumeration, while RemoveEntry() cannot.
* @param aEntry the entry-pointer to remove (obtained from GetEntry or
* the enumerator
*/
void RawRemoveEntry(EntryType* aEntry)
{
PL_DHashTableRawRemove(&mTable, aEntry);
}
/**
* client must provide an <code>Enumerator</code> function for
* EnumerateEntries
* @param aEntry the entry being enumerated
* @param userArg passed unchanged from <code>EnumerateEntries</code>
* @return combination of flags
* @link PLDHashOperator::PL_DHASH_NEXT PL_DHASH_NEXT @endlink ,
* @link PLDHashOperator::PL_DHASH_STOP PL_DHASH_STOP @endlink ,
* @link PLDHashOperator::PL_DHASH_REMOVE PL_DHASH_REMOVE @endlink
*/
typedef PLDHashOperator (*PR_CALLBACK Enumerator)(EntryType* aEntry, void* userArg);
/**
* Enumerate all the entries of the function.
* @param enumFunc the <code>Enumerator</code> function to call
* @param userArg a pointer to pass to the
* <code>Enumerator</code> function
* @return the number of entries actually enumerated
*/
PRUint32 EnumerateEntries(Enumerator enumFunc, void* userArg)
{
NS_ASSERTION(mTable.entrySize, "nsTHashtable was not initialized properly.");
s_EnumArgs args = { enumFunc, userArg };
return PL_DHashTableEnumerate(&mTable, s_EnumStub, &args);
}
/**
* remove all entries, return hashtable to "pristine" state ;)
*/
void Clear()
{
NS_ASSERTION(mTable.entrySize, "nsTHashtable was not initialized properly.");
PL_DHashTableEnumerate(&mTable, PL_DHashStubEnumRemove, nsnull);
}
protected:
PLDHashTable mTable;
static const void* PR_CALLBACK s_GetKey(PLDHashTable *table,
PLDHashEntryHdr *entry);
static PLDHashNumber PR_CALLBACK s_HashKey(PLDHashTable *table,
const void *key);
static PRBool PR_CALLBACK s_MatchEntry(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key);
static void PR_CALLBACK s_CopyEntry(PLDHashTable *table,
const PLDHashEntryHdr *from,
PLDHashEntryHdr *to);
static void PR_CALLBACK s_ClearEntry(PLDHashTable *table,
PLDHashEntryHdr *entry);
static PRBool PR_CALLBACK s_InitEntry(PLDHashTable *table,
PLDHashEntryHdr *entry,
const void *key);
/**
* passed internally during enumeration. Allocated on the stack.
*
* @param userFunc the Enumerator function passed to
* EnumerateEntries by the client
* @param userArg the userArg passed unaltered
*/
struct s_EnumArgs
{
Enumerator userFunc;
void* userArg;
};
static PLDHashOperator PR_CALLBACK s_EnumStub(PLDHashTable *table,
PLDHashEntryHdr *entry,
PRUint32 number,
void *arg);
private:
// copy constructor, not implemented
nsTHashtable(nsTHashtable<EntryType>& toCopy);
// assignment operator, not implemented
nsTHashtable<EntryType>& operator= (nsTHashtable<EntryType>& toEqual);
};
//
// template definitions
//
template<class EntryType>
nsTHashtable<EntryType>::nsTHashtable()
{
// entrySize is our "I'm initialized" indicator
mTable.entrySize = 0;
}
template<class EntryType>
nsTHashtable<EntryType>::~nsTHashtable()
{
if (mTable.entrySize)
PL_DHashTableFinish(&mTable);
}
template<class EntryType>
PRBool
nsTHashtable<EntryType>::Init(PRUint32 initSize)
{
if (mTable.entrySize)
{
NS_ERROR("nsTHashtable::Init() should not be called twice.");
return PR_TRUE;
}
static PLDHashTableOps sOps =
{
::PL_DHashAllocTable,
::PL_DHashFreeTable,
s_GetKey,
s_HashKey,
s_MatchEntry,
::PL_DHashMoveEntryStub,
s_ClearEntry,
::PL_DHashFinalizeStub,
s_InitEntry
};
if (!EntryType::ALLOW_MEMMOVE)
{
sOps.moveEntry = s_CopyEntry;
}
if (!PL_DHashTableInit(&mTable, &sOps, nsnull, sizeof(EntryType), initSize))
{
// if failed, reset "flag"
mTable.entrySize = 0;
return PR_FALSE;
}
return PR_TRUE;
}
// static definitions
template<class EntryType>
const void*
nsTHashtable<EntryType>::s_GetKey(PLDHashTable *table,
PLDHashEntryHdr *entry)
{
return ((EntryType*) entry)->GetKeyPointer();
}
template<class EntryType>
PLDHashNumber
nsTHashtable<EntryType>::s_HashKey(PLDHashTable *table,
const void *key)
{
return EntryType::HashKey(NS_REINTERPRET_CAST(const KeyTypePointer, key));
}
template<class EntryType>
PRBool
nsTHashtable<EntryType>::s_MatchEntry(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key)
{
return ((const EntryType*) entry)->KeyEquals(
NS_REINTERPRET_CAST(const KeyTypePointer, key));
}
template<class EntryType>
void
nsTHashtable<EntryType>::s_CopyEntry(PLDHashTable *table,
const PLDHashEntryHdr *from,
PLDHashEntryHdr *to)
{
EntryType* fromEntry =
NS_CONST_CAST(EntryType*, NS_REINTERPRET_CAST(const EntryType*, from));
new(to) EntryType(*fromEntry);
fromEntry->~EntryType();
}
template<class EntryType>
void
nsTHashtable<EntryType>::s_ClearEntry(PLDHashTable *table,
PLDHashEntryHdr *entry)
{
NS_REINTERPRET_CAST(EntryType*,entry)->~EntryType();
}
template<class EntryType>
PRBool
nsTHashtable<EntryType>::s_InitEntry(PLDHashTable *table,
PLDHashEntryHdr *entry,
const void *key)
{
new(entry) EntryType(NS_REINTERPRET_CAST(KeyTypePointer,key));
return PR_TRUE;
}
template<class EntryType>
PLDHashOperator
nsTHashtable<EntryType>::s_EnumStub(PLDHashTable *table,
PLDHashEntryHdr *entry,
PRUint32 number,
void *arg)
{
// dereferences the function-pointer to the user's enumeration function
return (* NS_REINTERPRET_CAST(s_EnumArgs*,arg)->userFunc)(
NS_REINTERPRET_CAST(EntryType*,entry),
NS_REINTERPRET_CAST(s_EnumArgs*,arg)->userArg);
}
#endif // nsTHashtable_h__

764
mozilla/xpcom/ds/pldhash.c
View File

@ -1,764 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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 JavaScript code.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1999-2001
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Brendan Eich <brendan@mozilla.org> (Original Author)
* Chris Waterson <waterson@netscape.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
/*
* Double hashing implementation.
* GENERATED BY js/src/plify_jsdhash.sed -- DO NOT EDIT!!!
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "prbit.h"
#include "pldhash.h"
#include "prlog.h" /* for PR_ASSERT */
#ifdef PL_DHASHMETER
# if defined MOZILLA_CLIENT && defined DEBUG_XXXbrendan
# include "nsTraceMalloc.h"
# endif
# define METER(x) x
#else
# define METER(x) /* nothing */
#endif
PR_IMPLEMENT(void *)
PL_DHashAllocTable(PLDHashTable *table, PRUint32 nbytes)
{
return malloc(nbytes);
}
PR_IMPLEMENT(void)
PL_DHashFreeTable(PLDHashTable *table, void *ptr)
{
free(ptr);
}
PR_IMPLEMENT(PLDHashNumber)
PL_DHashStringKey(PLDHashTable *table, const void *key)
{
PLDHashNumber h;
const unsigned char *s;
h = 0;
for (s = key; *s != '\0'; s++)
h = (h >> (PL_DHASH_BITS - 4)) ^ (h << 4) ^ *s;
return h;
}
PR_IMPLEMENT(const void *)
PL_DHashGetKeyStub(PLDHashTable *table, PLDHashEntryHdr *entry)
{
PLDHashEntryStub *stub = (PLDHashEntryStub *)entry;
return stub->key;
}
PR_IMPLEMENT(PLDHashNumber)
PL_DHashVoidPtrKeyStub(PLDHashTable *table, const void *key)
{
return (PLDHashNumber)key >> 2;
}
PR_IMPLEMENT(PRBool)
PL_DHashMatchEntryStub(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key)
{
const PLDHashEntryStub *stub = (const PLDHashEntryStub *)entry;
return stub->key == key;
}
PR_IMPLEMENT(PRBool)
PL_DHashMatchStringKey(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key)
{
const PLDHashEntryStub *stub = (const PLDHashEntryStub *)entry;
/* XXX tolerate null keys on account of sloppy Mozilla callers. */
return stub->key == key ||
(stub->key && key && strcmp(stub->key, key) == 0);
}
PR_IMPLEMENT(void)
PL_DHashMoveEntryStub(PLDHashTable *table,
const PLDHashEntryHdr *from,
PLDHashEntryHdr *to)
{
memcpy(to, from, table->entrySize);
}
PR_IMPLEMENT(void)
PL_DHashClearEntryStub(PLDHashTable *table, PLDHashEntryHdr *entry)
{
memset(entry, 0, table->entrySize);
}
PR_IMPLEMENT(void)
PL_DHashFreeStringKey(PLDHashTable *table, PLDHashEntryHdr *entry)
{
const PLDHashEntryStub *stub = (const PLDHashEntryStub *)entry;
free((void *) stub->key);
memset(entry, 0, table->entrySize);
}
PR_IMPLEMENT(void)
PL_DHashFinalizeStub(PLDHashTable *table)
{
}
static const PLDHashTableOps stub_ops = {
PL_DHashAllocTable,
PL_DHashFreeTable,
PL_DHashGetKeyStub,
PL_DHashVoidPtrKeyStub,
PL_DHashMatchEntryStub,
PL_DHashMoveEntryStub,
PL_DHashClearEntryStub,
PL_DHashFinalizeStub,
NULL
};
PR_IMPLEMENT(const PLDHashTableOps *)
PL_DHashGetStubOps(void)
{
return &stub_ops;
}
PR_IMPLEMENT(PLDHashTable *)
PL_NewDHashTable(const PLDHashTableOps *ops, void *data, PRUint32 entrySize,
PRUint32 capacity)
{
PLDHashTable *table;
table = (PLDHashTable *) malloc(sizeof *table);
if (!table)
return NULL;
if (!PL_DHashTableInit(table, ops, data, entrySize, capacity)) {
free(table);
return NULL;
}
return table;
}
PR_IMPLEMENT(void)
PL_DHashTableDestroy(PLDHashTable *table)
{
PL_DHashTableFinish(table);
free(table);
}
PR_IMPLEMENT(PRBool)
PL_DHashTableInit(PLDHashTable *table, const PLDHashTableOps *ops, void *data,
PRUint32 entrySize, PRUint32 capacity)
{
int log2;
PRUint32 nbytes;
#ifdef DEBUG
if (entrySize > 10 * sizeof(void *)) {
fprintf(stderr,
"pldhash: for the table at address %p, the given entrySize"
" of %lu %s favors chaining over double hashing.\n",
(void *)table,
(unsigned long) entrySize,
(entrySize > 16 * sizeof(void*)) ? "definitely" : "probably");
}
#endif
table->ops = ops;
table->data = data;
if (capacity < PL_DHASH_MIN_SIZE)
capacity = PL_DHASH_MIN_SIZE;
log2 = PR_CeilingLog2(capacity);
capacity = PR_BIT(log2);
if (capacity >= PL_DHASH_SIZE_LIMIT)
return PR_FALSE;
table->hashShift = PL_DHASH_BITS - log2;
table->maxAlphaFrac = 0xC0; /* .75 */
table->minAlphaFrac = 0x40; /* .25 */
table->entrySize = entrySize;
table->entryCount = table->removedCount = 0;
table->generation = 0;
nbytes = capacity * entrySize;
table->entryStore = ops->allocTable(table, nbytes);
if (!table->entryStore)
return PR_FALSE;
memset(table->entryStore, 0, nbytes);
METER(memset(&table->stats, 0, sizeof table->stats));
return PR_TRUE;
}
/*
* Compute max and min load numbers (entry counts) from table params.
*/
#define MAX_LOAD(table, size) (((table)->maxAlphaFrac * (size)) >> 8)
#define MIN_LOAD(table, size) (((table)->minAlphaFrac * (size)) >> 8)
PR_IMPLEMENT(void)
PL_DHashTableSetAlphaBounds(PLDHashTable *table,
float maxAlpha,
float minAlpha)
{
PRUint32 size;
/*
* Reject obviously insane bounds, rather than trying to guess what the
* buggy caller intended.
*/
PR_ASSERT(0.5 <= maxAlpha && maxAlpha < 1 && 0 <= minAlpha);
if (maxAlpha < 0.5 || 1 <= maxAlpha || minAlpha < 0)
return;
/*
* Ensure that at least one entry will always be free. If maxAlpha at
* minimum size leaves no entries free, reduce maxAlpha based on minimum
* size and the precision limit of maxAlphaFrac's fixed point format.
*/
PR_ASSERT(PL_DHASH_MIN_SIZE - (maxAlpha * PL_DHASH_MIN_SIZE) >= 1);
if (PL_DHASH_MIN_SIZE - (maxAlpha * PL_DHASH_MIN_SIZE) < 1) {
maxAlpha = (float)
(PL_DHASH_MIN_SIZE - PR_MAX(PL_DHASH_MIN_SIZE / 256, 1))
/ PL_DHASH_MIN_SIZE;
}
/*
* Ensure that minAlpha is strictly less than half maxAlpha. Take care
* not to truncate an entry's worth of alpha when storing in minAlphaFrac
* (8-bit fixed point format).
*/
PR_ASSERT(minAlpha < maxAlpha / 2);
if (minAlpha >= maxAlpha / 2) {
size = PL_DHASH_TABLE_SIZE(table);
minAlpha = (size * maxAlpha - PR_MAX(size / 256, 1)) / (2 * size);
}
table->maxAlphaFrac = (uint8)(maxAlpha * 256);
table->minAlphaFrac = (uint8)(minAlpha * 256);
}
/*
* Double hashing needs the second hash code to be relatively prime to table
* size, so we simply make hash2 odd.
*/
#define HASH1(hash0, shift) ((hash0) >> (shift))
#define HASH2(hash0,log2,shift) ((((hash0) << (log2)) >> (shift)) | 1)
/*
* Reserve keyHash 0 for free entries and 1 for removed-entry sentinels. Note
* that a removed-entry sentinel need be stored only if the removed entry had
* a colliding entry added after it. Therefore we can use 1 as the collision
* flag in addition to the removed-entry sentinel value. Multiplicative hash
* uses the high order bits of keyHash, so this least-significant reservation
* should not hurt the hash function's effectiveness much.
*
* If you change any of these magic numbers, also update PL_DHASH_ENTRY_IS_LIVE
* in pldhash.h. It used to be private to pldhash.c, but then became public to
* assist iterator writers who inspect table->entryStore directly.
*/
#define COLLISION_FLAG ((PLDHashNumber) 1)
#define MARK_ENTRY_FREE(entry) ((entry)->keyHash = 0)
#define MARK_ENTRY_REMOVED(entry) ((entry)->keyHash = 1)
#define ENTRY_IS_REMOVED(entry) ((entry)->keyHash == 1)
#define ENTRY_IS_LIVE(entry) PL_DHASH_ENTRY_IS_LIVE(entry)
#define ENSURE_LIVE_KEYHASH(hash0) if (hash0 < 2) hash0 -= 2; else (void)0
/* Match an entry's keyHash against an unstored one computed from a key. */
#define MATCH_ENTRY_KEYHASH(entry,hash0) \
(((entry)->keyHash & ~COLLISION_FLAG) == (hash0))
/* Compute the address of the indexed entry in table. */
#define ADDRESS_ENTRY(table, index) \
((PLDHashEntryHdr *)((table)->entryStore + (index) * (table)->entrySize))
PR_IMPLEMENT(void)
PL_DHashTableFinish(PLDHashTable *table)
{
char *entryAddr, *entryLimit;
PRUint32 entrySize;
PLDHashEntryHdr *entry;
#ifdef DEBUG_XXXbrendan
static FILE *dumpfp = NULL;
if (!dumpfp) dumpfp = fopen("/tmp/pldhash.bigdump", "w");
if (dumpfp) {
#ifdef MOZILLA_CLIENT
NS_TraceStack(1, dumpfp);
#endif
PL_DHashTableDumpMeter(table, NULL, dumpfp);
fputc('\n', dumpfp);
}
#endif
/* Call finalize before clearing entries, so it can enumerate them. */
table->ops->finalize(table);
/* Clear any remaining live entries. */
entryAddr = table->entryStore;
entrySize = table->entrySize;
entryLimit = entryAddr + PL_DHASH_TABLE_SIZE(table) * entrySize;
while (entryAddr < entryLimit) {
entry = (PLDHashEntryHdr *)entryAddr;
if (ENTRY_IS_LIVE(entry)) {
METER(table->stats.removeEnums++);
table->ops->clearEntry(table, entry);
}
entryAddr += entrySize;
}
/* Free entry storage last. */
table->ops->freeTable(table, table->entryStore);
}
static PLDHashEntryHdr * PL_DHASH_FASTCALL
SearchTable(PLDHashTable *table, const void *key, PLDHashNumber keyHash,
PLDHashOperator op)
{
PLDHashNumber hash1, hash2;
int hashShift, sizeLog2;
PLDHashEntryHdr *entry, *firstRemoved;
PLDHashMatchEntry matchEntry;
PRUint32 sizeMask;
METER(table->stats.searches++);
PR_ASSERT(!(keyHash & COLLISION_FLAG));
/* Compute the primary hash address. */
hashShift = table->hashShift;
hash1 = HASH1(keyHash, hashShift);
entry = ADDRESS_ENTRY(table, hash1);
/* Miss: return space for a new entry. */
if (PL_DHASH_ENTRY_IS_FREE(entry)) {
METER(table->stats.misses++);
return entry;
}
/* Hit: return entry. */
matchEntry = table->ops->matchEntry;
if (MATCH_ENTRY_KEYHASH(entry, keyHash) && matchEntry(table, entry, key)) {
METER(table->stats.hits++);
return entry;
}
/* Collision: double hash. */
sizeLog2 = PL_DHASH_BITS - table->hashShift;
hash2 = HASH2(keyHash, sizeLog2, hashShift);
sizeMask = PR_BITMASK(sizeLog2);
/* Save the first removed entry pointer so PL_DHASH_ADD can recycle it. */
if (ENTRY_IS_REMOVED(entry)) {
firstRemoved = entry;
} else {
firstRemoved = NULL;
if (op == PL_DHASH_ADD)
entry->keyHash |= COLLISION_FLAG;
}
for (;;) {
METER(table->stats.steps++);
hash1 -= hash2;
hash1 &= sizeMask;
entry = ADDRESS_ENTRY(table, hash1);
if (PL_DHASH_ENTRY_IS_FREE(entry)) {
METER(table->stats.misses++);
return (firstRemoved && op == PL_DHASH_ADD) ? firstRemoved : entry;
}
if (MATCH_ENTRY_KEYHASH(entry, keyHash) &&
matchEntry(table, entry, key)) {
METER(table->stats.hits++);
return entry;
}
if (ENTRY_IS_REMOVED(entry)) {
if (!firstRemoved)
firstRemoved = entry;
} else {
if (op == PL_DHASH_ADD)
entry->keyHash |= COLLISION_FLAG;
}
}
/* NOTREACHED */
return NULL;
}
static PRBool
ChangeTable(PLDHashTable *table, int deltaLog2)
{
int oldLog2, newLog2;
PRUint32 oldCapacity, newCapacity;
char *newEntryStore, *oldEntryStore, *oldEntryAddr;
PRUint32 entrySize, i, nbytes;
PLDHashEntryHdr *oldEntry, *newEntry;
PLDHashGetKey getKey;
PLDHashMoveEntry moveEntry;
/* Look, but don't touch, until we succeed in getting new entry store. */
oldLog2 = PL_DHASH_BITS - table->hashShift;
newLog2 = oldLog2 + deltaLog2;
oldCapacity = PR_BIT(oldLog2);
newCapacity = PR_BIT(newLog2);
if (newCapacity >= PL_DHASH_SIZE_LIMIT)
return PR_FALSE;
entrySize = table->entrySize;
nbytes = newCapacity * entrySize;
newEntryStore = table->ops->allocTable(table, nbytes);
if (!newEntryStore)
return PR_FALSE;
/* We can't fail from here on, so update table parameters. */
table->hashShift = PL_DHASH_BITS - newLog2;
table->removedCount = 0;
table->generation++;
/* Assign the new entry store to table. */
memset(newEntryStore, 0, nbytes);
oldEntryAddr = oldEntryStore = table->entryStore;
table->entryStore = newEntryStore;
getKey = table->ops->getKey;
moveEntry = table->ops->moveEntry;
/* Copy only live entries, leaving removed ones behind. */
for (i = 0; i < oldCapacity; i++) {
oldEntry = (PLDHashEntryHdr *)oldEntryAddr;
if (ENTRY_IS_LIVE(oldEntry)) {
oldEntry->keyHash &= ~COLLISION_FLAG;
newEntry = SearchTable(table, getKey(table, oldEntry),
oldEntry->keyHash, PL_DHASH_ADD);
PR_ASSERT(PL_DHASH_ENTRY_IS_FREE(newEntry));
moveEntry(table, oldEntry, newEntry);
newEntry->keyHash = oldEntry->keyHash;
}
oldEntryAddr += entrySize;
}
table->ops->freeTable(table, oldEntryStore);
return PR_TRUE;
}
PR_IMPLEMENT(PLDHashEntryHdr *) PL_DHASH_FASTCALL
PL_DHashTableOperate(PLDHashTable *table, const void *key, PLDHashOperator op)
{
PLDHashNumber keyHash;
PLDHashEntryHdr *entry;
PRUint32 size;
int deltaLog2;
keyHash = table->ops->hashKey(table, key);
keyHash *= PL_DHASH_GOLDEN_RATIO;
/* Avoid 0 and 1 hash codes, they indicate free and removed entries. */
ENSURE_LIVE_KEYHASH(keyHash);
keyHash &= ~COLLISION_FLAG;
switch (op) {
case PL_DHASH_LOOKUP:
METER(table->stats.lookups++);
entry = SearchTable(table, key, keyHash, op);
break;
case PL_DHASH_ADD:
/*
* If alpha is >= .75, grow or compress the table. If key is already
* in the table, we may grow once more than necessary, but only if we
* are on the edge of being overloaded.
*/
size = PL_DHASH_TABLE_SIZE(table);
if (table->entryCount + table->removedCount >= MAX_LOAD(table, size)) {
/* Compress if a quarter or more of all entries are removed. */
if (table->removedCount >= size >> 2) {
METER(table->stats.compresses++);
deltaLog2 = 0;
} else {
METER(table->stats.grows++);
deltaLog2 = 1;
}
/*
* Grow or compress table, returning null if ChangeTable fails and
* falling through might claim the last free entry.
*/
if (!ChangeTable(table, deltaLog2) &&
table->entryCount + table->removedCount == size - 1) {
METER(table->stats.addFailures++);
return NULL;
}
}
/*
* Look for entry after possibly growing, so we don't have to add it,
* then skip it while growing the table and re-add it after.
*/
entry = SearchTable(table, key, keyHash, op);
if (!ENTRY_IS_LIVE(entry)) {
/* Initialize the entry, indicating that it's no longer free. */
METER(table->stats.addMisses++);
if (ENTRY_IS_REMOVED(entry)) {
METER(table->stats.addOverRemoved++);
table->removedCount--;
keyHash |= COLLISION_FLAG;
}
if (table->ops->initEntry &&
!table->ops->initEntry(table, entry, key)) {
/* We haven't claimed entry yet; fail with null return. */
memset(entry + 1, 0, table->entrySize - sizeof *entry);
return NULL;
}
entry->keyHash = keyHash;
table->entryCount++;
}
METER(else table->stats.addHits++);
break;
case PL_DHASH_REMOVE:
entry = SearchTable(table, key, keyHash, op);
if (ENTRY_IS_LIVE(entry)) {
/* Clear this entry and mark it as "removed". */
METER(table->stats.removeHits++);
PL_DHashTableRawRemove(table, entry);
/* Shrink if alpha is <= .25 and table isn't too small already. */
size = PL_DHASH_TABLE_SIZE(table);
if (size > PL_DHASH_MIN_SIZE &&
table->entryCount <= MIN_LOAD(table, size)) {
METER(table->stats.shrinks++);
(void) ChangeTable(table, -1);
}
}
METER(else table->stats.removeMisses++);
entry = NULL;
break;
default:
PR_ASSERT(0);
entry = NULL;
}
return entry;
}
PR_IMPLEMENT(void)
PL_DHashTableRawRemove(PLDHashTable *table, PLDHashEntryHdr *entry)
{
PLDHashNumber keyHash; /* load first in case clearEntry goofs it */
PR_ASSERT(PL_DHASH_ENTRY_IS_LIVE(entry));
keyHash = entry->keyHash;
table->ops->clearEntry(table, entry);
if (keyHash & COLLISION_FLAG) {
MARK_ENTRY_REMOVED(entry);
table->removedCount++;
} else {
METER(table->stats.removeFrees++);
MARK_ENTRY_FREE(entry);
}
table->entryCount--;
}
PR_IMPLEMENT(PRUint32)
PL_DHashTableEnumerate(PLDHashTable *table, PLDHashEnumerator etor, void *arg)
{
char *entryAddr, *entryLimit;
PRUint32 i, capacity, entrySize;
PRBool didRemove;
PLDHashEntryHdr *entry;
PLDHashOperator op;
entryAddr = table->entryStore;
entrySize = table->entrySize;
capacity = PL_DHASH_TABLE_SIZE(table);
entryLimit = entryAddr + capacity * entrySize;
i = 0;
didRemove = PR_FALSE;
while (entryAddr < entryLimit) {
entry = (PLDHashEntryHdr *)entryAddr;
if (ENTRY_IS_LIVE(entry)) {
op = etor(table, entry, i++, arg);
if (op & PL_DHASH_REMOVE) {
METER(table->stats.removeEnums++);
PL_DHashTableRawRemove(table, entry);
didRemove = PR_TRUE;
}
if (op & PL_DHASH_STOP)
break;
}
entryAddr += entrySize;
}
/*
* Shrink or compress if a quarter or more of all entries are removed, or
* if the table is underloaded according to the configured minimum alpha,
* and is not minimal-size already. Do this only if we removed above, so
* non-removing enumerations can count on stable table->entryStore until
* the next non-lookup-Operate or removing-Enumerate.
*/
if (didRemove &&
(table->removedCount >= capacity >> 2 ||
(capacity > PL_DHASH_MIN_SIZE &&
table->entryCount <= MIN_LOAD(table, capacity)))) {
METER(table->stats.enumShrinks++);
capacity = table->entryCount;
capacity += capacity >> 1;
if (capacity < PL_DHASH_MIN_SIZE)
capacity = PL_DHASH_MIN_SIZE;
(void) ChangeTable(table,
PR_CeilingLog2(capacity)
- (PL_DHASH_BITS - table->hashShift));
}
return i;
}
#ifdef PL_DHASHMETER
#include <math.h>
PR_IMPLEMENT(void)
PL_DHashTableDumpMeter(PLDHashTable *table, PLDHashEnumerator dump, FILE *fp)
{
char *entryAddr;
PRUint32 entrySize, entryCount;
int hashShift, sizeLog2;
PRUint32 i, tableSize, sizeMask, chainLen, maxChainLen, chainCount;
PLDHashNumber hash1, hash2, saveHash1, maxChainHash1, maxChainHash2;
double sqsum, mean, variance, sigma;
PLDHashEntryHdr *entry, *probe;
entryAddr = table->entryStore;
entrySize = table->entrySize;
hashShift = table->hashShift;
sizeLog2 = PL_DHASH_BITS - hashShift;
tableSize = PL_DHASH_TABLE_SIZE(table);
sizeMask = PR_BITMASK(sizeLog2);
chainCount = maxChainLen = 0;
hash2 = 0;
sqsum = 0;
for (i = 0; i < tableSize; i++) {
entry = (PLDHashEntryHdr *)entryAddr;
entryAddr += entrySize;
if (!ENTRY_IS_LIVE(entry))
continue;
hash1 = HASH1(entry->keyHash & ~COLLISION_FLAG, hashShift);
saveHash1 = hash1;
probe = ADDRESS_ENTRY(table, hash1);
chainLen = 1;
if (probe == entry) {
/* Start of a (possibly unit-length) chain. */
chainCount++;
} else {
hash2 = HASH2(entry->keyHash & ~COLLISION_FLAG, sizeLog2,
hashShift);
do {
chainLen++;
hash1 -= hash2;
hash1 &= sizeMask;
probe = ADDRESS_ENTRY(table, hash1);
} while (probe != entry);
}
sqsum += chainLen * chainLen;
if (chainLen > maxChainLen) {
maxChainLen = chainLen;
maxChainHash1 = saveHash1;
maxChainHash2 = hash2;
}
}
entryCount = table->entryCount;
if (entryCount && chainCount) {
mean = (double)entryCount / chainCount;
variance = chainCount * sqsum - entryCount * entryCount;
if (variance < 0 || chainCount == 1)
variance = 0;
else
variance /= chainCount * (chainCount - 1);
sigma = sqrt(variance);
} else {
mean = sigma = 0;
}
fprintf(fp, "Double hashing statistics:\n");
fprintf(fp, " table size (in entries): %u\n", tableSize);
fprintf(fp, " number of entries: %u\n", table->entryCount);
fprintf(fp, " number of removed entries: %u\n", table->removedCount);
fprintf(fp, " number of searches: %u\n", table->stats.searches);
fprintf(fp, " number of hits: %u\n", table->stats.hits);
fprintf(fp, " number of misses: %u\n", table->stats.misses);
fprintf(fp, " mean steps per search: %g\n", table->stats.searches ?
(double)table->stats.steps
/ table->stats.searches :
0.);
fprintf(fp, " mean hash chain length: %g\n", mean);
fprintf(fp, " standard deviation: %g\n", sigma);
fprintf(fp, " maximum hash chain length: %u\n", maxChainLen);
fprintf(fp, " number of lookups: %u\n", table->stats.lookups);
fprintf(fp, " adds that made a new entry: %u\n", table->stats.addMisses);
fprintf(fp, "adds that recycled removeds: %u\n", table->stats.addOverRemoved);
fprintf(fp, " adds that found an entry: %u\n", table->stats.addHits);
fprintf(fp, " add failures: %u\n", table->stats.addFailures);
fprintf(fp, " useful removes: %u\n", table->stats.removeHits);
fprintf(fp, " useless removes: %u\n", table->stats.removeMisses);
fprintf(fp, "removes that freed an entry: %u\n", table->stats.removeFrees);
fprintf(fp, " removes while enumerating: %u\n", table->stats.removeEnums);
fprintf(fp, " number of grows: %u\n", table->stats.grows);
fprintf(fp, " number of shrinks: %u\n", table->stats.shrinks);
fprintf(fp, " number of compresses: %u\n", table->stats.compresses);
fprintf(fp, "number of enumerate shrinks: %u\n", table->stats.enumShrinks);
if (dump && maxChainLen && hash2) {
fputs("Maximum hash chain:\n", fp);
hash1 = maxChainHash1;
hash2 = maxChainHash2;
entry = ADDRESS_ENTRY(table, hash1);
i = 0;
do {
if (dump(table, entry, i++, fp) != PL_DHASH_NEXT)
break;
hash1 -= hash2;
hash1 &= sizeMask;
entry = ADDRESS_ENTRY(table, hash1);
} while (PL_DHASH_ENTRY_IS_BUSY(entry));
}
}
#endif /* PL_DHASHMETER */

580
mozilla/xpcom/ds/pldhash.h
View File

@ -1,580 +0,0 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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 JavaScript code.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1999-2001
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Brendan Eich <brendan@mozilla.org> (Original Author)
*
* Alternatively, the contents of this file may be used under the terms of
* either of the GNU General Public License Version 2 or later (the "GPL"),
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef pldhash_h___
#define pldhash_h___
/*
* Double hashing, a la Knuth 6.
* GENERATED BY js/src/plify_jsdhash.sed -- DO NOT EDIT!!!
*/
#include "prtypes.h"
PR_BEGIN_EXTERN_C
#ifdef DEBUG_XXXbrendan
#define PL_DHASHMETER 1
#endif
#if defined(__GNUC__) && defined(__i386__) && (__GNUC__ >= 3) && !defined(XP_OS2) && !defined(XP_MACOSX)
#define PL_DHASH_FASTCALL __attribute__ ((regparm (3),stdcall))
#else
#define PL_DHASH_FASTCALL
#endif
/* Table size limit, do not equal or exceed (see min&maxAlphaFrac, below). */
#undef PL_DHASH_SIZE_LIMIT
#define PL_DHASH_SIZE_LIMIT PR_BIT(24)
/* Minimum table size, or gross entry count (net is at most .75 loaded). */
#ifndef PL_DHASH_MIN_SIZE
#define PL_DHASH_MIN_SIZE 16
#elif (PL_DHASH_MIN_SIZE & (PL_DHASH_MIN_SIZE - 1)) != 0
#error "PL_DHASH_MIN_SIZE must be a power of two!"
#endif
/*
* Multiplicative hash uses an unsigned 32 bit integer and the golden ratio,
* expressed as a fixed-point 32-bit fraction.
*/
#define PL_DHASH_BITS 32
#define PL_DHASH_GOLDEN_RATIO 0x9E3779B9U
/* Primitive and forward-struct typedefs. */
typedef PRUint32 PLDHashNumber;
typedef struct PLDHashEntryHdr PLDHashEntryHdr;
typedef struct PLDHashEntryStub PLDHashEntryStub;
typedef struct PLDHashTable PLDHashTable;
typedef struct PLDHashTableOps PLDHashTableOps;
/*
* Table entry header structure.
*
* In order to allow in-line allocation of key and value, we do not declare
* either here. Instead, the API uses const void *key as a formal parameter,
* and asks each entry for its key when necessary via a getKey callback, used
* when growing or shrinking the table. Other callback types are defined
* below and grouped into the PLDHashTableOps structure, for single static
* initialization per hash table sub-type.
*
* Each hash table sub-type should nest the PLDHashEntryHdr structure at the
* front of its particular entry type. The keyHash member contains the result
* of multiplying the hash code returned from the hashKey callback (see below)
* by PL_DHASH_GOLDEN_RATIO, then constraining the result to avoid the magic 0
* and 1 values. The stored keyHash value is table size invariant, and it is
* maintained automatically by PL_DHashTableOperate -- users should never set
* it, and its only uses should be via the entry macros below.
*
* The PL_DHASH_ENTRY_IS_LIVE macro tests whether entry is neither free nor
* removed. An entry may be either busy or free; if busy, it may be live or
* removed. Consumers of this API should not access members of entries that
* are not live.
*
* However, use PL_DHASH_ENTRY_IS_BUSY for faster liveness testing of entries
* returned by PL_DHashTableOperate, as PL_DHashTableOperate never returns a
* non-live, busy (i.e., removed) entry pointer to its caller. See below for
* more details on PL_DHashTableOperate's calling rules.
*/
struct PLDHashEntryHdr {
PLDHashNumber keyHash; /* every entry must begin like this */
};
#define PL_DHASH_ENTRY_IS_FREE(entry) ((entry)->keyHash == 0)
#define PL_DHASH_ENTRY_IS_BUSY(entry) (!PL_DHASH_ENTRY_IS_FREE(entry))
#define PL_DHASH_ENTRY_IS_LIVE(entry) ((entry)->keyHash >= 2)
/*
* A PLDHashTable is currently 8 words (without the PL_DHASHMETER overhead)
* on most architectures, and may be allocated on the stack or within another
* structure or class (see below for the Init and Finish functions to use).
*
* To decide whether to use double hashing vs. chaining, we need to develop a
* trade-off relation, as follows:
*
* Let alpha be the load factor, esize the entry size in words, count the
* entry count, and pow2 the power-of-two table size in entries.
*
* (PLDHashTable overhead) > (PLHashTable overhead)
* (unused table entry space) > (malloc and .next overhead per entry) +
* (buckets overhead)
* (1 - alpha) * esize * pow2 > 2 * count + pow2
*
* Notice that alpha is by definition (count / pow2):
*
* (1 - alpha) * esize * pow2 > 2 * alpha * pow2 + pow2
* (1 - alpha) * esize > 2 * alpha + 1
*
* esize > (1 + 2 * alpha) / (1 - alpha)
*
* This assumes both tables must keep keyHash, key, and value for each entry,
* where key and value point to separately allocated strings or structures.
* If key and value can be combined into one pointer, then the trade-off is:
*
* esize > (1 + 3 * alpha) / (1 - alpha)
*
* If the entry value can be a subtype of PLDHashEntryHdr, rather than a type
* that must be allocated separately and referenced by an entry.value pointer
* member, and provided key's allocation can be fused with its entry's, then
* k (the words wasted per entry with chaining) is 4.
*
* To see these curves, feed gnuplot input like so:
*
* gnuplot> f(x,k) = (1 + k * x) / (1 - x)
* gnuplot> plot [0:.75] f(x,2), f(x,3), f(x,4)
*
* For k of 2 and a well-loaded table (alpha > .5), esize must be more than 4
* words for chaining to be more space-efficient than double hashing.
*
* Solving for alpha helps us decide when to shrink an underloaded table:
*
* esize > (1 + k * alpha) / (1 - alpha)
* esize - alpha * esize > 1 + k * alpha
* esize - 1 > (k + esize) * alpha
* (esize - 1) / (k + esize) > alpha
*
* alpha < (esize - 1) / (esize + k)
*
* Therefore double hashing should keep alpha >= (esize - 1) / (esize + k),
* assuming esize is not too large (in which case, chaining should probably be
* used for any alpha). For esize=2 and k=3, we want alpha >= .2; for esize=3
* and k=2, we want alpha >= .4. For k=4, esize could be 6, and alpha >= .5
* would still obtain. See the PL_DHASH_MIN_ALPHA macro further below.
*
* The current implementation uses a configurable lower bound on alpha, which
* defaults to .25, when deciding to shrink the table (while still respecting
* PL_DHASH_MIN_SIZE).
*
* Note a qualitative difference between chaining and double hashing: under
* chaining, entry addresses are stable across table shrinks and grows. With
* double hashing, you can't safely hold an entry pointer and use it after an
* ADD or REMOVE operation, unless you sample table->generation before adding
* or removing, and compare the sample after, dereferencing the entry pointer
* only if table->generation has not changed.
*
* The moral of this story: there is no one-size-fits-all hash table scheme,
* but for small table entry size, and assuming entry address stability is not
* required, double hashing wins.
*/
struct PLDHashTable {
const PLDHashTableOps *ops; /* virtual operations, see below */
void *data; /* ops- and instance-specific data */
PRInt16 hashShift; /* multiplicative hash shift */
uint8 maxAlphaFrac; /* 8-bit fixed point max alpha */
uint8 minAlphaFrac; /* 8-bit fixed point min alpha */
PRUint32 entrySize; /* number of bytes in an entry */
PRUint32 entryCount; /* number of entries in table */
PRUint32 removedCount; /* removed entry sentinels in table */
PRUint32 generation; /* entry storage generation number */
char *entryStore; /* entry storage */
#ifdef PL_DHASHMETER
struct PLDHashStats {
PRUint32 searches; /* total number of table searches */
PRUint32 steps; /* hash chain links traversed */
PRUint32 hits; /* searches that found key */
PRUint32 misses; /* searches that didn't find key */
PRUint32 lookups; /* number of PL_DHASH_LOOKUPs */
PRUint32 addMisses; /* adds that miss, and do work */
PRUint32 addOverRemoved; /* adds that recycled a removed entry */
PRUint32 addHits; /* adds that hit an existing entry */
PRUint32 addFailures; /* out-of-memory during add growth */
PRUint32 removeHits; /* removes that hit, and do work */
PRUint32 removeMisses; /* useless removes that miss */
PRUint32 removeFrees; /* removes that freed entry directly */
PRUint32 removeEnums; /* removes done by Enumerate */
PRUint32 grows; /* table expansions */
PRUint32 shrinks; /* table contractions */
PRUint32 compresses; /* table compressions */
PRUint32 enumShrinks; /* contractions after Enumerate */
} stats;
#endif
};
/*
* Size in entries (gross, not net of free and removed sentinels) for table.
* We store hashShift rather than sizeLog2 to optimize the collision-free case
* in SearchTable.
*/
#define PL_DHASH_TABLE_SIZE(table) PR_BIT(PL_DHASH_BITS - (table)->hashShift)
/*
* Table space at entryStore is allocated and freed using these callbacks.
* The allocator should return null on error only (not if called with nbytes
* equal to 0; but note that pldhash.c code will never call with 0 nbytes).
*/
typedef void *
(* PR_CALLBACK PLDHashAllocTable)(PLDHashTable *table, PRUint32 nbytes);
typedef void
(* PR_CALLBACK PLDHashFreeTable) (PLDHashTable *table, void *ptr);
/*
* When a table grows or shrinks, each entry is queried for its key using this
* callback. NB: in that event, entry is not in table any longer; it's in the
* old entryStore vector, which is due to be freed once all entries have been
* moved via moveEntry callbacks.
*/
typedef const void *
(* PR_CALLBACK PLDHashGetKey) (PLDHashTable *table,
PLDHashEntryHdr *entry);
/*
* Compute the hash code for a given key to be looked up, added, or removed
* from table. A hash code may have any PLDHashNumber value.
*/
typedef PLDHashNumber
(* PR_CALLBACK PLDHashHashKey) (PLDHashTable *table, const void *key);
/*
* Compare the key identifying entry in table with the provided key parameter.
* Return PR_TRUE if keys match, PR_FALSE otherwise.
*/
typedef PRBool
(* PR_CALLBACK PLDHashMatchEntry)(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key);
/*
* Copy the data starting at from to the new entry storage at to. Do not add
* reference counts for any strong references in the entry, however, as this
* is a "move" operation: the old entry storage at from will be freed without
* any reference-decrementing callback shortly.
*/
typedef void
(* PR_CALLBACK PLDHashMoveEntry)(PLDHashTable *table,
const PLDHashEntryHdr *from,
PLDHashEntryHdr *to);
/*
* Clear the entry and drop any strong references it holds. This callback is
* invoked during a PL_DHASH_REMOVE operation (see below for operation codes),
* but only if the given key is found in the table.
*/
typedef void
(* PR_CALLBACK PLDHashClearEntry)(PLDHashTable *table,
PLDHashEntryHdr *entry);
/*
* Called when a table (whether allocated dynamically by itself, or nested in
* a larger structure, or allocated on the stack) is finished. This callback
* allows table->ops-specific code to finalize table->data.
*/
typedef void
(* PR_CALLBACK PLDHashFinalize) (PLDHashTable *table);
/*
* Initialize a new entry, apart from keyHash. This function is called when
* PL_DHashTableOperate's PL_DHASH_ADD case finds no existing entry for the
* given key, and must add a new one. At that point, entry->keyHash is not
* set yet, to avoid claiming the last free entry in a severely overloaded
* table.
*/
typedef PRBool
(* PR_CALLBACK PLDHashInitEntry)(PLDHashTable *table,
PLDHashEntryHdr *entry,
const void *key);
/*
* Finally, the "vtable" structure for PLDHashTable. The first eight hooks
* must be provided by implementations; they're called unconditionally by the
* generic pldhash.c code. Hooks after these may be null.
*
* Summary of allocation-related hook usage with C++ placement new emphasis:
* allocTable Allocate raw bytes with malloc, no ctors run.
* freeTable Free raw bytes with free, no dtors run.
* initEntry Call placement new using default key-based ctor.
* Return PR_TRUE on success, PR_FALSE on error.
* moveEntry Call placement new using copy ctor, run dtor on old
* entry storage.
* clearEntry Run dtor on entry.
* finalize Stub unless table->data was initialized and needs to
* be finalized.
*
* Note the reason why initEntry is optional: the default hooks (stubs) clear
* entry storage: On successful PL_DHashTableOperate(tbl, key, PL_DHASH_ADD),
* the returned entry pointer addresses an entry struct whose keyHash member
* has been set non-zero, but all other entry members are still clear (null).
* PL_DHASH_ADD callers can test such members to see whether the entry was
* newly created by the PL_DHASH_ADD call that just succeeded. If placement
* new or similar initialization is required, define an initEntry hook. Of
* course, the clearEntry hook must zero or null appropriately.
*
* XXX assumes 0 is null for pointer types.
*/
struct PLDHashTableOps {
/* Mandatory hooks. All implementations must provide these. */
PLDHashAllocTable allocTable;
PLDHashFreeTable freeTable;
PLDHashGetKey getKey;
PLDHashHashKey hashKey;
PLDHashMatchEntry matchEntry;
PLDHashMoveEntry moveEntry;
PLDHashClearEntry clearEntry;
PLDHashFinalize finalize;
/* Optional hooks start here. If null, these are not called. */
PLDHashInitEntry initEntry;
};
/*
* Default implementations for the above ops.
*/
PR_EXTERN(void *)
PL_DHashAllocTable(PLDHashTable *table, PRUint32 nbytes);
PR_EXTERN(void)
PL_DHashFreeTable(PLDHashTable *table, void *ptr);
PR_EXTERN(PLDHashNumber)
PL_DHashStringKey(PLDHashTable *table, const void *key);
/* A minimal entry contains a keyHash header and a void key pointer. */
struct PLDHashEntryStub {
PLDHashEntryHdr hdr;
const void *key;
};
PR_EXTERN(const void *)
PL_DHashGetKeyStub(PLDHashTable *table, PLDHashEntryHdr *entry);
PR_EXTERN(PLDHashNumber)
PL_DHashVoidPtrKeyStub(PLDHashTable *table, const void *key);
PR_EXTERN(PRBool)
PL_DHashMatchEntryStub(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key);
PR_EXTERN(PRBool)
PL_DHashMatchStringKey(PLDHashTable *table,
const PLDHashEntryHdr *entry,
const void *key);
PR_EXTERN(void)
PL_DHashMoveEntryStub(PLDHashTable *table,
const PLDHashEntryHdr *from,
PLDHashEntryHdr *to);
PR_EXTERN(void)
PL_DHashClearEntryStub(PLDHashTable *table, PLDHashEntryHdr *entry);
PR_EXTERN(void)
PL_DHashFreeStringKey(PLDHashTable *table, PLDHashEntryHdr *entry);
PR_EXTERN(void)
PL_DHashFinalizeStub(PLDHashTable *table);
/*
* If you use PLDHashEntryStub or a subclass of it as your entry struct, and
* if your entries move via memcpy and clear via memset(0), you can use these
* stub operations.
*/
PR_EXTERN(const PLDHashTableOps *)
PL_DHashGetStubOps(void);
/*
* Dynamically allocate a new PLDHashTable using malloc, initialize it using
* PL_DHashTableInit, and return its address. Return null on malloc failure.
* Note that the entry storage at table->entryStore will be allocated using
* the ops->allocTable callback.
*/
PR_EXTERN(PLDHashTable *)
PL_NewDHashTable(const PLDHashTableOps *ops, void *data, PRUint32 entrySize,
PRUint32 capacity);
/*
* Finalize table's data, free its entry storage (via table->ops->freeTable),
* and return the memory starting at table to the malloc heap.
*/
PR_EXTERN(void)
PL_DHashTableDestroy(PLDHashTable *table);
/*
* Initialize table with ops, data, entrySize, and capacity. Capacity is a
* guess for the smallest table size at which the table will usually be less
* than 75% loaded (the table will grow or shrink as needed; capacity serves
* only to avoid inevitable early growth from PL_DHASH_MIN_SIZE).
*/
PR_EXTERN(PRBool)
PL_DHashTableInit(PLDHashTable *table, const PLDHashTableOps *ops, void *data,
PRUint32 entrySize, PRUint32 capacity);
/*
* Set maximum and minimum alpha for table. The defaults are 0.75 and .25.
* maxAlpha must be in [0.5, 0.9375] for the default PL_DHASH_MIN_SIZE; or if
* MinSize=PL_DHASH_MIN_SIZE <= 256, in [0.5, (float)(MinSize-1)/MinSize]; or
* else in [0.5, 255.0/256]. minAlpha must be in [0, maxAlpha / 2), so that
* we don't shrink on the very next remove after growing a table upon adding
* an entry that brings entryCount past maxAlpha * tableSize.
*/
PR_IMPLEMENT(void)
PL_DHashTableSetAlphaBounds(PLDHashTable *table,
float maxAlpha,
float minAlpha);
/*
* Call this macro with k, the number of pointer-sized words wasted per entry
* under chaining, to compute the minimum alpha at which double hashing still
* beats chaining.
*/
#define PL_DHASH_MIN_ALPHA(table, k) \
((float)((table)->entrySize / sizeof(void *) - 1) \
/ ((table)->entrySize / sizeof(void *) + (k)))
/*
* Finalize table's data, free its entry storage using table->ops->freeTable,
* and leave its members unchanged from their last live values (which leaves
* pointers dangling). If you want to burn cycles clearing table, it's up to
* your code to call memset.
*/
PR_EXTERN(void)
PL_DHashTableFinish(PLDHashTable *table);
/*
* To consolidate keyHash computation and table grow/shrink code, we use a
* single entry point for lookup, add, and remove operations. The operation
* codes are declared here, along with codes returned by PLDHashEnumerator
* functions, which control PL_DHashTableEnumerate's behavior.
*/
typedef enum PLDHashOperator {
PL_DHASH_LOOKUP = 0, /* lookup entry */
PL_DHASH_ADD = 1, /* add entry */
PL_DHASH_REMOVE = 2, /* remove entry, or enumerator says remove */
PL_DHASH_NEXT = 0, /* enumerator says continue */
PL_DHASH_STOP = 1 /* enumerator says stop */
} PLDHashOperator;
/*
* To lookup a key in table, call:
*
* entry = PL_DHashTableOperate(table, key, PL_DHASH_LOOKUP);
*
* If PL_DHASH_ENTRY_IS_BUSY(entry) is true, key was found and it identifies
* entry. If PL_DHASH_ENTRY_IS_FREE(entry) is true, key was not found.
*
* To add an entry identified by key to table, call:
*
* entry = PL_DHashTableOperate(table, key, PL_DHASH_ADD);
*
* If entry is null upon return, then either the table is severely overloaded,
* and memory can't be allocated for entry storage via table->ops->allocTable;
* Or if table->ops->initEntry is non-null, the table->ops->initEntry op may
* have returned false.
*
* Otherwise, entry->keyHash has been set so that PL_DHASH_ENTRY_IS_BUSY(entry)
* is true, and it is up to the caller to initialize the key and value parts
* of the entry sub-type, if they have not been set already (i.e. if entry was
* not already in the table, and if the optional initEntry hook was not used).
*
* To remove an entry identified by key from table, call:
*
* (void) PL_DHashTableOperate(table, key, PL_DHASH_REMOVE);
*
* If key's entry is found, it is cleared (via table->ops->clearEntry) and
* the entry is marked so that PL_DHASH_ENTRY_IS_FREE(entry). This operation
* returns null unconditionally; you should ignore its return value.
*/
PR_EXTERN(PLDHashEntryHdr *) PL_DHASH_FASTCALL
PL_DHashTableOperate(PLDHashTable *table, const void *key, PLDHashOperator op);
/*
* Remove an entry already accessed via LOOKUP or ADD.
*
* NB: this is a "raw" or low-level routine, intended to be used only where
* the inefficiency of a full PL_DHashTableOperate (which rehashes in order
* to find the entry given its key) is not tolerable. This function does not
* shrink the table if it is underloaded. It does not update stats #ifdef
* PL_DHASHMETER, either.
*/
PR_EXTERN(void)
PL_DHashTableRawRemove(PLDHashTable *table, PLDHashEntryHdr *entry);
/*
* Enumerate entries in table using etor:
*
* count = PL_DHashTableEnumerate(table, etor, arg);
*
* PL_DHashTableEnumerate calls etor like so:
*
* op = etor(table, entry, number, arg);
*
* where number is a zero-based ordinal assigned to live entries according to
* their order in table->entryStore.
*
* The return value, op, is treated as a set of flags. If op is PL_DHASH_NEXT,
* then continue enumerating. If op contains PL_DHASH_REMOVE, then clear (via
* table->ops->clearEntry) and free entry. Then we check whether op contains
* PL_DHASH_STOP; if so, stop enumerating and return the number of live entries
* that were enumerated so far. Return the total number of live entries when
* enumeration completes normally.
*
* If etor calls PL_DHashTableOperate on table with op != PL_DHASH_LOOKUP, it
* must return PL_DHASH_STOP; otherwise undefined behavior results.
*
* If any enumerator returns PL_DHASH_REMOVE, table->entryStore may be shrunk
* or compressed after enumeration, but before PL_DHashTableEnumerate returns.
* Such an enumerator therefore can't safely set aside entry pointers, but an
* enumerator that never returns PL_DHASH_REMOVE can set pointers to entries
* aside, e.g., to avoid copying live entries into an array of the entry type.
* Copying entry pointers is cheaper, and safe so long as the caller of such a
* "stable" Enumerate doesn't use the set-aside pointers after any call either
* to PL_DHashTableOperate, or to an "unstable" form of Enumerate, which might
* grow or shrink entryStore.
*
* If your enumerator wants to remove certain entries, but set aside pointers
* to other entries that it retains, it can use PL_DHashTableRawRemove on the
* entries to be removed, returning PL_DHASH_NEXT to skip them. Likewise, if
* you want to remove entries, but for some reason you do not want entryStore
* to be shrunk or compressed, you can call PL_DHashTableRawRemove safely on
* the entry being enumerated, rather than returning PL_DHASH_REMOVE.
*/
typedef PLDHashOperator
(* PR_CALLBACK PLDHashEnumerator)(PLDHashTable *table, PLDHashEntryHdr *hdr,
PRUint32 number, void *arg);
PR_EXTERN(PRUint32)
PL_DHashTableEnumerate(PLDHashTable *table, PLDHashEnumerator etor, void *arg);
#ifdef PL_DHASHMETER
#include <stdio.h>
PR_EXTERN(void)
PL_DHashTableDumpMeter(PLDHashTable *table, PLDHashEnumerator dump, FILE *fp);
#endif
PR_END_EXTERN_C
#endif /* pldhash_h___ */

20
mozilla/xpcom/glue/Makefile.in
View File

@ -56,9 +56,25 @@ LOCAL_INCLUDES = \
-I$(srcdir)/../build \
$(NULL)
CPPSRCS = \
CSRCS = \
$(XPCOM_GLUE_SRC_LCSRCS) \
$(XPCOM_GLUENS_SRC_LCSRCS) \
$(NULL)
CPPSRCS = \
$(XPCOM_GLUE_SRC_LCPPSRCS) \
$(XPCOM_GLUENS_SRC_LCPPSRCS) \
$(NULL)
EXPORTS = \
pldhash.h \
nsBaseHashtable.h \
nsClassHashtable.h \
nsDataHashtable.h \
nsHashKeys.h \
nsINIParser.h \
nsInterfaceHashtable.h \
nsRefPtrHashtable.h \
nsTHashtable.h \
$(NULL)
SDK_HEADERS = \

21
mozilla/xpcom/glue/nsHashKeys.h
View File

@ -38,16 +38,21 @@
#ifndef nsTHashKeys_h__
#define nsTHashKeys_h__
#include "nsAString.h"
#include "nsString.h"
#include "nsID.h"
#include "nsCRT.h"
#include "nsReadableUtils.h"
#include "nsISupports.h"
#include "nsCOMPtr.h"
#include "pldhash.h"
#include NEW_H
#ifdef MOZILLA_INTERNAL_API
#include "nsAString.h"
#include "nsString.h"
#else
#include "nsStringAPI.h"
#endif
#include <stdlib.h>
/** @file nsHashKeys.h
* standard HashKey classes for nsBaseHashtable and relatives. Each of these
* classes follows the nsTHashtable::EntryType specification
@ -61,6 +66,10 @@
* nsDepCharHashKey
*/
NS_COM_GLUE PRUint32 HashString(const nsAString& aStr);
NS_COM_GLUE PRUint32 HashString(const nsACString& aStr);
NS_COM_GLUE PRUint32 HashCString(const char* aKey);
/**
* hashkey wrapper using nsAString KeyType
*
@ -274,7 +283,7 @@ public:
}
static const char* KeyToPointer(const char* aKey) { return aKey; }
static PLDHashNumber HashKey(const char* aKey) { return nsCRT::HashCode(aKey); }
static PLDHashNumber HashKey(const char* aKey) { return HashCString(aKey); }
enum { ALLOW_MEMMOVE = PR_TRUE };
private:
@ -304,7 +313,7 @@ public:
}
static KeyTypePointer KeyToPointer(KeyType aKey) { return aKey; }
static PLDHashNumber HashKey(KeyTypePointer aKey) { return nsCRT::HashCode(aKey); }
static PLDHashNumber HashKey(KeyTypePointer aKey) { return HashCString(aKey); }
enum { ALLOW_MEMMOVE = PR_TRUE };

310
mozilla/xpcom/glue/nsINIParser.cpp Normal file
View File

@ -0,0 +1,310 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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 Communicator client code, released
* March 31, 1998.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Samir Gehani <sgehani@netscape.com>
* Benjamin Smedberg <bsmedberg@covad.net>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsINIParser.h"
#include "nsError.h"
#include "nsILocalFile.h"
#include <stdlib.h>
#include <stdio.h>
// Stack based FILE wrapper to ensure that fclose is called, copied from
// toolkit/mozapps/update/src/updater/readstrings.cpp
class AutoFILE {
public:
AutoFILE(FILE *fp = nsnull) : fp_(fp) {}
~AutoFILE() { if (fp_) fclose(fp_); }
operator FILE *() { return fp_; }
FILE** operator &() { return &fp_; }
private:
FILE *fp_;
};
nsresult
nsINIParser::Init(nsILocalFile* aFile)
{
nsresult rv;
/* open the file */
AutoFILE fd;
rv = aFile->OpenANSIFileDesc("r", &fd);
if (NS_FAILED(rv))
return rv;
return InitFromFILE(fd);
}
nsresult
nsINIParser::Init(const char *aPath)
{
/* open the file */
AutoFILE fd = fopen(aPath, "r");
if (!fd)
return NS_ERROR_FAILURE;
return InitFromFILE(fd);
}
// copied from toolkit/mozapps/updater/src/updater/updater.cpp
// we could use nsCRT::strtok except that nsCRT isn't part of the glue,
// and may never be due to NSPR dependencies. This should probably be declared
// and exported in a string-management glue header.
static char*
mstrtok(const char *delims, char **str)
{
if (!*str || !**str)
return NULL;
// skip leading "whitespace"
char *ret = *str;
const char *d;
do {
for (d = delims; *d != '\0'; ++d) {
if (*ret == *d) {
++ret;
break;
}
}
} while (*d);
if (!*ret) {
*str = ret;
return NULL;
}
char *i = ret;
do {
for (d = delims; *d != '\0'; ++d) {
if (*i == *d) {
*i = '\0';
*str = ++i;
return ret;
}
}
++i;
} while (*i);
*str = NULL;
return ret;
}
static const char kNL[] = "\r\n";
static const char kEquals[] = "=";
static const char kWhitespace[] = " \t";
static const char kRBracket[] = "]";
nsresult
nsINIParser::InitFromFILE(FILE *fd)
{
if (!mSections.Init())
return NS_ERROR_OUT_OF_MEMORY;
/* get file size */
if (fseek(fd, 0, SEEK_END) != 0)
return NS_ERROR_FAILURE;
long flen = ftell(fd);
if (flen == 0)
return NS_ERROR_FAILURE;
/* malloc an internal buf the size of the file */
mFileContents = new char[flen + 1];
if (!mFileContents)
return NS_ERROR_OUT_OF_MEMORY;
/* read the file in one swoop */
if (fseek(fd, 0, SEEK_SET) != 0)
return NS_BASE_STREAM_OSERROR;
int rd = fread(mFileContents, sizeof(char), flen, fd);
if (rd != flen)
return NS_BASE_STREAM_OSERROR;
mFileContents[flen] = '\0';
char *buffer = mFileContents;
char *currSection = nsnull;
INIValue *last = nsnull;
// outer loop tokenizes into lines
while (char *line = mstrtok(kNL, &buffer)) {
if (line[0] == '#') // it's a comment
continue;
char *token = mstrtok(kWhitespace, &line);
if (!token) // empty line
continue;
if (token[0] == '[') { // section header!
++token;
currSection = token;
last = nsnull;
char *rb = mstrtok(kRBracket, &token);
if (!rb || mstrtok(kWhitespace, &token)) {
// there's either an unclosed [Section or a [Section]Moretext!
// we could frankly decide that this INI file is malformed right
// here and stop, but we won't... keep going, looking for
// a well-formed [section] to continue working with
currSection = nsnull;
}
continue;
}
if (!currSection) {
// If we haven't found a section header (or we found a malformed
// section header), don't bother parsing this line.
continue;
}
char *key = token;
char *e = mstrtok(kEquals, &token);
if (!e)
continue;
INIValue *val = new INIValue(key, token);
if (!val)
return NS_ERROR_OUT_OF_MEMORY;
// If we haven't already added something to this section, "last" will
// be null.
if (!last) {
mSections.Get(currSection, &last);
while (last && last->next)
last = last->next;
}
if (last) {
// Add this element on to the tail of the existing list
last->next = val;
last = val;
continue;
}
// We've never encountered this section before, add it to the head
mSections.Put(currSection, val);
}
return NS_OK;
}
nsresult
nsINIParser::GetString(const char *aSection, const char *aKey,
nsACString &aResult)
{
INIValue *val;
mSections.Get(aSection, &val);
while (val) {
if (strcmp(val->key, aKey) == 0) {
aResult.Assign(val->value);
return NS_OK;
}
val = val->next;
}
return NS_ERROR_FAILURE;
}
nsresult
nsINIParser::GetString(const char *aSection, const char *aKey,
char *aResult, PRUint32 aResultLen)
{
INIValue *val;
mSections.Get(aSection, &val);
while (val) {
if (strcmp(val->key, aKey) == 0) {
strncpy(aResult, val->value, aResultLen);
aResult[aResultLen - 1] = '\0';
if (strlen(val->value) >= aResultLen)
return NS_ERROR_LOSS_OF_SIGNIFICANT_DATA;
return NS_OK;
}
val = val->next;
}
return NS_ERROR_FAILURE;
}
PLDHashOperator
nsINIParser::GetSectionsCB(const char *aKey, INIValue *aData,
void *aClosure)
{
GSClosureStruct *cs = NS_REINTERPRET_CAST(GSClosureStruct*, aClosure);
return cs->usercb(aKey, cs->userclosure) ? PL_DHASH_NEXT : PL_DHASH_STOP;
}
nsresult
nsINIParser::GetSections(INISectionCallback aCB, void *aClosure)
{
GSClosureStruct gs = {
aCB,
aClosure
};
mSections.EnumerateRead(GetSectionsCB, &gs);
return NS_OK;
}
nsresult
nsINIParser::GetStrings(const char *aSection,
INIStringCallback aCB, void *aClosure)
{
INIValue *val;
for (mSections.Get(aSection, &val);
val;
val = val->next) {
if (!aCB(val->key, val->value, aClosure))
return NS_OK;
}
return NS_OK;
}

158
mozilla/xpcom/glue/nsINIParser.h Normal file
View File

@ -0,0 +1,158 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* 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 Communicator client code, released
* March 31, 1998.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Samir Gehani <sgehani@netscape.com>
* Benjamin Smedberg <bsmedberg@covad.net>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
// This file was shamelessly copied from mozilla/xpinstall/wizard/unix/src2
#ifndef nsINIParser_h__
#define nsINIParser_h__
#include "nscore.h"
#include "nsClassHashtable.h"
#include "nsAutoPtr.h"
#include <stdio.h>
class nsILocalFile;
class nsINIParser
{
public:
nsINIParser() { }
~nsINIParser() { }
/**
* Initialize the INIParser with a nsILocalFile. If this method fails, no
* other methods should be called. This method reads and parses the file,
* the class does not hold a file handle open. An instance must only be
* initialized once.
*/
nsresult Init(nsILocalFile* aFile);
/**
* Initialize the INIParser with a file path. If this method fails, no
* other methods should be called. This method reads and parses the file,
* the class does not hold a file handle open. An instance must only
* be initialized once.
*/
nsresult Init(const char *aPath);
/**
* Callback for GetSections
* @return PR_FALSE to stop enumeration, or PR_TRUE to continue.
*/
typedef PRBool
(* PR_CALLBACK INISectionCallback)(const char *aSection,
void *aClosure);
/**
* Enumerate the sections within the INI file.
*/
nsresult GetSections(INISectionCallback aCB, void *aClosure);
/**
* Callback for GetStrings
* @return PR_FALSE to stop enumeration, or PR_TRUE to continue
*/
typedef PRBool
(* PR_CALLBACK INIStringCallback)(const char *aString,
const char *aValue,
void *aClosure);
/**
* Enumerate the strings within a section. If the section does
* not exist, this function will silently return.
*/
nsresult GetStrings(const char *aSection,
INIStringCallback aCB, void *aClosure);
/**
* Get the value of the specified key in the specified section
* of the INI file represented by this instance.
*
* @param aSection section name
* @param aKey key name
* @param aResult the value found
* @throws NS_ERROR_FAILURE if the specified section/key could not be
* found.
*/
nsresult GetString(const char *aSection, const char *aKey,
nsACString &aResult);
/**
* Alternate signature of GetString that uses a pre-allocated buffer
* instead of a nsACString (for use in the standalone glue before
* the glue is initialized).
*
* @throws NS_ERROR_LOSS_OF_SIGNIFICANT_DATA if the aResult buffer is not
* large enough for the data. aResult will be filled with as
* much data as possible.
*
* @see GetString [1]
*/
nsresult GetString(const char *aSection, const char* aKey,
char *aResult, PRUint32 aResultLen);
private:
struct INIValue
{
INIValue(const char *aKey, const char *aValue)
: key(aKey), value(aValue) { }
const char *key;
const char *value;
nsAutoPtr<INIValue> next;
};
struct GSClosureStruct
{
INISectionCallback usercb;
void *userclosure;
};
nsClassHashtable<nsDepCharHashKey, INIValue> mSections;
nsAutoArrayPtr<char> mFileContents;
nsresult InitFromFILE(FILE *fd);
static PLDHashOperator GetSectionsCB(const char *aKey,
INIValue *aData, void *aClosure);
};
#endif /* nsINIParser_h__ */

59
mozilla/xpcom/glue/nsTHashtable.cpp
View File

@ -38,6 +38,65 @@
#include "nsTHashtable.h"
#include "nsHashKeys.h"
PRUint32
HashString( const nsAString& aStr )
{
PRUint32 code = 0;
#ifdef MOZILLA_INTERNAL_API
nsAString::const_iterator begin, end;
aStr.BeginReading(begin);
aStr.EndReading(end);
#else
const PRUnichar *begin, *end;
PRUint32 len = NS_StringGetData(aStr, &begin);
end = begin + len;
#endif
while (begin != end) {
code = (code>>28) ^ (code<<4) ^ PRUint32(*begin);
++begin;
}
return code;
}
PRUint32
HashString( const nsACString& aStr )
{
PRUint32 code = 0;
#ifdef MOZILLA_INTERNAL_API
nsACString::const_iterator begin, end;
aStr.BeginReading(begin);
aStr.EndReading(end);
#else
const char *begin, *end;
PRUint32 len = NS_CStringGetData(aStr, &begin);
end = begin + len;
#endif
while (begin != end) {
code = (code>>28) ^ (code<<4) ^ PRUint32(*begin);
++begin;
}
return code;
}
PRUint32
HashCString(const char *str)
{
PRUint32 code = 0;
while (*str) {
code = (code>>28) ^ (code<<4) ^ PRUint32(*str);
++str;
}
return code;
}
PR_IMPLEMENT(PLDHashOperator)
PL_DHashStubEnumRemove(PLDHashTable *table,
PLDHashEntryHdr *entry,

42
mozilla/xpcom/glue/objs.mk
View File

@ -34,27 +34,35 @@
#
# ***** END LICENSE BLOCK *****
XPCOM_GLUE_SRC_LCSRCS = \
nsCOMPtr.cpp \
nsComponentManagerUtils.cpp \
nsDebug.cpp \
nsID.cpp \
nsIInterfaceRequestorUtils.cpp \
nsMemory.cpp \
nsTraceRefcnt.cpp \
nsWeakReference.cpp \
nsGREGlue.cpp \
nsVersionComparator.cpp \
$(NULL)
XPCOM_GLUE_SRC_LCSRCS = \
pldhash.c \
$(NULL)
XPCOM_GLUE_SRC_CSRCS := $(addprefix $(topsrcdir)/xpcom/glue/, $(XPCOM_GLUE_SRC_LCSRCS))
XPCOM_GLUE_SRC_CSRCS = $(addprefix $(topsrcdir)/xpcom/glue/, $(XPCOM_GLUE_SRC_LCSRCS))
XPCOM_GLUE_SRC_LCPPSRCS = \
nsCOMPtr.cpp \
nsComponentManagerUtils.cpp \
nsDebug.cpp \
nsID.cpp \
nsIInterfaceRequestorUtils.cpp \
nsINIParser.cpp \
nsMemory.cpp \
nsTraceRefcnt.cpp \
nsWeakReference.cpp \
nsGREGlue.cpp \
nsVersionComparator.cpp \
nsTHashtable.cpp \
$(NULL)
XPCOM_GLUE_SRC_CPPSRCS = $(addprefix $(topsrcdir)/xpcom/glue/, $(XPCOM_GLUE_SRC_LCPPSRCS))
# nsGenericFactory is not really all that helpful in the standalone glue,
# and it has a bad dependency on the NSPR AtomicIncrement function, so we
# only build it for the dependent XPCOM glue and builtin to xpcom-core.
XPCOM_GLUENS_SRC_LCSRCS = \
nsGenericFactory.cpp \
$(NULL)
XPCOM_GLUENS_SRC_LCPPSRCS = \
nsGenericFactory.cpp \
$(NULL)
XPCOM_GLUENS_SRC_CSRCS := $(addprefix $(topsrcdir)/xpcom/glue/,$(XPCOM_GLUENS_SRC_LCSRCS))
XPCOM_GLUENS_SRC_CPPSRCS = $(addprefix $(topsrcdir)/xpcom/glue/,$(XPCOM_GLUENS_SRC_LCPPSRCS))

8
mozilla/xpcom/glue/standalone/Makefile.in
View File

@ -71,8 +71,12 @@ LINKSRC = nsGlueLinkingNull.cpp
$(warning TinderboxPrint:<a href="https://bugzilla.mozilla.org/show_bug.cgi?id=298044">Error: XPCOM Glue</a>)
endif
CSRCS = \
$(XPCOM_GLUE_SRC_LCSRCS) \
$(NULL)
CPPSRCS = \
$(XPCOM_GLUE_SRC_LCSRCS) \
$(XPCOM_GLUE_SRC_LCPPSRCS) \
nsXPCOMGlue.cpp \
nsGREDirServiceProvider.cpp \
$(LINKSRC) \
@ -98,7 +102,7 @@ SRCS_IN_OBJDIR = 1
include $(topsrcdir)/config/rules.mk
export:: $(XPCOM_GLUE_SRC_CSRCS)
export:: $(XPCOM_GLUE_SRC_CSRCS) $(XPCOM_GLUE_SRC_CPPSRCS)
$(INSTALL) $^ .
DEFINES += -DXPCOM_GLUE

3
mozilla/xpcom/string/public/nsReadableUtils.h
View File

@ -360,9 +360,6 @@ StringEndsWith( const nsACString& aSource, const nsACString& aSubstring,
const nsCStringComparator& aComparator =
nsDefaultCStringComparator() );
NS_COM PRUint32 HashString( const nsAString& aStr );
NS_COM PRUint32 HashString( const nsACString& aStr );
NS_COM const nsAFlatString& EmptyString();
NS_COM const nsAFlatCString& EmptyCString();

26
mozilla/xpcom/string/public/nsStringAPI.h
View File

@ -38,6 +38,8 @@
#ifndef nsStringAPI_h__
#define nsStringAPI_h__
#include <string.h>
/**
* nsStringAPI.h
*
@ -921,6 +923,18 @@ public:
NS_HIDDEN_(void) Cut( index_type cutStart, size_type cutLength ) { Replace(cutStart, cutLength, nsnull, 0); }
NS_HIDDEN_(PRBool) Equals( const self_type &other ) const {
const char_type *cself;
const char_type *cother;
PRUint32 selflen = NS_StringGetData(*this, &cself);
PRUint32 otherlen = NS_StringGetData(other, &cother);
if (selflen != otherlen)
return PR_FALSE;
return memcmp(cself, cother, selflen * sizeof(char_type)) == 0;
}
#endif // MOZILLA_INTERNAL_API
protected:
@ -1026,6 +1040,18 @@ public:
NS_HIDDEN_(void) Cut( index_type cutStart, size_type cutLength ) { Replace(cutStart, cutLength, nsnull, 0); }
NS_HIDDEN_(PRBool) Equals( const self_type &other ) const {
const char_type *cself;
const char_type *cother;
PRUint32 selflen = NS_CStringGetData(*this, &cself);
PRUint32 otherlen = NS_CStringGetData(other, &cother);
if (selflen != otherlen)
return PR_FALSE;
return memcmp(cself, cother, selflen * sizeof(char_type)) == 0;
}
#endif // MOZILLA_INTERNAL_API
protected:

42
mozilla/xpcom/string/src/nsReadableUtils.cpp
View File

@ -1079,48 +1079,6 @@ StringEndsWith( const nsACString& aSource, const nsACString& aSubstring,
template <class CharT>
class CalculateHashCode
{
public:
typedef CharT char_type;
typedef PRUint32 hashcode_type;
typedef CharT value_type;
CalculateHashCode() : mHashCode(0) { }
hashcode_type GetHashCode() const { return mHashCode; }
PRUint32 write( const CharT* chars, PRUint32 N )
{
for ( const CharT *end = chars + N; chars < end; ++chars)
mHashCode = (mHashCode>>28) ^ (mHashCode<<4) ^ PRUint32(*chars);
return N;
}
private:
hashcode_type mHashCode;
};
NS_COM PRUint32 HashString( const nsAString& aStr )
{
CalculateHashCode<nsAString::char_type> sink;
nsAString::const_iterator begin, end;
aStr.BeginReading(begin);
aStr.EndReading(end);
copy_string(begin, end, sink);
return sink.GetHashCode();
}
NS_COM PRUint32 HashString( const nsACString& aStr )
{
CalculateHashCode<nsACString::char_type> sink;
nsACString::const_iterator begin, end;
aStr.BeginReading(begin);
aStr.EndReading(end);
copy_string(begin, end, sink);
return sink.GetHashCode();
}
static const PRUnichar empty_buffer[1] = { '\0' };
NS_COM const nsAFlatString& EmptyString()

1
mozilla/xpcom/tests/Makefile.in
View File

@ -67,6 +67,7 @@ CPPSRCS = \
TestFactory.cpp \
TestHashtables.cpp \
TestID.cpp \
TestINIParser.cpp \
TestObserverService.cpp \
TestPermanentAtoms.cpp \
TestPipes.cpp \

71
mozilla/xpcom/ds/nsTHashtable.cpp → mozilla/xpcom/tests/TestINIParser.cpp
View File

@ -1,4 +1,3 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
@ -12,11 +11,12 @@
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is C++ hashtable templates.
* The Original Code is Mozilla XPCOM tests.
*
* The Initial Developer of the Original Code is
* Benjamin Smedberg.
* Portions created by the Initial Developer are Copyright (C) 2002
* Benjamin Smedberg <benjamin@smedbergs.us>.
*
* Portions created by the Initial Developer are Copyright (C) 2005
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
@ -35,28 +35,59 @@
*
* ***** END LICENSE BLOCK ***** */
#include "nsTHashtable.h"
#include "nsHashKeys.h"
#include <string.h>
PR_IMPLEMENT(PLDHashOperator)
PL_DHashStubEnumRemove(PLDHashTable *table,
PLDHashEntryHdr *entry,
PRUint32 ordinal,
void *userarg)
#include "nsINIParser.h"
#include "nsILocalFile.h"
static PRBool
StringCB(const char *aKey, const char *aValue, void* aClosure)
{
return PL_DHASH_REMOVE;
printf("%s=%s\n", aKey, aValue);
return PR_TRUE;
}
PRUint32 nsIDHashKey::HashKey(const nsID* id)
static PRBool
SectionCB(const char *aSection, void* aClosure)
{
PRUint32 h = id->m0;
PRUint32 i;
nsINIParser *ini = NS_REINTERPRET_CAST(nsINIParser*, aClosure);
h = (h>>28) ^ (h<<4) ^ id->m1;
h = (h>>28) ^ (h<<4) ^ id->m2;
printf("[%s]\n", aSection);
for (i = 0; i < 8; i++)
h = (h>>28) ^ (h<<4) ^ id->m3[i];
ini->GetStrings(aSection, StringCB, nsnull);
return h;
printf("\n");
return PR_TRUE;
}
int main(int argc, char **argv)
{
if (argc < 2) {
fprintf(stderr, "Usage: %s <ini-file>\n", argv[0]);
return 255;
}
nsCOMPtr<nsILocalFile> lf;
nsresult rv = NS_NewNativeLocalFile(nsDependentCString(argv[1]),
PR_TRUE,
getter_AddRefs(lf));
if (NS_FAILED(rv)) {
fprintf(stderr, "Error: NS_NewNativeLocalFile failed\n");
return 1;
}
nsINIParser ini;
rv = ini.Init(lf);
if (NS_FAILED(rv)) {
fprintf(stderr, "Error: Init failed.");
return 2;
}
ini.GetSections(SectionCB, &ini);
return 0;
}

9
mozilla/xulrunner/app/Makefile.in
View File

@ -82,10 +82,6 @@ CPPSRCS += nsRegisterGREUnix.cpp
endif
endif
ifdef MOZ_ENABLE_LIBXUL
CPPSRCS += nsINIParser.cpp
endif
LOCAL_INCLUDES += \
-I$(topsrcdir)/toolkit/xre \
-I$(topsrcdir)/toolkit/profile/src \
@ -329,11 +325,6 @@ endif
README_FILE = $(topsrcdir)/README.txt
ifdef MOZ_ENABLE_LIBXUL
export::
$(INSTALL) $(topsrcdir)/toolkit/profile/src/nsINIParser.cpp .
endif
libs::
$(INSTALL) $(README_FILE) $(DIST)/bin
$(INSTALL) $(topsrcdir)/LICENSE $(DIST)/bin

44
mozilla/xulrunner/app/nsXULRunnerApp.cpp
View File

@ -139,10 +139,11 @@ static PRBool CheckMaxVersion(const char *versionStr)
/**
* Parse application data.
*/
static int LoadAppData(const char* appDataFile, nsXREAppData* aResult)
static int LoadAppData(const char* appDataFile, nsXREAppData* aResult,
nsCString& vendor, nsCString& name, nsCString& version,
nsCString& buildID, nsCString& appID,
nsCString& copyright)
{
static char vendor[256], name[256], version[32], buildID[32], appID[256], copyright[512];
nsresult rv;
nsCOMPtr<nsILocalFile> lf;
@ -169,15 +170,16 @@ static int LoadAppData(const char* appDataFile, nsXREAppData* aResult)
// TODO: If these version checks fail, then look for a compatible XULRunner
// version on the system, and launch it instead.
char gkVersion[32];
rv = parser.GetString("Gecko", "MinVersion", gkVersion, sizeof(gkVersion));
if (NS_FAILED(rv) || !CheckMinVersion(gkVersion)) {
nsCAutoString gkVersion;
rv = parser.GetString("Gecko", "MinVersion", gkVersion);
if (NS_FAILED(rv) || !CheckMinVersion(gkVersion.get())) {
Output(PR_TRUE, "Error: Gecko MinVersion requirement not met.\n");
return 1;
}
rv = parser.GetString("Gecko", "MaxVersion", gkVersion, sizeof(gkVersion));
if (NS_SUCCEEDED(rv) && !CheckMaxVersion(gkVersion)) {
rv = parser.GetString("Gecko", "MaxVersion", gkVersion);
if (NS_SUCCEEDED(rv) && !CheckMaxVersion(gkVersion.get())) {
Output(PR_TRUE, "Error: Gecko MaxVersion requirement not met.\n");
return 1;
}
@ -188,22 +190,21 @@ static int LoadAppData(const char* appDataFile, nsXREAppData* aResult)
const struct {
const char *key;
const char **fill;
char *buf;
size_t bufLen;
nsCString &buf;
PRBool required;
} string_fields[] = {
{ "Vendor", &aResult->vendor, vendor, sizeof(vendor), PR_FALSE },
{ "Name", &aResult->name, name, sizeof(name), PR_TRUE },
{ "Version", &aResult->version, version, sizeof(version), PR_FALSE },
{ "BuildID", &aResult->buildID, buildID, sizeof(buildID), PR_TRUE },
{ "ID", &aResult->ID, appID, sizeof(appID), PR_FALSE },
{ "Copyright", &aResult->copyright, copyright, sizeof(copyright), PR_FALSE }
{ "Vendor", &aResult->vendor, vendor, PR_FALSE },
{ "Name", &aResult->name, name, PR_TRUE },
{ "Version", &aResult->version, version, PR_FALSE },
{ "BuildID", &aResult->buildID, buildID, PR_TRUE },
{ "ID", &aResult->ID, appID, PR_FALSE },
{ "Copyright", &aResult->copyright, copyright, PR_FALSE }
};
for (i = 0; i < NS_ARRAY_LENGTH(string_fields); ++i) {
rv = parser.GetString("App", string_fields[i].key, string_fields[i].buf,
string_fields[i].bufLen);
rv = parser.GetString("App", string_fields[i].key,
string_fields[i].buf);
if (NS_SUCCEEDED(rv)) {
*string_fields[i].fill = string_fields[i].buf;
*string_fields[i].fill = string_fields[i].buf.get();
}
else if (string_fields[i].required) {
Output(PR_TRUE, "Error: %x: No \"%s\" field.\n",
@ -401,9 +402,12 @@ int main(int argc, char* argv[])
PR_SetEnv(kAppEnv);
}
nsCAutoString vendor, name, version, buildID, appID, copyright;
nsXREAppData appData = { sizeof(nsXREAppData), 0 };
int rv = LoadAppData(appDataFile, &appData);
int rv = LoadAppData(appDataFile, &appData,
vendor, name, version, buildID, appID, copyright);
if (!rv)
rv = XRE_main(argc, argv, &appData);