Libs/VarVisitorsLua.cpp

   1 /*
   2 Cafu Engine, http://www.cafu.de/
   3 Copyright (c) Carsten Fuchs and other contributors.
   4 This project is licensed under the terms of the MIT license.
   5 */
   6
   7 #include "VarVisitorsLua.hpp"
   8
   9 extern "C"
  10 {
  11     #include <lua.h>
  12     #include <lauxlib.h>
  13 }
  14
  15 #include <cctype>
  16
  17
  18 using namespace cf::TypeSys;
  19
  20
  21 /***************************/
  22 /*** VarVisitorGetToLuaT ***/
  23 /***************************/
  24
  25 VarVisitorGetToLuaT::VarVisitorGetToLuaT(lua_State* LuaState)
  26     : m_LuaState(LuaState),
  27       m_NumResults(0)
  28 {
  29 }
  30
  31
  32 void VarVisitorGetToLuaT::visit(const cf::TypeSys::VarT<float>& Var)
  33 {
  34     lua_pushnumber(m_LuaState, Var.Get());
  35     m_NumResults++;
  36 }
  37
  38
  39 void VarVisitorGetToLuaT::visit(const cf::TypeSys::VarT<double>& Var)
  40 {
  41     lua_pushnumber(m_LuaState, Var.Get());
  42     m_NumResults++;
  43 }
  44
  45
  46 void VarVisitorGetToLuaT::visit(const cf::TypeSys::VarT<int>& Var)
  47 {
  48     lua_pushinteger(m_LuaState, Var.Get());
  49     m_NumResults++;
  50 }
  51
  52
  53 void VarVisitorGetToLuaT::visit(const cf::TypeSys::VarT<unsigned int>& Var)
  54 {
  55     lua_pushinteger(m_LuaState, Var.Get());
  56     m_NumResults++;
  57 }
  58
  59
  60 void VarVisitorGetToLuaT::visit(const cf::TypeSys::VarT<uint16_t>& Var)
  61 {
  62     lua_pushinteger(m_LuaState, Var.Get());
  63     m_NumResults++;
  64 }
  65
  66
  67 void VarVisitorGetToLuaT::visit(const cf::TypeSys::VarT<uint8_t>& Var)
  68 {
  69     lua_pushinteger(m_LuaState, Var.Get());
  70     m_NumResults++;
  71 }
  72
  73
  74 void VarVisitorGetToLuaT::visit(const cf::TypeSys::VarT<bool>& Var)
  75 {
  76     lua_pushboolean(m_LuaState, Var.Get());
  77     m_NumResults++;
  78 }
  79
  80
  81 void VarVisitorGetToLuaT::visit(const cf::TypeSys::VarT<std::string>& Var)
  82 {
  83     lua_pushstring(m_LuaState, Var.Get().c_str());
  84     m_NumResults++;
  85 }
  86
  87
  88 void VarVisitorGetToLuaT::visit(const cf::TypeSys::VarT<Vector2fT>& Var)
  89 {
  90     lua_pushnumber(m_LuaState, Var.Get().x); m_NumResults++;
  91     lua_pushnumber(m_LuaState, Var.Get().y); m_NumResults++;
  92 }
  93
  94
  95 void VarVisitorGetToLuaT::visit(const cf::TypeSys::VarT<Vector3fT>& Var)
  96 {
  97     lua_pushnumber(m_LuaState, Var.Get().x); m_NumResults++;
  98     lua_pushnumber(m_LuaState, Var.Get().y); m_NumResults++;
  99     lua_pushnumber(m_LuaState, Var.Get().z); m_NumResults++;
 100 }
 101
 102
 103 void VarVisitorGetToLuaT::visit(const cf::TypeSys::VarT<Vector3dT>& Var)
 104 {
 105     lua_pushnumber(m_LuaState, Var.Get().x); m_NumResults++;
 106     lua_pushnumber(m_LuaState, Var.Get().y); m_NumResults++;
 107     lua_pushnumber(m_LuaState, Var.Get().z); m_NumResults++;
 108 }
 109
 110
 111 void VarVisitorGetToLuaT::visit(const cf::TypeSys::VarT<BoundingBox3dT>& Var)
 112 {
 113     lua_pushnumber(m_LuaState, Var.Get().Min.x); m_NumResults++;
 114     lua_pushnumber(m_LuaState, Var.Get().Min.y); m_NumResults++;
 115     lua_pushnumber(m_LuaState, Var.Get().Min.z); m_NumResults++;
 116
 117     lua_pushnumber(m_LuaState, Var.Get().Max.x); m_NumResults++;
 118     lua_pushnumber(m_LuaState, Var.Get().Max.y); m_NumResults++;
 119     lua_pushnumber(m_LuaState, Var.Get().Max.z); m_NumResults++;
 120 }
 121
 122
 123 void VarVisitorGetToLuaT::visit(const cf::TypeSys::VarArrayT<uint32_t>& Var)
 124 {
 125     lua_newtable(m_LuaState);
 126     m_NumResults++;
 127
 128     for (unsigned int i = 0; i < Var.Size(); i++)
 129     {
 130         lua_pushinteger(m_LuaState, Var[i]);
 131         lua_rawseti(m_LuaState, -2, i + 1);   // Lua array numbering starts per convention at 1.
 132     }
 133 }
 134
 135
 136 void VarVisitorGetToLuaT::visit(const cf::TypeSys::VarArrayT<uint16_t>& Var)
 137 {
 138     lua_newtable(m_LuaState);
 139     m_NumResults++;
 140
 141     for (unsigned int i = 0; i < Var.Size(); i++)
 142     {
 143         lua_pushinteger(m_LuaState, Var[i]);
 144         lua_rawseti(m_LuaState, -2, i + 1);   // Lua array numbering starts per convention at 1.
 145     }
 146 }
 147
 148
 149 void VarVisitorGetToLuaT::visit(const cf::TypeSys::VarArrayT<uint8_t>& Var)
 150 {
 151     lua_newtable(m_LuaState);
 152     m_NumResults++;
 153
 154     for (unsigned int i = 0; i < Var.Size(); i++)
 155     {
 156         lua_pushinteger(m_LuaState, Var[i]);
 157         lua_rawseti(m_LuaState, -2, i + 1);   // Lua array numbering starts per convention at 1.
 158     }
 159 }
 160
 161
 162 void VarVisitorGetToLuaT::visit(const cf::TypeSys::VarArrayT<std::string>& Var)
 163 {
 164     lua_newtable(m_LuaState);
 165     m_NumResults++;
 166
 167     for (unsigned int i = 0; i < Var.Size(); i++)
 168     {
 169         lua_pushstring(m_LuaState, Var[i].c_str());
 170         lua_rawseti(m_LuaState, -2, i + 1);   // Lua array numbering starts per convention at 1.
 171     }
 172 }
 173
 174
 175 /*****************************/
 176 /*** VarVisitorSetFromLuaT ***/
 177 /*****************************/
 178
 179 VarVisitorSetFromLuaT::VarVisitorSetFromLuaT(lua_State* LuaState)
 180     : m_LuaState(LuaState)
 181 {
 182 }
 183
 184
 185 void VarVisitorSetFromLuaT::visit(cf::TypeSys::VarT<float>& Var)
 186 {
 187     Var.Set(float(luaL_checknumber(m_LuaState, -1)));
 188 }
 189
 190
 191 void VarVisitorSetFromLuaT::visit(cf::TypeSys::VarT<double>& Var)
 192 {
 193     Var.Set(luaL_checknumber(m_LuaState, -1));
 194 }
 195
 196
 197 void VarVisitorSetFromLuaT::visit(cf::TypeSys::VarT<int>& Var)
 198 {
 199     Var.Set(luaL_checkint(m_LuaState, -1));
 200 }
 201
 202
 203 void VarVisitorSetFromLuaT::visit(cf::TypeSys::VarT<unsigned int>& Var)
 204 {
 205     Var.Set(luaL_checkint(m_LuaState, -1));
 206 }
 207
 208
 209 void VarVisitorSetFromLuaT::visit(cf::TypeSys::VarT<uint16_t>& Var)
 210 {
 211     Var.Set(luaL_checkint(m_LuaState, -1));
 212 }
 213
 214
 215 void VarVisitorSetFromLuaT::visit(cf::TypeSys::VarT<uint8_t>& Var)
 216 {
 217     Var.Set(luaL_checkint(m_LuaState, -1));
 218 }
 219
 220
 221 void VarVisitorSetFromLuaT::visit(cf::TypeSys::VarT<bool>& Var)
 222 {
 223     // Also treat the number 0 as false, not just "false" and "nil".
 224     if (lua_isnumber(m_LuaState, -1))
 225         Var.Set(lua_tonumber(m_LuaState, -1) != 0.0);
 226     else
 227         Var.Set(lua_toboolean(m_LuaState, -1) != 0);
 228 }
 229
 230
 231 void VarVisitorSetFromLuaT::visit(cf::TypeSys::VarT<std::string>& Var)
 232 {
 233     Var.Set(luaL_checkstring(m_LuaState, -1));
 234 }
 235
 236
 237 void VarVisitorSetFromLuaT::visit(cf::TypeSys::VarT<Vector2fT>& Var)
 238 {
 239     Vector2fT v;
 240
 241     if (lua_istable(m_LuaState, -1))
 242     {
 243         lua_rawgeti(m_LuaState, -1, 1); v.x = float(lua_tonumber(m_LuaState, -1)); lua_pop(m_LuaState, 1);
 244         lua_rawgeti(m_LuaState, -1, 2); v.y = float(lua_tonumber(m_LuaState, -1)); lua_pop(m_LuaState, 1);
 245     }
 246     else
 247     {
 248         v.x = float(luaL_checknumber(m_LuaState, -2));
 249         v.y = float(luaL_checknumber(m_LuaState, -1));
 250     }
 251
 252     Var.Set(v);
 253 }
 254
 255
 256 void VarVisitorSetFromLuaT::visit(cf::TypeSys::VarT<Vector3fT>& Var)
 257 {
 258     Vector3fT v;
 259
 260     if (lua_istable(m_LuaState, -1))
 261     {
 262         lua_rawgeti(m_LuaState, -1, 1); v.x = float(lua_tonumber(m_LuaState, -1)); lua_pop(m_LuaState, 1);
 263         lua_rawgeti(m_LuaState, -1, 2); v.y = float(lua_tonumber(m_LuaState, -1)); lua_pop(m_LuaState, 1);
 264         lua_rawgeti(m_LuaState, -1, 3); v.z = float(lua_tonumber(m_LuaState, -1)); lua_pop(m_LuaState, 1);
 265     }
 266     else
 267     {
 268         v.x = float(luaL_checknumber(m_LuaState, -3));
 269         v.y = float(luaL_checknumber(m_LuaState, -2));
 270         v.z = float(luaL_checknumber(m_LuaState, -1));
 271     }
 272
 273     Var.Set(v);
 274 }
 275
 276
 277 void VarVisitorSetFromLuaT::visit(cf::TypeSys::VarT<Vector3dT>& Var)
 278 {
 279     Vector3dT v;
 280
 281     if (lua_istable(m_LuaState, -1))
 282     {
 283         lua_rawgeti(m_LuaState, -1, 1); v.x = lua_tonumber(m_LuaState, -1); lua_pop(m_LuaState, 1);
 284         lua_rawgeti(m_LuaState, -1, 2); v.y = lua_tonumber(m_LuaState, -1); lua_pop(m_LuaState, 1);
 285         lua_rawgeti(m_LuaState, -1, 3); v.z = lua_tonumber(m_LuaState, -1); lua_pop(m_LuaState, 1);
 286     }
 287     else
 288     {
 289         v.x = luaL_checknumber(m_LuaState, -3);
 290         v.y = luaL_checknumber(m_LuaState, -2);
 291         v.z = luaL_checknumber(m_LuaState, -1);
 292     }
 293
 294     Var.Set(v);
 295 }
 296
 297
 298 void VarVisitorSetFromLuaT::visit(cf::TypeSys::VarT<BoundingBox3dT>& Var)
 299 {
 300     BoundingBox3dT BB;
 301
 302     BB.Min.x = luaL_checknumber(m_LuaState, -6);
 303     BB.Min.y = luaL_checknumber(m_LuaState, -5);
 304     BB.Min.z = luaL_checknumber(m_LuaState, -4);
 305
 306     BB.Max.x = luaL_checknumber(m_LuaState, -3);
 307     BB.Max.y = luaL_checknumber(m_LuaState, -2);
 308     BB.Max.z = luaL_checknumber(m_LuaState, -1);
 309
 310     Var.Set(BB);
 311 }
 312
 313
 314 void VarVisitorSetFromLuaT::visit(cf::TypeSys::VarArrayT<uint32_t>& Var)
 315 {
 316     Var.Overwrite();
 317
 318     if (lua_istable(m_LuaState, -1))
 319     {
 320         const int Num = int(lua_rawlen(m_LuaState, -1));
 321
 322         for (int i = 1; i <= Num; i++)
 323         {
 324             lua_rawgeti(m_LuaState, -1, i);
 325             Var.PushBack(lua_tointeger(m_LuaState, -1));
 326             lua_pop(m_LuaState, 1);
 327         }
 328     }
 329     else
 330     {
 331         // Stack index 1 has the "this" object,
 332         // stack index 2 has the variable name.
 333         for (int i = 3; i <= lua_gettop(m_LuaState); i++)
 334             Var.PushBack(lua_tointeger(m_LuaState, i));
 335     }
 336 }
 337
 338
 339 void VarVisitorSetFromLuaT::visit(cf::TypeSys::VarArrayT<uint16_t>& Var)
 340 {
 341     Var.Overwrite();
 342
 343     if (lua_istable(m_LuaState, -1))
 344     {
 345         const int Num = int(lua_rawlen(m_LuaState, -1));
 346
 347         for (int i = 1; i <= Num; i++)
 348         {
 349             lua_rawgeti(m_LuaState, -1, i);
 350             Var.PushBack(lua_tointeger(m_LuaState, -1));
 351             lua_pop(m_LuaState, 1);
 352         }
 353     }
 354     else
 355     {
 356         // Stack index 1 has the "this" object,
 357         // stack index 2 has the variable name.
 358         for (int i = 3; i <= lua_gettop(m_LuaState); i++)
 359             Var.PushBack(lua_tointeger(m_LuaState, i));
 360     }
 361 }
 362
 363
 364 void VarVisitorSetFromLuaT::visit(cf::TypeSys::VarArrayT<uint8_t>& Var)
 365 {
 366     Var.Overwrite();
 367
 368     if (lua_istable(m_LuaState, -1))
 369     {
 370         const int Num = int(lua_rawlen(m_LuaState, -1));
 371
 372         for (int i = 1; i <= Num; i++)
 373         {
 374             lua_rawgeti(m_LuaState, -1, i);
 375             Var.PushBack(lua_tointeger(m_LuaState, -1));
 376             lua_pop(m_LuaState, 1);
 377         }
 378     }
 379     else
 380     {
 381         // Stack index 1 has the "this" object,
 382         // stack index 2 has the variable name.
 383         for (int i = 3; i <= lua_gettop(m_LuaState); i++)
 384             Var.PushBack(lua_tointeger(m_LuaState, i));
 385     }
 386 }
 387
 388
 389 void VarVisitorSetFromLuaT::visit(cf::TypeSys::VarArrayT<std::string>& Var)
 390 {
 391     Var.Overwrite();
 392
 393     if (lua_istable(m_LuaState, -1))
 394     {
 395         const int Num = int(lua_rawlen(m_LuaState, -1));
 396
 397         for (int i = 1; i <= Num; i++)
 398         {
 399             lua_rawgeti(m_LuaState, -1, i);
 400             const char* s = lua_tostring(m_LuaState, -1);
 401             Var.PushBack(s ? s : "NULL");
 402             lua_pop(m_LuaState, 1);
 403         }
 404     }
 405     else
 406     {
 407         // Stack index 1 has the "this" object,
 408         // stack index 2 has the variable name.
 409         for (int i = 3; i <= lua_gettop(m_LuaState); i++)
 410         {
 411             const char* s = lua_tostring(m_LuaState, i);
 412             Var.PushBack(s ? s : "NULL");
 413         }
 414     }
 415 }
 416
 417
 418 /***************************/
 419 /*** VarVisitorSetFloatT ***/
 420 /***************************/
 421
 422 VarVisitorSetFloatT::VarVisitorSetFloatT(unsigned int Suffix, float Value)
 423     : m_Suffix(Suffix),
 424       m_Value(Value)
 425 {
 426 }
 427
 428
 429 void VarVisitorSetFloatT::visit(cf::TypeSys::VarT<float>& Var)
 430 {
 431     Var.Set(m_Value);
 432 }
 433
 434
 435 void VarVisitorSetFloatT::visit(cf::TypeSys::VarT<Vector2fT>& Var)
 436 {
 437     Vector2fT v = Var.Get();
 438
 439     v[m_Suffix % 2] = m_Value;
 440
 441     Var.Set(v);
 442 }
 443
 444
 445 void VarVisitorSetFloatT::visit(cf::TypeSys::VarT<Vector3fT>& Var)
 446 {
 447     Vector3fT v = Var.Get();
 448
 449     v[m_Suffix % 3] = m_Value;
 450
 451     Var.Set(v);
 452 }
 453
 454
 455 void VarVisitorSetFloatT::visit(cf::TypeSys::VarT<double>& Var) { }
 456 void VarVisitorSetFloatT::visit(cf::TypeSys::VarT<int>& Var) { }
 457 void VarVisitorSetFloatT::visit(cf::TypeSys::VarT<unsigned int>& Var) { }
 458 void VarVisitorSetFloatT::visit(cf::TypeSys::VarT<uint16_t>& Var) { }
 459 void VarVisitorSetFloatT::visit(cf::TypeSys::VarT<uint8_t>& Var) { }
 460 void VarVisitorSetFloatT::visit(cf::TypeSys::VarT<bool>& Var) { }
 461 void VarVisitorSetFloatT::visit(cf::TypeSys::VarT<std::string>& Var) { }
 462 void VarVisitorSetFloatT::visit(cf::TypeSys::VarT<Vector3dT>& Var) { }
 463 void VarVisitorSetFloatT::visit(cf::TypeSys::VarT<BoundingBox3dT>& Var) { }
 464 void VarVisitorSetFloatT::visit(cf::TypeSys::VarArrayT<uint32_t>& Var) { }
 465 void VarVisitorSetFloatT::visit(cf::TypeSys::VarArrayT<uint16_t>& Var) { }
 466 void VarVisitorSetFloatT::visit(cf::TypeSys::VarArrayT<uint8_t>& Var) { }
 467 void VarVisitorSetFloatT::visit(cf::TypeSys::VarArrayT<std::string>& Var) { }
 468
 469
 470 /****************************/
 471 /*** VarVisitorToLuaCodeT ***/
 472 /****************************/
 473
 474 namespace
 475 {
 476     /// This function serializes a given float f1 to a string s, such that:
 477     ///   - s is minimal (uses the least number of decimal digits required),
 478     ///   - unserializing s back to a float f2 yields f1 == f2.
 479     /// See my post "float to string to float, with first float == second float"
 480     /// to comp.lang.c++ on 2009-10-06 for additional details.
 481     template<class T> std::string serialize(const T f1)
 482     {
 483         // Make sure that if f1 is -0, "0" instead of "-0" is returned.
 484         if (f1 == 0.0f) return "0";
 485
 486         // From MSDN documentation: "digits10 returns the number of decimal digits that the type can represent without loss of precision."
 487         // For floats, that's usually 6, for doubles, that's usually 15. However, we want to use the number of *significant* decimal digits here,
 488         // that is, max_digits10. See http://www.open-std.org/JTC1/sc22/wg21/docs/papers/2006/n2005.pdf for details.
 489         const unsigned int DIGITS10     = std::numeric_limits<T>::digits10;
 490         const unsigned int MAX_DIGITS10 = DIGITS10 + 3;
 491
 492         std::string  s;
 493         unsigned int prec;
 494
 495         for (prec = DIGITS10; prec <= MAX_DIGITS10; prec++)
 496         {
 497             std::stringstream ss;
 498
 499             ss.precision(prec);
 500             ss << f1;
 501
 502             s = ss.str();
 503
 504 #if defined(_MSC_VER) && (_MSC_VER <= 1900)     // 1900 == Visual C++ 14.0 (2015)
 505             // There is a bug in Microsoft's iostream implementation up to Visual C++ 2015,
 506             // see http://trac.cafu.de/ticket/150 for details.
 507             const T f2 = T(atof(s.c_str()));
 508 #else
 509             T f2;
 510             ss >> f2;
 511 #endif
 512
 513             if (f2 == f1) break;
 514         }
 515
 516         assert(prec <= MAX_DIGITS10);
 517         return s;
 518     }
 519 }
 520
 521
 522 VarVisitorToLuaCodeT::VarVisitorToLuaCodeT(std::ostream& Out)
 523     : m_Out(Out)
 524 {
 525 }
 526
 527
 528 void VarVisitorToLuaCodeT::visit(const cf::TypeSys::VarT<float>& Var)
 529 {
 530     m_Out << serialize(Var.Get());
 531 }
 532
 533
 534 void VarVisitorToLuaCodeT::visit(const cf::TypeSys::VarT<double>& Var)
 535 {
 536     m_Out << serialize(Var.Get());
 537 }
 538
 539
 540 void VarVisitorToLuaCodeT::visit(const cf::TypeSys::VarT<int>& Var)
 541 {
 542     m_Out << Var.Get();
 543 }
 544
 545
 546 void VarVisitorToLuaCodeT::visit(const cf::TypeSys::VarT<unsigned int>& Var)
 547 {
 548     m_Out << Var.Get();
 549 }
 550
 551
 552 void VarVisitorToLuaCodeT::visit(const cf::TypeSys::VarT<uint16_t>& Var)
 553 {
 554     m_Out << Var.Get();
 555 }
 556
 557
 558 void VarVisitorToLuaCodeT::visit(const cf::TypeSys::VarT<uint8_t>& Var)
 559 {
 560     m_Out << uint16_t(Var.Get());   // Write numbers, not characters.
 561 }
 562
 563
 564 void VarVisitorToLuaCodeT::visit(const cf::TypeSys::VarT<bool>& Var)
 565 {
 566     m_Out << (Var.Get() ? "true" : "false");
 567 }
 568
 569
 570 void VarVisitorToLuaCodeT::visit(const cf::TypeSys::VarT<std::string>& Var)
 571 {
 572     WriteString(Var.Get());
 573 }
 574
 575
 576 void VarVisitorToLuaCodeT::visit(const cf::TypeSys::VarT<Vector2fT>& Var)
 577 {
 578     m_Out << serialize(Var.Get().x) << ", " << serialize(Var.Get().y);
 579 }
 580
 581
 582 void VarVisitorToLuaCodeT::visit(const cf::TypeSys::VarT<Vector3fT>& Var)
 583 {
 584     m_Out << serialize(Var.Get().x) << ", " << serialize(Var.Get().y) << ", " << serialize(Var.Get().z);
 585 }
 586
 587
 588 void VarVisitorToLuaCodeT::visit(const cf::TypeSys::VarT<Vector3dT>& Var)
 589 {
 590     m_Out << serialize(Var.Get().x) << ", " << serialize(Var.Get().y) << ", " << serialize(Var.Get().z);
 591 }
 592
 593
 594 void VarVisitorToLuaCodeT::visit(const cf::TypeSys::VarT<BoundingBox3dT>& Var)
 595 {
 596     m_Out << serialize(Var.Get().Min.x) << ", " << serialize(Var.Get().Min.y) << ", " << serialize(Var.Get().Min.z) << ", ";
 597     m_Out << serialize(Var.Get().Max.x) << ", " << serialize(Var.Get().Max.y) << ", " << serialize(Var.Get().Max.z);
 598 }
 599
 600
 601 void VarVisitorToLuaCodeT::visit(const cf::TypeSys::VarArrayT<uint32_t>& Var)
 602 {
 603     m_Out << "{ ";
 604
 605     for (unsigned int i = 0; i < Var.Size(); i++)
 606     {
 607         m_Out << Var[i];
 608         if (i+1 < Var.Size()) m_Out << ", ";
 609     }
 610
 611     m_Out << " }";
 612 }
 613
 614
 615 void VarVisitorToLuaCodeT::visit(const cf::TypeSys::VarArrayT<uint16_t>& Var)
 616 {
 617     m_Out << "{ ";
 618
 619     for (unsigned int i = 0; i < Var.Size(); i++)
 620     {
 621         m_Out << Var[i];
 622         if (i+1 < Var.Size()) m_Out << ", ";
 623     }
 624
 625     m_Out << " }";
 626 }
 627
 628
 629 void VarVisitorToLuaCodeT::visit(const cf::TypeSys::VarArrayT<uint8_t>& Var)
 630 {
 631     m_Out << "{ ";
 632
 633     for (unsigned int i = 0; i < Var.Size(); i++)
 634     {
 635         m_Out << uint16_t(Var[i]);    // Write numbers, not characters.
 636         if (i+1 < Var.Size()) m_Out << ", ";
 637     }
 638
 639     m_Out << " }";
 640 }
 641
 642
 643 void VarVisitorToLuaCodeT::visit(const cf::TypeSys::VarArrayT<std::string>& Var)
 644 {
 645     m_Out << "{ ";
 646
 647     for (unsigned int i = 0; i < Var.Size(); i++)
 648     {
 649         WriteString(Var[i]);
 650         if (i+1 < Var.Size()) m_Out << ", ";
 651     }
 652
 653     m_Out << " }";
 654 }
 655
 656
 657 void VarVisitorToLuaCodeT::WriteString(const std::string& s) const
 658 {
 659     for (size_t i = 0; i < s.size(); i++)
 660         if (iscntrl(s[i]) || s[i] == '"' || s[i] == '\\')
 661         {
 662             std::string Equals = "";
 663
 664             while (s.find("[" + Equals + "[") != std::string::npos ||
 665                    s.find("]" + Equals + "]") != std::string::npos)
 666                 Equals += "=";
 667
 668             // Why do we write an extra newline following the opening long bracket?
 669             // The answer is given in the Lua reference manual:
 670             //
 671             // > For convenience, when the opening long bracket is immediately
 672             // > followed by a newline, the newline is not included in the string.
 673             //
 674             // That is, if s begins with a character that is *not* a newline, prepending the extra newline
 675             // doesn't make a difference. But if the first character in s happened to be a newline, it would
 676             // get lost if the extra newline was not written.
 677             m_Out << "[" << Equals << "[\n";
 678             m_Out << s;
 679             m_Out << "]" << Equals << "]";
 680             return;
 681         }
 682
 683     m_Out << "\"" << s << "\"";
 684 }