9d83290a5c2c0580f5af9c7b9b968c6b1409d06d
[WebKit-https.git] / Source / JavaScriptCore / runtime / MathObject.cpp
1 /*
2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2007, 2008 Apple Inc. All Rights Reserved.
4  *
5  *  This library is free software; you can redistribute it and/or
6  *  modify it under the terms of the GNU Lesser General Public
7  *  License as published by the Free Software Foundation; either
8  *  version 2 of the License, or (at your option) any later version.
9  *
10  *  This library is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  Lesser General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Lesser General Public
16  *  License along with this library; if not, write to the Free Software
17  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
18  *
19  */
20
21 #include "config.h"
22 #include "MathObject.h"
23
24 #include "Lookup.h"
25 #include "ObjectPrototype.h"
26 #include "Operations.h"
27 #include <time.h>
28 #include <wtf/Assertions.h>
29 #include <wtf/MathExtras.h>
30 #include <wtf/RandomNumber.h>
31 #include <wtf/RandomNumberSeed.h>
32
33 namespace JSC {
34
35 ASSERT_CLASS_FITS_IN_CELL(MathObject);
36
37 static EncodedJSValue JSC_HOST_CALL mathProtoFuncAbs(ExecState*);
38 static EncodedJSValue JSC_HOST_CALL mathProtoFuncACos(ExecState*);
39 static EncodedJSValue JSC_HOST_CALL mathProtoFuncASin(ExecState*);
40 static EncodedJSValue JSC_HOST_CALL mathProtoFuncATan(ExecState*);
41 static EncodedJSValue JSC_HOST_CALL mathProtoFuncATan2(ExecState*);
42 static EncodedJSValue JSC_HOST_CALL mathProtoFuncCeil(ExecState*);
43 static EncodedJSValue JSC_HOST_CALL mathProtoFuncCos(ExecState*);
44 static EncodedJSValue JSC_HOST_CALL mathProtoFuncExp(ExecState*);
45 static EncodedJSValue JSC_HOST_CALL mathProtoFuncFloor(ExecState*);
46 static EncodedJSValue JSC_HOST_CALL mathProtoFuncLog(ExecState*);
47 static EncodedJSValue JSC_HOST_CALL mathProtoFuncMax(ExecState*);
48 static EncodedJSValue JSC_HOST_CALL mathProtoFuncMin(ExecState*);
49 static EncodedJSValue JSC_HOST_CALL mathProtoFuncPow(ExecState*);
50 static EncodedJSValue JSC_HOST_CALL mathProtoFuncRandom(ExecState*);
51 static EncodedJSValue JSC_HOST_CALL mathProtoFuncRound(ExecState*);
52 static EncodedJSValue JSC_HOST_CALL mathProtoFuncSin(ExecState*);
53 static EncodedJSValue JSC_HOST_CALL mathProtoFuncSqrt(ExecState*);
54 static EncodedJSValue JSC_HOST_CALL mathProtoFuncTan(ExecState*);
55
56 }
57
58 #include "MathObject.lut.h"
59
60 namespace JSC {
61
62 ASSERT_HAS_TRIVIAL_DESTRUCTOR(MathObject);
63
64 const ClassInfo MathObject::s_info = { "Math", &JSNonFinalObject::s_info, 0, ExecState::mathTable, CREATE_METHOD_TABLE(MathObject) };
65
66 /* Source for MathObject.lut.h
67 @begin mathTable
68   abs           mathProtoFuncAbs               DontEnum|Function 1
69   acos          mathProtoFuncACos              DontEnum|Function 1
70   asin          mathProtoFuncASin              DontEnum|Function 1
71   atan          mathProtoFuncATan              DontEnum|Function 1
72   atan2         mathProtoFuncATan2             DontEnum|Function 2
73   ceil          mathProtoFuncCeil              DontEnum|Function 1
74   cos           mathProtoFuncCos               DontEnum|Function 1
75   exp           mathProtoFuncExp               DontEnum|Function 1
76   floor         mathProtoFuncFloor             DontEnum|Function 1
77   log           mathProtoFuncLog               DontEnum|Function 1
78   max           mathProtoFuncMax               DontEnum|Function 2
79   min           mathProtoFuncMin               DontEnum|Function 2
80   pow           mathProtoFuncPow               DontEnum|Function 2
81   random        mathProtoFuncRandom            DontEnum|Function 0 
82   round         mathProtoFuncRound             DontEnum|Function 1
83   sin           mathProtoFuncSin               DontEnum|Function 1
84   sqrt          mathProtoFuncSqrt              DontEnum|Function 1
85   tan           mathProtoFuncTan               DontEnum|Function 1
86 @end
87 */
88
89 MathObject::MathObject(JSGlobalObject* globalObject, Structure* structure)
90     : JSNonFinalObject(globalObject->globalData(), structure)
91 {
92 }
93
94 void MathObject::finishCreation(ExecState* exec, JSGlobalObject* globalObject)
95 {
96     Base::finishCreation(globalObject->globalData());
97     ASSERT(inherits(&s_info));
98
99     putDirectWithoutTransition(exec->globalData(), Identifier(exec, "E"), jsNumber(exp(1.0)), DontDelete | DontEnum | ReadOnly);
100     putDirectWithoutTransition(exec->globalData(), Identifier(exec, "LN2"), jsNumber(log(2.0)), DontDelete | DontEnum | ReadOnly);
101     putDirectWithoutTransition(exec->globalData(), Identifier(exec, "LN10"), jsNumber(log(10.0)), DontDelete | DontEnum | ReadOnly);
102     putDirectWithoutTransition(exec->globalData(), Identifier(exec, "LOG2E"), jsNumber(1.0 / log(2.0)), DontDelete | DontEnum | ReadOnly);
103     putDirectWithoutTransition(exec->globalData(), Identifier(exec, "LOG10E"), jsNumber(0.4342944819032518), DontDelete | DontEnum | ReadOnly); // See ECMA-262 15.8.1.5
104     putDirectWithoutTransition(exec->globalData(), Identifier(exec, "PI"), jsNumber(piDouble), DontDelete | DontEnum | ReadOnly);
105     putDirectWithoutTransition(exec->globalData(), Identifier(exec, "SQRT1_2"), jsNumber(sqrt(0.5)), DontDelete | DontEnum | ReadOnly);
106     putDirectWithoutTransition(exec->globalData(), Identifier(exec, "SQRT2"), jsNumber(sqrt(2.0)), DontDelete | DontEnum | ReadOnly);
107 }
108
109 bool MathObject::getOwnPropertySlot(JSCell* cell, ExecState* exec, PropertyName propertyName, PropertySlot &slot)
110 {
111     return getStaticFunctionSlot<JSObject>(exec, ExecState::mathTable(exec), jsCast<MathObject*>(cell), propertyName, slot);
112 }
113
114 bool MathObject::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
115 {
116     return getStaticFunctionDescriptor<JSObject>(exec, ExecState::mathTable(exec), jsCast<MathObject*>(object), propertyName, descriptor);
117 }
118
119 // ------------------------------ Functions --------------------------------
120
121 EncodedJSValue JSC_HOST_CALL mathProtoFuncAbs(ExecState* exec)
122 {
123     return JSValue::encode(jsNumber(fabs(exec->argument(0).toNumber(exec))));
124 }
125
126 EncodedJSValue JSC_HOST_CALL mathProtoFuncACos(ExecState* exec)
127 {
128     return JSValue::encode(jsDoubleNumber(acos(exec->argument(0).toNumber(exec))));
129 }
130
131 EncodedJSValue JSC_HOST_CALL mathProtoFuncASin(ExecState* exec)
132 {
133     return JSValue::encode(jsDoubleNumber(asin(exec->argument(0).toNumber(exec))));
134 }
135
136 EncodedJSValue JSC_HOST_CALL mathProtoFuncATan(ExecState* exec)
137 {
138     return JSValue::encode(jsDoubleNumber(atan(exec->argument(0).toNumber(exec))));
139 }
140
141 EncodedJSValue JSC_HOST_CALL mathProtoFuncATan2(ExecState* exec)
142 {
143     double arg0 = exec->argument(0).toNumber(exec);
144     double arg1 = exec->argument(1).toNumber(exec);
145     return JSValue::encode(jsDoubleNumber(atan2(arg0, arg1)));
146 }
147
148 EncodedJSValue JSC_HOST_CALL mathProtoFuncCeil(ExecState* exec)
149 {
150     return JSValue::encode(jsNumber(ceil(exec->argument(0).toNumber(exec))));
151 }
152
153 EncodedJSValue JSC_HOST_CALL mathProtoFuncCos(ExecState* exec)
154 {
155     return JSValue::encode(jsDoubleNumber(cos(exec->argument(0).toNumber(exec))));
156 }
157
158 EncodedJSValue JSC_HOST_CALL mathProtoFuncExp(ExecState* exec)
159 {
160     return JSValue::encode(jsDoubleNumber(exp(exec->argument(0).toNumber(exec))));
161 }
162
163 EncodedJSValue JSC_HOST_CALL mathProtoFuncFloor(ExecState* exec)
164 {
165     return JSValue::encode(jsNumber(floor(exec->argument(0).toNumber(exec))));
166 }
167
168 EncodedJSValue JSC_HOST_CALL mathProtoFuncLog(ExecState* exec)
169 {
170     return JSValue::encode(jsDoubleNumber(log(exec->argument(0).toNumber(exec))));
171 }
172
173 EncodedJSValue JSC_HOST_CALL mathProtoFuncMax(ExecState* exec)
174 {
175     unsigned argsCount = exec->argumentCount();
176     double result = -std::numeric_limits<double>::infinity();
177     for (unsigned k = 0; k < argsCount; ++k) {
178         double val = exec->argument(k).toNumber(exec);
179         if (isnan(val)) {
180             result = std::numeric_limits<double>::quiet_NaN();
181             break;
182         }
183         if (val > result || (val == 0 && result == 0 && !signbit(val)))
184             result = val;
185     }
186     return JSValue::encode(jsNumber(result));
187 }
188
189 EncodedJSValue JSC_HOST_CALL mathProtoFuncMin(ExecState* exec)
190 {
191     unsigned argsCount = exec->argumentCount();
192     double result = +std::numeric_limits<double>::infinity();
193     for (unsigned k = 0; k < argsCount; ++k) {
194         double val = exec->argument(k).toNumber(exec);
195         if (isnan(val)) {
196             result = std::numeric_limits<double>::quiet_NaN();
197             break;
198         }
199         if (val < result || (val == 0 && result == 0 && signbit(val)))
200             result = val;
201     }
202     return JSValue::encode(jsNumber(result));
203 }
204
205 EncodedJSValue JSC_HOST_CALL mathProtoFuncPow(ExecState* exec)
206 {
207     // ECMA 15.8.2.1.13
208
209     double arg = exec->argument(0).toNumber(exec);
210     double arg2 = exec->argument(1).toNumber(exec);
211
212     if (isnan(arg2))
213         return JSValue::encode(jsNaN());
214     if (isinf(arg2) && fabs(arg) == 1)
215         return JSValue::encode(jsNaN());
216     return JSValue::encode(jsNumber(pow(arg, arg2)));
217 }
218
219 EncodedJSValue JSC_HOST_CALL mathProtoFuncRandom(ExecState* exec)
220 {
221     return JSValue::encode(jsDoubleNumber(exec->lexicalGlobalObject()->weakRandomNumber()));
222 }
223
224 EncodedJSValue JSC_HOST_CALL mathProtoFuncRound(ExecState* exec)
225 {
226     double arg = exec->argument(0).toNumber(exec);
227     double integer = ceil(arg);
228     return JSValue::encode(jsNumber(integer - (integer - arg > 0.5)));
229 }
230
231 EncodedJSValue JSC_HOST_CALL mathProtoFuncSin(ExecState* exec)
232 {
233     return JSValue::encode(exec->globalData().cachedSin(exec->argument(0).toNumber(exec)));
234 }
235
236 EncodedJSValue JSC_HOST_CALL mathProtoFuncSqrt(ExecState* exec)
237 {
238     return JSValue::encode(jsDoubleNumber(sqrt(exec->argument(0).toNumber(exec))));
239 }
240
241 EncodedJSValue JSC_HOST_CALL mathProtoFuncTan(ExecState* exec)
242 {
243     return JSValue::encode(jsDoubleNumber(tan(exec->argument(0).toNumber(exec))));
244 }
245
246 } // namespace JSC