source/scriptinterface/ScriptConversions.cpp

   1 /* Copyright (C) 2023 Wildfire Games.
   2  * This file is part of 0 A.D.
   3  *
   4  * 0 A.D. is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * 0 A.D. is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "precompiled.h"
  19
  20 #include "ScriptConversions.h"
  21 #include "ScriptExceptions.h"
  22 #include "ScriptExtraHeaders.h"
  23
  24 #include "graphics/Entity.h"
  25 #include "lib/file/vfs/vfs_path.h"
  26 #include "maths/Vector2D.h"
  27 #include "ps/CLogger.h"
  28 #include "ps/CStr.h"
  29
  30 #include <string>
  31
  32 // Catch the raised exception right away to ensure the stack trace gets printed.
  33 #define FAIL(msg) STMT(ScriptException::Raise(rq, msg); ScriptException::CatchPending(rq); return false)
  34
  35 // Implicit type conversions often hide bugs, so fail.
  36 #define FAIL_IF_NOT(c, v) STMT(if (!(c)) { \
  37         ScriptException::Raise(rq, "Script value conversion check failed: %s (got type %s)", #c, JS::InformalValueTypeName(v)); \
  38         ScriptException::CatchPending(rq); \
  39         return false; \
  40 })
  41
  42 template<> bool Script::FromJSVal<bool>(const ScriptRequest& rq, JS::HandleValue v, bool& out)
  43 {
  44         FAIL_IF_NOT(v.isBoolean(), v);
  45         out = JS::ToBoolean(v);
  46         return true;
  47 }
  48
  49 template<> bool Script::FromJSVal<float>(const ScriptRequest& rq, JS::HandleValue v, float& out)
  50 {
  51         double tmp;
  52         FAIL_IF_NOT(v.isNumber(), v);
  53         if (!JS::ToNumber(rq.cx, v, &tmp))
  54                 return false;
  55         out = tmp;
  56         return true;
  57 }
  58
  59 template<> bool Script::FromJSVal<double>(const ScriptRequest& rq,  JS::HandleValue v, double& out)
  60 {
  61         FAIL_IF_NOT(v.isNumber(), v);
  62         if (!JS::ToNumber(rq.cx, v, &out))
  63                 return false;
  64         return true;
  65 }
  66
  67 template<> bool Script::FromJSVal<i32>(const ScriptRequest& rq,  JS::HandleValue v, i32& out)
  68 {
  69         FAIL_IF_NOT(v.isNumber(), v);
  70         if (!JS::ToInt32(rq.cx, v, &out))
  71                 return false;
  72         return true;
  73 }
  74
  75 template<> bool Script::FromJSVal<u32>(const ScriptRequest& rq,  JS::HandleValue v, u32& out)
  76 {
  77         FAIL_IF_NOT(v.isNumber(), v);
  78         if (!JS::ToUint32(rq.cx, v, &out))
  79                 return false;
  80         return true;
  81 }
  82
  83 template<> bool Script::FromJSVal<u16>(const ScriptRequest& rq,  JS::HandleValue v, u16& out)
  84 {
  85         FAIL_IF_NOT(v.isNumber(), v);
  86         if (!JS::ToUint16(rq.cx, v, &out))
  87                 return false;
  88         return true;
  89 }
  90
  91 template<> bool Script::FromJSVal<u8>(const ScriptRequest& rq,  JS::HandleValue v, u8& out)
  92 {
  93         u16 tmp;
  94         FAIL_IF_NOT(v.isNumber(), v);
  95         if (!JS::ToUint16(rq.cx, v, &tmp))
  96                 return false;
  97         out = (u8)tmp;
  98         return true;
  99 }
 100
 101 template<> bool Script::FromJSVal<std::wstring>(const ScriptRequest& rq,  JS::HandleValue v, std::wstring& out)
 102 {
 103         FAIL_IF_NOT(v.isString() || v.isNumber() || v.isBoolean(), v); // allow implicit boolean/number conversions
 104         JS::RootedString str(rq.cx, JS::ToString(rq.cx, v));
 105         if (!str)
 106                 FAIL("Argument must be convertible to a string");
 107
 108         if (JS::StringHasLatin1Chars(str))
 109         {
 110                 size_t length;
 111                 JS::AutoCheckCannotGC nogc;
 112                 const JS::Latin1Char* ch = JS_GetLatin1StringCharsAndLength(rq.cx, nogc, str, &length);
 113                 if (!ch)
 114                         FAIL("JS_GetLatin1StringCharsAndLength failed");
 115
 116                 out.assign(ch, ch + length);
 117         }
 118         else
 119         {
 120                 size_t length;
 121                 JS::AutoCheckCannotGC nogc;
 122                 const char16_t* ch = JS_GetTwoByteStringCharsAndLength(rq.cx, nogc, str, &length);
 123                 if (!ch)
 124                         FAIL("JS_GetTwoByteStringsCharsAndLength failed"); // out of memory
 125
 126                 out.assign(ch, ch + length);
 127         }
 128         return true;
 129 }
 130
 131 template<> bool Script::FromJSVal<Path>(const ScriptRequest& rq,  JS::HandleValue v, Path& out)
 132 {
 133         std::wstring string;
 134         if (!FromJSVal(rq, v, string))
 135                 return false;
 136         out = string;
 137         return true;
 138 }
 139
 140 template<> bool Script::FromJSVal<std::string>(const ScriptRequest& rq,  JS::HandleValue v, std::string& out)
 141 {
 142         std::wstring wideout;
 143         if (!FromJSVal(rq, v, wideout))
 144                 return false;
 145         out = CStrW(wideout).ToUTF8();
 146         return true;
 147 }
 148
 149 template<> bool Script::FromJSVal<CStr8>(const ScriptRequest& rq,  JS::HandleValue v, CStr8& out)
 150 {
 151         return Script::FromJSVal(rq, v, static_cast<std::string&>(out));
 152 }
 153
 154 template<> bool Script::FromJSVal<CStrW>(const ScriptRequest& rq,  JS::HandleValue v, CStrW& out)
 155 {
 156         return Script::FromJSVal(rq, v, static_cast<std::wstring&>(out));
 157 }
 158
 159 template<> bool Script::FromJSVal<Entity>(const ScriptRequest& rq,  JS::HandleValue v, Entity& out)
 160 {
 161         if (!v.isObject())
 162                 FAIL("Argument must be an object");
 163
 164         JS::RootedObject obj(rq.cx, &v.toObject());
 165         JS::RootedValue templateName(rq.cx);
 166         JS::RootedValue id(rq.cx);
 167         JS::RootedValue player(rq.cx);
 168         JS::RootedValue position(rq.cx);
 169         JS::RootedValue rotation(rq.cx);
 170
 171         // TODO: Report type errors
 172         if (!JS_GetProperty(rq.cx, obj, "player", &player) || !FromJSVal(rq, player, out.playerID))
 173                 FAIL("Failed to read Entity.player property");
 174         if (!JS_GetProperty(rq.cx, obj, "templateName", &templateName) || !FromJSVal(rq, templateName, out.templateName))
 175                 FAIL("Failed to read Entity.templateName property");
 176         if (!JS_GetProperty(rq.cx, obj, "id", &id) || !FromJSVal(rq, id, out.entityID))
 177                 FAIL("Failed to read Entity.id property");
 178         if (!JS_GetProperty(rq.cx, obj, "position", &position) || !FromJSVal(rq, position, out.position))
 179                 FAIL("Failed to read Entity.position property");
 180         if (!JS_GetProperty(rq.cx, obj, "rotation", &rotation) || !FromJSVal(rq, rotation, out.rotation))
 181                 FAIL("Failed to read Entity.rotation property");
 182
 183         return true;
 184 }
 185
 186 ////////////////////////////////////////////////////////////////
 187 // Primitive types:
 188
 189 template<> void Script::ToJSVal<bool>(const ScriptRequest& UNUSED(rq), JS::MutableHandleValue ret, const bool& val)
 190 {
 191         ret.setBoolean(val);
 192 }
 193
 194 template<> void Script::ToJSVal<float>(const ScriptRequest& UNUSED(rq), JS::MutableHandleValue ret, const float& val)
 195 {
 196         ret.set(JS::NumberValue(val));
 197 }
 198
 199 template<> void Script::ToJSVal<double>(const ScriptRequest& UNUSED(rq), JS::MutableHandleValue ret, const double& val)
 200 {
 201         ret.set(JS::NumberValue(val));
 202 }
 203
 204 template<> void Script::ToJSVal<i32>(const ScriptRequest& UNUSED(rq), JS::MutableHandleValue ret, const i32& val)
 205 {
 206         ret.set(JS::NumberValue(val));
 207 }
 208
 209 template<> void Script::ToJSVal<u16>(const ScriptRequest& UNUSED(rq), JS::MutableHandleValue ret, const u16& val)
 210 {
 211         ret.set(JS::NumberValue(val));
 212 }
 213
 214 template<> void Script::ToJSVal<u8>(const ScriptRequest& UNUSED(rq), JS::MutableHandleValue ret, const u8& val)
 215 {
 216         ret.set(JS::NumberValue(val));
 217 }
 218
 219 template<> void Script::ToJSVal<u32>(const ScriptRequest& UNUSED(rq), JS::MutableHandleValue ret, const u32& val)
 220 {
 221         ret.set(JS::NumberValue(val));
 222 }
 223
 224 template<> void Script::ToJSVal<std::wstring>(const ScriptRequest& rq,  JS::MutableHandleValue ret, const std::wstring& val)
 225 {
 226         std::u16string utf16(val.begin(), val.end());
 227         JS::RootedString str(rq.cx, JS_NewUCStringCopyN(rq.cx, utf16.c_str(), utf16.length()));
 228         if (str)
 229                 ret.setString(str);
 230         else
 231                 ret.setUndefined();
 232 }
 233
 234 template<> void Script::ToJSVal<Path>(const ScriptRequest& rq,  JS::MutableHandleValue ret, const Path& val)
 235 {
 236         ToJSVal(rq, ret, val.string());
 237 }
 238
 239 template<> void Script::ToJSVal<std::string>(const ScriptRequest& rq,  JS::MutableHandleValue ret, const std::string& val)
 240 {
 241         ToJSVal(rq, ret, static_cast<const std::wstring>(CStr(val).FromUTF8()));
 242 }
 243
 244 template<> void Script::ToJSVal<const wchar_t*>(const ScriptRequest& rq,  JS::MutableHandleValue ret, const wchar_t* const& val)
 245 {
 246         ToJSVal(rq, ret, std::wstring(val));
 247 }
 248
 249 template<> void Script::ToJSVal<const char*>(const ScriptRequest& rq,  JS::MutableHandleValue ret, const char* const& val)
 250 {
 251         JS::RootedString str(rq.cx, JS_NewStringCopyZ(rq.cx, val));
 252         if (str)
 253                 ret.setString(str);
 254         else
 255                 ret.setUndefined();
 256 }
 257
 258 #define TOJSVAL_CHAR(N) \
 259 template<> void Script::ToJSVal<wchar_t[N]>(const ScriptRequest& rq,  JS::MutableHandleValue ret, const wchar_t (&val)[N]) \
 260 { \
 261         ToJSVal(rq, ret, static_cast<const wchar_t*>(val)); \
 262 } \
 263 template<> void Script::ToJSVal<char[N]>(const ScriptRequest& rq,  JS::MutableHandleValue ret, const char (&val)[N]) \
 264 { \
 265         ToJSVal(rq, ret, static_cast<const char*>(val)); \
 266 }
 267
 268 TOJSVAL_CHAR(3)
 269 TOJSVAL_CHAR(5)
 270 TOJSVAL_CHAR(6)
 271 TOJSVAL_CHAR(7)
 272 TOJSVAL_CHAR(8)
 273 TOJSVAL_CHAR(9)
 274 TOJSVAL_CHAR(10)
 275 TOJSVAL_CHAR(11)
 276 TOJSVAL_CHAR(12)
 277 TOJSVAL_CHAR(13)
 278 TOJSVAL_CHAR(14)
 279 TOJSVAL_CHAR(15)
 280 TOJSVAL_CHAR(16)
 281 TOJSVAL_CHAR(17)
 282 TOJSVAL_CHAR(18)
 283 TOJSVAL_CHAR(19)
 284 TOJSVAL_CHAR(20)
 285 TOJSVAL_CHAR(24)
 286 TOJSVAL_CHAR(29)
 287 TOJSVAL_CHAR(33)
 288 TOJSVAL_CHAR(35)
 289 TOJSVAL_CHAR(256)
 290 #undef TOJSVAL_CHAR
 291
 292 template<> void Script::ToJSVal<CStrW>(const ScriptRequest& rq,  JS::MutableHandleValue ret, const CStrW& val)
 293 {
 294         ToJSVal(rq, ret, static_cast<const std::wstring&>(val));
 295 }
 296
 297 template<> void Script::ToJSVal<CStr8>(const ScriptRequest& rq,  JS::MutableHandleValue ret, const CStr8& val)
 298 {
 299         ToJSVal(rq, ret, static_cast<const std::string&>(val));
 300 }
 301
 302 ////////////////////////////////////////////////////////////////
 303 // Compound types
 304 // Instantiate various vector types:
 305
 306 JSVAL_VECTOR(int)
 307 JSVAL_VECTOR(u32)
 308 JSVAL_VECTOR(u16)
 309 JSVAL_VECTOR(std::string)
 310 JSVAL_VECTOR(std::wstring)
 311 JSVAL_VECTOR(std::vector<std::wstring>)
 312 JSVAL_VECTOR(CStr8)
 313 JSVAL_VECTOR(CStrW)
 314 JSVAL_VECTOR(std::vector<CStr8>)
 315 JSVAL_VECTOR(std::vector<std::string>)
 316
 317
 318 class IComponent;
 319 template<> void Script::ToJSVal<std::vector<IComponent*>>(const ScriptRequest& rq,  JS::MutableHandleValue ret, const std::vector<IComponent*>& val)
 320 {
 321         ToJSVal_vector(rq, ret, val);
 322 }
 323
 324 template<> bool Script::FromJSVal<std::vector<Entity>>(const ScriptRequest& rq,  JS::HandleValue v, std::vector<Entity>& out)
 325 {
 326         return FromJSVal_vector(rq, v, out);
 327 }
 328
 329 #undef FAIL
 330 #undef FAIL_IF_NOT