<https://bugs.webkit.org/show_bug.cgi?id=23049> [jsfunfuzz] With blocks do not correc...
[WebKit-https.git] / JavaScriptCore / parser / ResultType.h
1 /*
2  * Copyright (C) 2008 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 #ifndef ResultType_h
27 #define ResultType_h
28
29 namespace JSC {
30
31     struct ResultType {
32         friend struct OperandTypes;
33
34         typedef char Type;
35         static const Type TypeReusable = 1;
36         
37         static const Type TypeMaybeNumber = 2;
38         static const Type TypeMaybeString = 4;
39         static const Type TypeMaybeNull = 8;
40         static const Type TypeMaybeBool = 16;
41         static const Type TypeMaybeOther = 32;
42
43         static const Type TypeReusableNumber = 3;
44         static const Type TypeStringOrReusableNumber = 4;
45     
46         explicit ResultType(Type type)
47             : m_type(type)
48         {
49         }
50         
51         bool isReusable()
52         {
53             return (m_type & TypeReusable);
54         }
55
56         bool definitelyIsNumber()
57         {
58             return ((m_type & ~TypeReusable) == TypeMaybeNumber);
59         }
60         
61         bool isNotNumber()
62         {
63             return ((m_type & TypeMaybeNumber) == 0);
64         }
65         
66         bool mightBeNumber()
67         {
68             return !isNotNumber();
69         }
70
71         static ResultType nullType()
72         {
73             return ResultType(TypeMaybeNull);
74         }
75         
76         static ResultType boolean()
77         {
78             return ResultType(TypeMaybeBool);
79         }
80         
81         static ResultType constNumber()
82         {
83             return ResultType(TypeMaybeNumber);
84         }
85         
86         static ResultType reusableNumber()
87         {
88             return ResultType(TypeReusable | TypeMaybeNumber);
89         }
90         
91         static ResultType reusableNumberOrString()
92         {
93             return ResultType(TypeReusable | TypeMaybeNumber | TypeMaybeString);
94         }
95         
96         static ResultType string()
97         {
98             return ResultType(TypeMaybeString);
99         }
100         
101         static ResultType unknown()
102         {
103             return ResultType(TypeMaybeNumber | TypeMaybeString | TypeMaybeNull | TypeMaybeBool | TypeMaybeOther);
104         }
105         
106         static ResultType forAdd(ResultType op1, ResultType op2)
107         {
108             if (op1.definitelyIsNumber() && op2.definitelyIsNumber())
109                 return reusableNumber();
110             if (op1.isNotNumber() || op2.isNotNumber())
111                 return string();
112             return reusableNumberOrString();
113         }
114
115     private:
116         Type m_type;
117     };
118     
119     struct OperandTypes
120     {
121         OperandTypes(ResultType first = ResultType::unknown(), ResultType second = ResultType::unknown())
122         {
123             m_u.rds.first = first.m_type;
124             m_u.rds.second = second.m_type;
125         }
126         
127         union {
128             struct {
129                 ResultType::Type first;
130                 ResultType::Type second;
131             } rds;
132             int i;
133         } m_u;
134
135         ResultType first()
136         {
137             return ResultType(m_u.rds.first);
138         }
139
140         ResultType second()
141         {
142             return ResultType(m_u.rds.second);
143         }
144
145         int toInt()
146         {
147             return m_u.i;
148         }
149         static OperandTypes fromInt(int value)
150         {
151             OperandTypes types;
152             types.m_u.i = value;
153             return types;
154         }
155     };
156
157 } // namespace JSC
158
159 #endif // ResultType_h