This broke windows.
[WebKit-https.git] / JavaScriptCore / runtime / Identifier.cpp
1 /*
2  *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
3  *
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.
8  *
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.
13  *
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.
18  *
19  */
20
21 #include "config.h"
22 #include "Identifier.h"
23
24 #include "CallFrame.h"
25 #include "NumericStrings.h"
26 #include <new> // for placement new
27 #include <string.h> // for strlen
28 #include <wtf/Assertions.h>
29 #include <wtf/FastMalloc.h>
30 #include <wtf/HashSet.h>
31
32 using WTF::ThreadSpecific;
33
34 namespace JSC {
35
36 typedef HashMap<const char*, RefPtr<UString::Rep>, PtrHash<const char*> > LiteralIdentifierTable;
37
38 class IdentifierTable : public FastAllocBase {
39 public:
40     ~IdentifierTable()
41     {
42         HashSet<UString::Rep*>::iterator end = m_table.end();
43         for (HashSet<UString::Rep*>::iterator iter = m_table.begin(); iter != end; ++iter)
44             (*iter)->setIsIdentifier(false);
45     }
46
47     std::pair<HashSet<UString::Rep*>::iterator, bool> add(UString::Rep* value)
48     {
49         std::pair<HashSet<UString::Rep*>::iterator, bool> result = m_table.add(value);
50         (*result.first)->setIsIdentifier(true);
51         return result;
52     }
53
54     template<typename U, typename V>
55     std::pair<HashSet<UString::Rep*>::iterator, bool> add(U value)
56     {
57         std::pair<HashSet<UString::Rep*>::iterator, bool> result = m_table.add<U, V>(value);
58         (*result.first)->setIsIdentifier(true);
59         return result;
60     }
61
62     void remove(UString::Rep* r) { m_table.remove(r); }
63
64     LiteralIdentifierTable& literalTable() { return m_literalTable; }
65
66 private:
67     HashSet<UString::Rep*> m_table;
68     LiteralIdentifierTable m_literalTable;
69 };
70
71 IdentifierTable* createIdentifierTable()
72 {
73     return new IdentifierTable;
74 }
75
76 void deleteIdentifierTable(IdentifierTable* table)
77 {
78     delete table;
79 }
80
81 bool Identifier::equal(const UString::Rep* r, const char* s)
82 {
83     int length = r->length();
84     const UChar* d = r->characters();
85     for (int i = 0; i != length; ++i)
86         if (d[i] != (unsigned char)s[i])
87             return false;
88     return s[length] == 0;
89 }
90
91 bool Identifier::equal(const UString::Rep* r, const UChar* s, unsigned length)
92 {
93     if (r->length() != length)
94         return false;
95     const UChar* d = r->characters();
96     for (unsigned i = 0; i != length; ++i)
97         if (d[i] != s[i])
98             return false;
99     return true;
100 }
101
102 struct CStringTranslator {
103     static unsigned hash(const char* c)
104     {
105         return UString::Rep::computeHash(c);
106     }
107
108     static bool equal(UString::Rep* r, const char* s)
109     {
110         return Identifier::equal(r, s);
111     }
112
113     static void translate(UString::Rep*& location, const char* c, unsigned hash)
114     {
115         size_t length = strlen(c);
116         UChar* d;
117         UString::Rep* r = UString::Rep::createUninitialized(length, d).releaseRef();
118         for (size_t i = 0; i != length; i++)
119             d[i] = static_cast<unsigned char>(c[i]); // use unsigned char to zero-extend instead of sign-extend
120         r->setHash(hash);
121         location = r;
122     }
123 };
124
125 PassRefPtr<UString::Rep> Identifier::add(JSGlobalData* globalData, const char* c)
126 {
127     if (!c)
128         return UString::null().rep();
129     if (!c[0])
130         return UString::Rep::empty();
131     if (!c[1])
132         return add(globalData, globalData->smallStrings.singleCharacterStringRep(static_cast<unsigned char>(c[0])));
133
134     IdentifierTable& identifierTable = *globalData->identifierTable;
135     LiteralIdentifierTable& literalIdentifierTable = identifierTable.literalTable();
136
137     const LiteralIdentifierTable::iterator& iter = literalIdentifierTable.find(c);
138     if (iter != literalIdentifierTable.end())
139         return iter->second;
140
141     pair<HashSet<UString::Rep*>::iterator, bool> addResult = identifierTable.add<const char*, CStringTranslator>(c);
142
143     // If the string is newly-translated, then we need to adopt it.
144     // The boolean in the pair tells us if that is so.
145     RefPtr<UString::Rep> addedString = addResult.second ? adoptRef(*addResult.first) : *addResult.first;
146
147     literalIdentifierTable.add(c, addedString.get());
148
149     return addedString.release();
150 }
151
152 PassRefPtr<UString::Rep> Identifier::add(ExecState* exec, const char* c)
153 {
154     return add(&exec->globalData(), c);
155 }
156
157 struct UCharBuffer {
158     const UChar* s;
159     unsigned int length;
160 };
161
162 struct UCharBufferTranslator {
163     static unsigned hash(const UCharBuffer& buf)
164     {
165         return UString::Rep::computeHash(buf.s, buf.length);
166     }
167
168     static bool equal(UString::Rep* str, const UCharBuffer& buf)
169     {
170         return Identifier::equal(str, buf.s, buf.length);
171     }
172
173     static void translate(UString::Rep*& location, const UCharBuffer& buf, unsigned hash)
174     {
175         UChar* d;
176         UString::Rep* r = UString::Rep::createUninitialized(buf.length, d).releaseRef();
177         for (unsigned i = 0; i != buf.length; i++)
178             d[i] = buf.s[i];
179         r->setHash(hash);
180         location = r; 
181     }
182 };
183
184 PassRefPtr<UString::Rep> Identifier::add(JSGlobalData* globalData, const UChar* s, int length)
185 {
186     if (length == 1) {
187         UChar c = s[0];
188         if (c <= 0xFF)
189             return add(globalData, globalData->smallStrings.singleCharacterStringRep(c));
190     }
191     if (!length)
192         return UString::Rep::empty();
193     UCharBuffer buf = {s, length}; 
194     pair<HashSet<UString::Rep*>::iterator, bool> addResult = globalData->identifierTable->add<UCharBuffer, UCharBufferTranslator>(buf);
195
196     // If the string is newly-translated, then we need to adopt it.
197     // The boolean in the pair tells us if that is so.
198     return addResult.second ? adoptRef(*addResult.first) : *addResult.first;
199 }
200
201 PassRefPtr<UString::Rep> Identifier::add(ExecState* exec, const UChar* s, int length)
202 {
203     return add(&exec->globalData(), s, length);
204 }
205
206 PassRefPtr<UString::Rep> Identifier::addSlowCase(JSGlobalData* globalData, UString::Rep* r)
207 {
208     ASSERT(!r->isIdentifier());
209     // The empty & null strings are static singletons, and static strings are handled
210     // in ::add() in the header, so we should never get here with a zero length string.
211     ASSERT(r->length());
212
213     if (r->length() == 1) {
214         UChar c = r->characters()[0];
215         if (c <= 0xFF)
216             r = globalData->smallStrings.singleCharacterStringRep(c);
217             if (r->isIdentifier())
218                 return r;
219     }
220
221     return *globalData->identifierTable->add(r).first;
222 }
223
224 PassRefPtr<UString::Rep> Identifier::addSlowCase(ExecState* exec, UString::Rep* r)
225 {
226     return addSlowCase(&exec->globalData(), r);
227 }
228
229 void Identifier::remove(UString::Rep* r)
230 {
231     currentIdentifierTable()->remove(r);
232 }
233     
234 Identifier Identifier::from(ExecState* exec, unsigned value)
235 {
236     return Identifier(exec, exec->globalData().numericStrings.add(value));
237 }
238
239 Identifier Identifier::from(ExecState* exec, int value)
240 {
241     return Identifier(exec, exec->globalData().numericStrings.add(value));
242 }
243
244 Identifier Identifier::from(ExecState* exec, double value)
245 {
246     return Identifier(exec, exec->globalData().numericStrings.add(value));
247 }
248
249 #ifndef NDEBUG
250
251 void Identifier::checkCurrentIdentifierTable(JSGlobalData* globalData)
252 {
253     // Check the identifier table accessible through the threadspecific matches the
254     // globalData's identifier table.
255     ASSERT_UNUSED(globalData, globalData->identifierTable == currentIdentifierTable());
256 }
257
258 void Identifier::checkCurrentIdentifierTable(ExecState* exec)
259 {
260     checkCurrentIdentifierTable(&exec->globalData());
261 }
262
263 #else
264
265 // These only exists so that our exports are the same for debug and release builds.
266 // This would be an ASSERT_NOT_REACHED(), but we're in NDEBUG only code here!
267 void Identifier::checkCurrentIdentifierTable(JSGlobalData*) { CRASH(); }
268 void Identifier::checkCurrentIdentifierTable(ExecState*) { CRASH(); }
269
270 #endif
271
272 ThreadSpecific<ThreadIdentifierTableData>* g_identifierTableSpecific = 0;
273
274 #if ENABLE(JSC_MULTIPLE_THREADS)
275
276 pthread_once_t createIdentifierTableSpecificOnce = PTHREAD_ONCE_INIT;
277 static void createIdentifierTableSpecificCallback()
278 {
279     ASSERT(!g_identifierTableSpecific);
280     g_identifierTableSpecific = new ThreadSpecific<ThreadIdentifierTableData>();
281 }
282 void createIdentifierTableSpecific()
283 {
284     pthread_once(&createIdentifierTableSpecificOnce, createIdentifierTableSpecificCallback);
285     ASSERT(g_identifierTableSpecific);
286 }
287
288 #else 
289
290 void createIdentifierTableSpecific()
291 {
292     ASSERT(!g_identifierTableSpecific);
293     g_identifierTableSpecific = new ThreadSpecific<ThreadIdentifierTableData>();
294 }
295
296 #endif
297
298 } // namespace JSC