ryzom/tools/leveldesign/variable_parser/lua_helper_inline.h

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program 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 Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #ifndef RZ_INCLUDE_LUA_HELPER_INLINE
  18         #error "don't include directly, include lua_helper.h instead"
  19 #endif
  20
  21
  22 /////////////////////
  23 // CLuaStackChecker //
  24 //////////////////////
  25
  26 //================================================================================
  27 inline CLuaStackChecker::CLuaStackChecker(CLuaState *state, int numWantedResults)
  28 {
  29         nlassert(state);
  30         _State = state;
  31         _FinalWantedSize = state->getTop() + numWantedResults;
  32 }
  33
  34
  35 ///////////////
  36 // CLuaState //
  37 ///////////////
  38
  39 //================================================================================
  40 inline void CLuaState::checkIndex(int index)
  41 {
  42         // NB : more restrictive test that in the documentation there, because
  43         // we don't expose the check stack function
  44         nlassert( (index!=0 && abs(index) <= getTop())
  45                 || index == LUA_REGISTRYINDEX
  46                 || index == LUA_GLOBALSINDEX
  47                 );
  48 }
  49
  50 //================================================================================
  51 inline int  CLuaState::getTop()
  52 {
  53         return lua_gettop(_State);
  54 }
  55
  56 //================================================================================
  57 inline void CLuaState::setTop(int index)
  58 {
  59         // if index is strictly negative, this is a "pop". ensure that the user don't pop more than allowed
  60         if (index < 0)
  61         {
  62                 checkIndex(index);
  63         }
  64         // if index is positive and is more than the current top
  65         else if ( index>getTop() )
  66         {
  67                 // must ensure that we have enough stack space
  68                 nlverify( lua_checkstack(_State, index-getTop()) );
  69         }
  70
  71         // set top
  72         lua_settop(_State, index);
  73 }
  74
  75 //================================================================================
  76 inline void CLuaState::pushValue(int index)
  77 {
  78         checkIndex(index);
  79         lua_pushvalue(_State, index);
  80 }
  81
  82 //================================================================================
  83 inline void CLuaState::remove(int index)
  84 {
  85         checkIndex(index);
  86         lua_remove(_State, index);
  87 }
  88
  89 //================================================================================
  90 inline void CLuaState::insert(int index)
  91 {
  92         checkIndex(index);
  93         lua_insert(_State, index);
  94 }
  95
  96 //================================================================================
  97 inline void CLuaState::replace(int index)
  98 {
  99         checkIndex(index);
 100         lua_replace(_State, index);
 101 }
 102
 103 //================================================================================
 104 inline void CLuaState::pop(int numElem /* = 1 */)
 105 {
 106         nlassert(numElem <= getTop());
 107         lua_pop(_State, numElem);
 108 }
 109
 110 //================================================================================
 111 inline int CLuaState::type(int index /* = -1 */)
 112 {
 113         checkIndex(index);
 114         return lua_type(_State, index);
 115 }
 116
 117 //================================================================================
 118 inline const char *CLuaState::getTypename(int type)
 119 {
 120         return lua_typename(_State, type);
 121 }
 122
 123 //================================================================================
 124 inline bool CLuaState::isNil(int index)
 125 {
 126         checkIndex(index);
 127         return lua_isnil(_State, index) != 0;
 128 }
 129
 130 //================================================================================
 131 inline bool CLuaState::isBoolean(int index)
 132 {
 133         checkIndex(index);
 134         return lua_isboolean(_State, index) != 0;
 135 }
 136
 137 //================================================================================
 138 inline bool CLuaState::isNumber(int index)
 139 {
 140         checkIndex(index);
 141         return lua_isnumber(_State, index) != 0;
 142 }
 143
 144 //================================================================================
 145 inline bool CLuaState::isString(int index)
 146 {
 147         checkIndex(index);
 148         return lua_isstring(_State, index) != 0;
 149 }
 150
 151 //================================================================================
 152 inline bool CLuaState::isTable(int index)
 153 {
 154         checkIndex(index);
 155         return lua_istable(_State, index) != 0;
 156 }
 157
 158 //================================================================================
 159 inline bool CLuaState::isFunction(int index)
 160 {
 161         checkIndex(index);
 162         return lua_isfunction(_State, index) != 0;
 163 }
 164
 165 //================================================================================
 166 inline bool CLuaState::isCFunction(int index)
 167 {
 168         checkIndex(index);
 169         return lua_iscfunction(_State, index) != 0;
 170 }
 171
 172 //================================================================================
 173 inline bool CLuaState::isUserData(int index)
 174 {
 175         checkIndex(index);
 176         return lua_isuserdata(_State, index) != 0;
 177 }
 178
 179 //================================================================================
 180 inline bool CLuaState::isLightUserData(int index)
 181 {
 182         checkIndex(index);
 183         return lua_islightuserdata(_State, index) != 0;
 184 }
 185
 186 //================================================================================
 187 inline bool CLuaState::toBoolean(int index)
 188 {
 189         checkIndex(index);
 190         return lua_toboolean(_State, index) != 0;
 191 }
 192
 193 //================================================================================
 194 inline lua_Number CLuaState::toNumber(int index)
 195 {
 196         checkIndex(index);
 197         return lua_tonumber(_State, index);
 198 }
 199
 200 //================================================================================
 201 inline const char *CLuaState::toString(int index)
 202 {
 203         checkIndex(index);
 204         return lua_tostring(_State, index);
 205 }
 206
 207 //================================================================================
 208 inline void                     CLuaState::toString(int index, std::string &str)
 209 {
 210         checkIndex(index);
 211         const char *pc= lua_tostring(_State, index);
 212         if(pc)
 213                 str= pc;
 214         else
 215                 str.clear();
 216 }
 217
 218 //================================================================================
 219 inline size_t CLuaState::strlen(int index)
 220 {
 221         checkIndex(index);
 222         return lua_strlen(_State, index);
 223 }
 224
 225 //================================================================================
 226 inline lua_CFunction CLuaState::toCFunction(int index)
 227 {
 228         checkIndex(index);
 229         return lua_tocfunction(_State, index);
 230 }
 231
 232 //================================================================================
 233 inline void *CLuaState::toUserData(int index)
 234 {
 235         checkIndex(index);
 236         return lua_touserdata(_State, index);
 237 }
 238
 239 //================================================================================
 240 inline const void *CLuaState::toPointer(int index)
 241 {
 242         checkIndex(index);
 243         return lua_topointer(_State, index);
 244 }
 245
 246
 247 //================================================================================
 248 inline void CLuaState::push(bool value)
 249 {
 250         nlverify( lua_checkstack(_State, 1) );
 251         lua_pushboolean(_State, (int) value);
 252 }
 253
 254 //================================================================================
 255 inline void CLuaState::push(lua_Number value)
 256 {
 257         nlverify( lua_checkstack(_State, 1) );
 258         lua_pushnumber(_State, value);
 259 }
 260
 261 //================================================================================
 262 inline void CLuaState::push(const char *str)
 263 {
 264         nlverify( lua_checkstack(_State, 1) );
 265         lua_pushstring(_State, str);
 266 }
 267
 268
 269 //================================================================================
 270 inline void CLuaState::push(const char *str, int length)
 271 {
 272         nlverify( lua_checkstack(_State, 1) );
 273         lua_pushlstring(_State, str, length);
 274 }
 275
 276 //================================================================================
 277 inline void         CLuaState::push(const std::string &str)
 278 {
 279         nlverify( lua_checkstack(_State, 1) );
 280         push(str.c_str());
 281 }
 282
 283 //================================================================================
 284 inline void         CLuaState::pushNil()
 285 {
 286         nlverify( lua_checkstack(_State, 1) );
 287         lua_pushnil(_State);
 288 }
 289
 290 //================================================================================
 291 inline void         CLuaState::push(lua_CFunction f)
 292 {
 293         nlverify( lua_checkstack(_State, 1) );
 294         lua_pushcfunction(_State, f);
 295 }
 296
 297 //================================================================================
 298 inline void         CLuaState::pushLightUserData(void *ptr)
 299 {
 300         nlverify( lua_checkstack(_State, 1) );
 301         lua_pushlightuserdata(_State, ptr);
 302 }
 303
 304 //================================================================================
 305 inline bool         CLuaState::equal(int index1, int index2)
 306 {
 307         checkIndex(index1);
 308         checkIndex(index2);
 309         return lua_equal(_State, index1, index2) != 0;
 310 }
 311
 312 //================================================================================
 313 inline bool         CLuaState::getMetaTable(int index)
 314 {
 315         checkIndex(index);
 316         return lua_getmetatable(_State, index) != 0;
 317 }
 318
 319 //================================================================================
 320 inline bool         CLuaState::setMetaTable(int index)
 321 {
 322         checkIndex(index);
 323         return lua_setmetatable(_State, index) != 0;
 324 }
 325
 326 //================================================================================
 327 inline bool         CLuaState::rawEqual(int index1, int index2)
 328 {
 329         checkIndex(index1);
 330         checkIndex(index2);
 331         return lua_rawequal(_State, index1, index2) != 0;
 332 }
 333
 334 //================================================================================
 335 inline bool         CLuaState::lessThan(int index1, int index2)
 336 {
 337         checkIndex(index1);
 338         checkIndex(index2);
 339         return lua_lessthan(_State, index1, index2) != 0;
 340 }
 341
 342
 343 //================================================================================
 344 inline void         CLuaState::concat(int numElem)
 345 {
 346         nlassert(numElem <= getTop());
 347         lua_concat(_State, numElem);
 348 }
 349
 350 //================================================================================
 351 inline void         CLuaState::getTable(int index)
 352 {
 353         checkIndex(index);
 354         nlassert(isTable(index) || isUserData(index));
 355         lua_gettable(_State, index);
 356 }
 357
 358 //================================================================================
 359 inline void                CLuaState::rawGet(int index)
 360 {
 361         checkIndex(index);
 362         lua_rawget(_State, index);
 363 }
 364
 365 //================================================================================
 366 inline void                CLuaState::setTable(int index)
 367 {
 368         checkIndex(index);
 369         nlassert(getTop() >= 2);
 370         nlassert(isTable(index));
 371         lua_settable(_State, index);
 372 }
 373
 374 //================================================================================
 375 inline void                CLuaState::rawSet(int index)
 376 {
 377         checkIndex(index);
 378         lua_rawset(_State, index);
 379 }
 380
 381 //================================================================================
 382 inline bool                CLuaState::next(int index)
 383 {
 384         //H_AUTO(Lua_CLuaState_next)
 385         checkIndex(index);
 386         return lua_next(_State, index) != 0;
 387 }
 388
 389 //================================================================================
 390 inline void                CLuaState::rawSetI(int index, int n)
 391 {
 392         //H_AUTO(Lua_CLuaState_rawSetI)
 393         checkIndex(index);
 394         lua_rawseti(_State, index, n);
 395 }
 396
 397 //================================================================================
 398 inline void                CLuaState::rawGetI(int index, int n)
 399 {
 400         checkIndex(index);
 401         lua_rawgeti(_State, index, n);
 402 }
 403
 404 //================================================================================
 405 inline void                CLuaState::call(int nargs, int nresults)
 406 {
 407         nlassert(getTop() >= nargs);
 408         lua_call(_State, nargs, nresults);
 409 }
 410
 411 //================================================================================
 412 inline int                 CLuaState::pcall(int nargs, int nresults, int errfunc)
 413 {
 414         return lua_pcall(_State, nargs, nresults, errfunc);
 415 }
 416
 417 //================================================================================
 418 inline void                                     *CLuaState::newUserData(uint size)
 419 {
 420         nlassert(size>0);
 421         return lua_newuserdata(_State, size);
 422 }