2 * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public License
15 * along with this library; see the file COPYING.LIB. If not, write to
16 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17 * Boston, MA 02110-1301, USA.
22 #include "Identifier.h"
24 #include "CallFrame.h"
26 #include "NumericStrings.h"
27 #include "ScopeChain.h"
28 #include <new> // for placement new
29 #include <string.h> // for strlen
30 #include <wtf/Assertions.h>
31 #include <wtf/FastMalloc.h>
32 #include <wtf/HashSet.h>
33 #include <wtf/text/StringHash.h>
35 using WTF::ThreadSpecific;
39 IdentifierTable::~IdentifierTable()
41 HashSet<StringImpl*>::iterator end = m_table.end();
42 for (HashSet<StringImpl*>::iterator iter = m_table.begin(); iter != end; ++iter)
43 (*iter)->setIsIdentifier(false);
46 std::pair<HashSet<StringImpl*>::iterator, bool> IdentifierTable::add(StringImpl* value)
48 std::pair<HashSet<StringImpl*>::iterator, bool> result = m_table.add(value);
49 (*result.first)->setIsIdentifier(true);
53 IdentifierTable* createIdentifierTable()
55 return new IdentifierTable;
58 void deleteIdentifierTable(IdentifierTable* table)
63 struct IdentifierCStringTranslator {
64 static unsigned hash(const LChar* c)
66 return StringHasher::computeHash<LChar>(c);
69 static bool equal(StringImpl* r, const LChar* s)
71 return Identifier::equal(r, s);
74 static void translate(StringImpl*& location, const LChar* c, unsigned hash)
76 size_t length = strlen(reinterpret_cast<const char*>(c));
78 StringImpl* r = StringImpl::createUninitialized(length, d).leakRef();
79 for (size_t i = 0; i != length; i++)
86 struct IdentifierLCharFromUCharTranslator {
87 static unsigned hash(const CharBuffer<UChar>& buf)
89 return StringHasher::computeHash<UChar>(buf.s, buf.length);
92 static bool equal(StringImpl* str, const CharBuffer<UChar>& buf)
94 return Identifier::equal(str, buf.s, buf.length);
97 static void translate(StringImpl*& location, const CharBuffer<UChar>& buf, unsigned hash)
100 StringImpl* r = StringImpl::createUninitialized(buf.length, d).leakRef();
101 for (unsigned i = 0; i != buf.length; i++) {
111 PassRefPtr<StringImpl> Identifier::add(JSGlobalData* globalData, const char* c)
116 return StringImpl::empty();
118 return add(globalData, globalData->smallStrings.singleCharacterStringRep(c[0]));
120 IdentifierTable& identifierTable = *globalData->identifierTable;
121 LiteralIdentifierTable& literalIdentifierTable = identifierTable.literalTable();
123 const LiteralIdentifierTable::iterator& iter = literalIdentifierTable.find(c);
124 if (iter != literalIdentifierTable.end())
127 pair<HashSet<StringImpl*>::iterator, bool> addResult = identifierTable.add<const LChar*, IdentifierCStringTranslator>(reinterpret_cast<const LChar*>(c));
129 // If the string is newly-translated, then we need to adopt it.
130 // The boolean in the pair tells us if that is so.
131 RefPtr<StringImpl> addedString = addResult.second ? adoptRef(*addResult.first) : *addResult.first;
133 literalIdentifierTable.add(c, addedString.get());
135 return addedString.release();
138 PassRefPtr<StringImpl> Identifier::add(ExecState* exec, const char* c)
140 return add(&exec->globalData(), c);
143 PassRefPtr<StringImpl> Identifier::add8(JSGlobalData* globalData, const UChar* s, int length)
148 if (canUseSingleCharacterString(c))
149 return add(globalData, globalData->smallStrings.singleCharacterStringRep(c));
153 return StringImpl::empty();
154 CharBuffer<UChar> buf = {s, length};
155 pair<HashSet<StringImpl*>::iterator, bool> addResult = globalData->identifierTable->add<CharBuffer<UChar>, IdentifierLCharFromUCharTranslator >(buf);
157 // If the string is newly-translated, then we need to adopt it.
158 // The boolean in the pair tells us if that is so.
159 return addResult.second ? adoptRef(*addResult.first) : *addResult.first;
162 template <typename CharType>
163 ALWAYS_INLINE uint32_t Identifier::toUInt32FromCharacters(const CharType* characters, unsigned length, bool& ok)
165 // Get the first character, turning it into a digit.
166 uint32_t value = characters[0] - '0';
170 // Check for leading zeros. If the first characher is 0, then the
171 // length of the string must be one - e.g. "042" is not equal to "42".
172 if (!value && length > 1)
176 // Multiply value by 10, checking for overflow out of 32 bits.
177 if (value > 0xFFFFFFFFU / 10)
181 // Get the next character, turning it into a digit.
182 uint32_t newValue = *(++characters) - '0';
186 // Add in the old value, checking for overflow out of 32 bits.
188 if (newValue < value)
197 uint32_t Identifier::toUInt32(const UString& string, bool& ok)
201 unsigned length = string.length();
203 // An empty string is not a number.
208 return toUInt32FromCharacters(string.characters8(), length, ok);
209 return toUInt32FromCharacters(string.characters16(), length, ok);
212 PassRefPtr<StringImpl> Identifier::addSlowCase(JSGlobalData* globalData, StringImpl* r)
214 ASSERT(!r->isIdentifier());
215 // The empty & null strings are static singletons, and static strings are handled
216 // in ::add() in the header, so we should never get here with a zero length string.
219 if (r->length() == 1) {
221 if (c <= maxSingleCharacterString)
222 r = globalData->smallStrings.singleCharacterStringRep(c);
223 if (r->isIdentifier())
227 return *globalData->identifierTable->add(r).first;
230 PassRefPtr<StringImpl> Identifier::addSlowCase(ExecState* exec, StringImpl* r)
232 return addSlowCase(&exec->globalData(), r);
235 Identifier Identifier::from(ExecState* exec, unsigned value)
237 return Identifier(exec, exec->globalData().numericStrings.add(value));
240 Identifier Identifier::from(ExecState* exec, int value)
242 return Identifier(exec, exec->globalData().numericStrings.add(value));
245 Identifier Identifier::from(ExecState* exec, double value)
247 return Identifier(exec, exec->globalData().numericStrings.add(value));
250 Identifier Identifier::from(JSGlobalData* globalData, unsigned value)
252 return Identifier(globalData, globalData->numericStrings.add(value));
255 Identifier Identifier::from(JSGlobalData* globalData, int value)
257 return Identifier(globalData, globalData->numericStrings.add(value));
260 Identifier Identifier::from(JSGlobalData* globalData, double value)
262 return Identifier(globalData, globalData->numericStrings.add(value));
267 void Identifier::checkCurrentIdentifierTable(JSGlobalData* globalData)
269 // Check the identifier table accessible through the threadspecific matches the
270 // globalData's identifier table.
271 ASSERT_UNUSED(globalData, globalData->identifierTable == wtfThreadData().currentIdentifierTable());
274 void Identifier::checkCurrentIdentifierTable(ExecState* exec)
276 checkCurrentIdentifierTable(&exec->globalData());
281 // These only exists so that our exports are the same for debug and release builds.
282 // This would be an ASSERT_NOT_REACHED(), but we're in NDEBUG only code here!
283 NO_RETURN_DUE_TO_CRASH void Identifier::checkCurrentIdentifierTable(JSGlobalData*) { CRASH(); }
284 NO_RETURN_DUE_TO_CRASH void Identifier::checkCurrentIdentifierTable(ExecState*) { CRASH(); }