Move back primary header includes next to config.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 #include "DFGLazyJSValue.h"
28
29 #if ENABLE(DFG_JIT)
30
31 #include "JSCInlines.h"
32
33 namespace JSC { namespace DFG {
34
35 JSValue LazyJSValue::getValue(VM& vm) const
36 {
37     switch (m_kind) {
38     case KnownValue:
39         return value();
40     case SingleCharacterString:
41         return jsSingleCharacterString(&vm, u.character);
42     case KnownStringImpl:
43         return jsString(&vm, u.stringImpl);
44     }
45     RELEASE_ASSERT_NOT_REACHED();
46     return value();
47 }
48
49 static TriState equalToSingleCharacter(JSValue value, UChar character)
50 {
51     if (!value.isString())
52         return FalseTriState;
53     
54     JSString* jsString = asString(value);
55     if (jsString->length() != 1)
56         return FalseTriState;
57     
58     const StringImpl* string = jsString->tryGetValueImpl();
59     if (!string)
60         return MixedTriState;
61     
62     return triState(string->at(0) == character);
63 }
64
65 static TriState equalToStringImpl(JSValue value, StringImpl* stringImpl)
66 {
67     if (!value.isString())
68         return FalseTriState;
69     
70     JSString* jsString = asString(value);
71     const StringImpl* string = jsString->tryGetValueImpl();
72     if (!string)
73         return MixedTriState;
74     
75     return triState(WTF::equal(stringImpl, string));
76 }
77
78 TriState LazyJSValue::strictEqual(const LazyJSValue& other) const
79 {
80     switch (m_kind) {
81     case KnownValue:
82         switch (other.m_kind) {
83         case KnownValue:
84             return JSValue::pureStrictEqual(value(), other.value());
85         case SingleCharacterString:
86             return equalToSingleCharacter(value(), other.character());
87         case KnownStringImpl:
88             return equalToStringImpl(value(), other.stringImpl());
89         }
90         break;
91     case SingleCharacterString:
92         switch (other.m_kind) {
93         case SingleCharacterString:
94             return triState(character() == other.character());
95         case KnownStringImpl:
96             if (other.stringImpl()->length() != 1)
97                 return FalseTriState;
98             return triState(other.stringImpl()->at(0) == character());
99         default:
100             return other.strictEqual(*this);
101         }
102         break;
103     case KnownStringImpl:
104         switch (other.m_kind) {
105         case KnownStringImpl:
106             return triState(WTF::equal(stringImpl(), other.stringImpl()));
107         default:
108             return other.strictEqual(*this);
109         }
110         break;
111     }
112     RELEASE_ASSERT_NOT_REACHED();
113     return FalseTriState;
114 }
115
116 void LazyJSValue::dumpInContext(PrintStream& out, DumpContext* context) const
117 {
118     switch (m_kind) {
119     case KnownValue:
120         value().dumpInContext(out, context);
121         return;
122     case SingleCharacterString:
123         out.print("Lazy:SingleCharacterString(");
124         out.printf("%04X", static_cast<unsigned>(character()));
125         out.print(" / ", StringImpl::utf8ForCharacters(&u.character, 1), ")");
126         return;
127     case KnownStringImpl:
128         out.print("Lazy:String(", stringImpl(), ")");
129         return;
130     }
131     RELEASE_ASSERT_NOT_REACHED();
132 }
133
134 void LazyJSValue::dump(PrintStream& out) const
135 {
136     dumpInContext(out, 0);
137 }
138
139 } } // namespace JSC::DFG
140
141 #endif // ENABLE(DFG_JIT)
142