js/src/jsbool.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  * vim: set ts=8 sts=4 et sw=4 tw=99:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /*
   8  * JS boolean implementation.
   9  */
  10
  11 #include "jsboolinlines.h"
  12
  13 #include "jsapi.h"
  14 #include "jsatom.h"
  15 #include "jscntxt.h"
  16 #include "jsobj.h"
  17 #include "jstypes.h"
  18
  19 #include "vm/GlobalObject.h"
  20 #include "vm/ProxyObject.h"
  21 #include "vm/StringBuffer.h"
  22
  23 #include "vm/BooleanObject-inl.h"
  24
  25 using namespace js;
  26 using namespace js::types;
  27
  28 const Class BooleanObject::class_ = {
  29     "Boolean",
  30     JSCLASS_HAS_RESERVED_SLOTS(1) | JSCLASS_HAS_CACHED_PROTO(JSProto_Boolean)
  31 };
  32
  33 MOZ_ALWAYS_INLINE bool
  34 IsBoolean(HandleValue v)
  35 {
  36     return v.isBoolean() || (v.isObject() && v.toObject().is<BooleanObject>());
  37 }
  38
  39 #if JS_HAS_TOSOURCE
  40 MOZ_ALWAYS_INLINE bool
  41 bool_toSource_impl(JSContext* cx, CallArgs args)
  42 {
  43     HandleValue thisv = args.thisv();
  44     MOZ_ASSERT(IsBoolean(thisv));
  45
  46     bool b = thisv.isBoolean() ? thisv.toBoolean() : thisv.toObject().as<BooleanObject>().unbox();
  47
  48     StringBuffer sb(cx);
  49     if (!sb.append("(new Boolean(") || !BooleanToStringBuffer(b, sb) || !sb.append("))"))
  50         return false;
  51
  52     JSString* str = sb.finishString();
  53     if (!str)
  54         return false;
  55     args.rval().setString(str);
  56     return true;
  57 }
  58
  59 static bool
  60 bool_toSource(JSContext* cx, unsigned argc, Value* vp)
  61 {
  62     CallArgs args = CallArgsFromVp(argc, vp);
  63     return CallNonGenericMethod<IsBoolean, bool_toSource_impl>(cx, args);
  64 }
  65 #endif
  66
  67 MOZ_ALWAYS_INLINE bool
  68 bool_toString_impl(JSContext* cx, CallArgs args)
  69 {
  70     HandleValue thisv = args.thisv();
  71     MOZ_ASSERT(IsBoolean(thisv));
  72
  73     bool b = thisv.isBoolean() ? thisv.toBoolean() : thisv.toObject().as<BooleanObject>().unbox();
  74     args.rval().setString(js_BooleanToString(cx, b));
  75     return true;
  76 }
  77
  78 static bool
  79 bool_toString(JSContext* cx, unsigned argc, Value* vp)
  80 {
  81     CallArgs args = CallArgsFromVp(argc, vp);
  82     return CallNonGenericMethod<IsBoolean, bool_toString_impl>(cx, args);
  83 }
  84
  85 MOZ_ALWAYS_INLINE bool
  86 bool_valueOf_impl(JSContext* cx, CallArgs args)
  87 {
  88     HandleValue thisv = args.thisv();
  89     MOZ_ASSERT(IsBoolean(thisv));
  90
  91     bool b = thisv.isBoolean() ? thisv.toBoolean() : thisv.toObject().as<BooleanObject>().unbox();
  92     args.rval().setBoolean(b);
  93     return true;
  94 }
  95
  96 static bool
  97 bool_valueOf(JSContext* cx, unsigned argc, Value* vp)
  98 {
  99     CallArgs args = CallArgsFromVp(argc, vp);
 100     return CallNonGenericMethod<IsBoolean, bool_valueOf_impl>(cx, args);
 101 }
 102
 103 static const JSFunctionSpec boolean_methods[] = {
 104 #if JS_HAS_TOSOURCE
 105     JS_FN(js_toSource_str,  bool_toSource,  0, 0),
 106 #endif
 107     JS_FN(js_toString_str,  bool_toString,  0, 0),
 108     JS_FN(js_valueOf_str,   bool_valueOf,   0, 0),
 109     JS_FS_END
 110 };
 111
 112 static bool
 113 Boolean(JSContext* cx, unsigned argc, Value* vp)
 114 {
 115     CallArgs args = CallArgsFromVp(argc, vp);
 116
 117     bool b = args.length() != 0 ? JS::ToBoolean(args[0]) : false;
 118
 119     if (args.isConstructing()) {
 120         JSObject* obj = BooleanObject::create(cx, b);
 121         if (!obj)
 122             return false;
 123         args.rval().setObject(*obj);
 124     } else {
 125         args.rval().setBoolean(b);
 126     }
 127     return true;
 128 }
 129
 130 JSObject*
 131 js_InitBooleanClass(JSContext* cx, HandleObject obj)
 132 {
 133     MOZ_ASSERT(obj->isNative());
 134
 135     Rooted<GlobalObject*> global(cx, &obj->as<GlobalObject>());
 136
 137     Rooted<BooleanObject*> booleanProto(cx, global->createBlankPrototype<BooleanObject>(cx));
 138     if (!booleanProto)
 139         return nullptr;
 140     booleanProto->setFixedSlot(BooleanObject::PRIMITIVE_VALUE_SLOT, BooleanValue(false));
 141
 142     RootedFunction ctor(cx, global->createConstructor(cx, Boolean, cx->names().Boolean, 1));
 143     if (!ctor)
 144         return nullptr;
 145
 146     if (!LinkConstructorAndPrototype(cx, ctor, booleanProto))
 147         return nullptr;
 148
 149     if (!DefinePropertiesAndFunctions(cx, booleanProto, nullptr, boolean_methods))
 150         return nullptr;
 151
 152     if (!GlobalObject::initBuiltinConstructor(cx, global, JSProto_Boolean, ctor, booleanProto))
 153         return nullptr;
 154
 155     return booleanProto;
 156 }
 157
 158 JSString*
 159 js_BooleanToString(ExclusiveContext* cx, bool b)
 160 {
 161     return b ? cx->names().true_ : cx->names().false_;
 162 }
 163
 164 JS_PUBLIC_API(bool)
 165 js::ToBooleanSlow(HandleValue v)
 166 {
 167     if (v.isString())
 168         return v.toString()->length() != 0;
 169
 170     MOZ_ASSERT(v.isObject());
 171     return !EmulatesUndefined(&v.toObject());
 172 }