Never include *Inlines.h files in interface headers, and never include *Inlines.h...
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGLazyJSValue.cpp
1 /*
2  * Copyright (C) 2013 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27
28 #if ENABLE(DFG_JIT)
29
30 #include "DFGLazyJSValue.h"
31
32 #include "Operations.h"
33
34 namespace JSC { namespace DFG {
35
36 JSValue LazyJSValue::getValue(VM& vm) const
37 {
38     switch (m_kind) {
39     case KnownValue:
40         return value();
41     case SingleCharacterString:
42         return jsSingleCharacterString(&vm, u.character);
43     case KnownStringImpl:
44         return jsString(&vm, u.stringImpl);
45     }
46     RELEASE_ASSERT_NOT_REACHED();
47     return value();
48 }
49
50 static TriState equalToSingleCharacter(JSValue value, UChar character)
51 {
52     if (!value.isString())
53         return FalseTriState;
54     
55     JSString* jsString = asString(value);
56     if (jsString->length() != 1)
57         return FalseTriState;
58     
59     const StringImpl* string = jsString->tryGetValueImpl();
60     if (!string)
61         return MixedTriState;
62     
63     return triState(string->at(0) == character);
64 }
65
66 static TriState equalToStringImpl(JSValue value, StringImpl* stringImpl)
67 {
68     if (!value.isString())
69         return FalseTriState;
70     
71     JSString* jsString = asString(value);
72     const StringImpl* string = jsString->tryGetValueImpl();
73     if (!string)
74         return MixedTriState;
75     
76     return triState(WTF::equal(stringImpl, string));
77 }
78
79 TriState LazyJSValue::strictEqual(const LazyJSValue& other) const
80 {
81     switch (m_kind) {
82     case KnownValue:
83         switch (other.m_kind) {
84         case KnownValue:
85             return JSValue::pureStrictEqual(value(), other.value());
86         case SingleCharacterString:
87             return equalToSingleCharacter(value(), other.character());
88         case KnownStringImpl:
89             return equalToStringImpl(value(), other.stringImpl());
90         }
91         break;
92     case SingleCharacterString:
93         switch (other.m_kind) {
94         case SingleCharacterString:
95             return triState(character() == other.character());
96         case KnownStringImpl:
97             if (other.stringImpl()->length() != 1)
98                 return FalseTriState;
99             return triState(other.stringImpl()->at(0) == character());
100         default:
101             return other.strictEqual(*this);
102         }
103         break;
104     case KnownStringImpl:
105         switch (other.m_kind) {
106         case KnownStringImpl:
107             return triState(WTF::equal(stringImpl(), other.stringImpl()));
108         default:
109             return other.strictEqual(*this);
110         }
111         break;
112     }
113     RELEASE_ASSERT_NOT_REACHED();
114     return FalseTriState;
115 }
116
117 void LazyJSValue::dumpInContext(PrintStream& out, DumpContext* context) const
118 {
119     switch (m_kind) {
120     case KnownValue:
121         value().dumpInContext(out, context);
122         return;
123     case SingleCharacterString:
124         out.print("Lazy:SingleCharacterString(");
125         out.printf("%04X", static_cast<unsigned>(character()));
126         out.print(" / ", StringImpl::utf8ForCharacters(&u.character, 1), ")");
127         return;
128     case KnownStringImpl:
129         out.print("Lazy:String(", stringImpl(), ")");
130         return;
131     }
132     RELEASE_ASSERT_NOT_REACHED();
133 }
134
135 void LazyJSValue::dump(PrintStream& out) const
136 {
137     dumpInContext(out, 0);
138 }
139
140 } } // namespace JSC::DFG
141
142 #endif // ENABLE(DFG_JIT)
143