SkillerDebugInterface_tolua.cpp

00001 /*
00002 ** Lua binding: interfaces_SkillerDebugInterface
00003 ** Generated automatically by tolua++-1.0.92
00004 */
00005 /*  This program is free software; you can redistribute it and/or modify
00006  *  it under the terms of the GNU General Public License as published by
00007  *  the Free Software Foundation; either version 2 of the License, or
00008  *  (at your option) any later version. A runtime exception applies to
00009  *  this software (see LICENSE.GPL_WRE file mentioned below for details).
00010  *
00011  *  This program is distributed in the hope that it will be useful,
00012  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  *  GNU Library General Public License for more details.
00015  *
00016  *  Read the full text in the LICENSE.GPL_WRE file in the doc directory.
00017  */
00018 
00019 #ifndef __cplusplus
00020 #include "stdlib.h"
00021 #endif
00022 #include "string.h"
00023 
00024 #include "tolua++.h"
00025 
00026 /* Exported function */
00027 TOLUA_API int  tolua_interfaces_SkillerDebugInterface_open (lua_State* tolua_S);
00028 
00029 #include <interfaces/SkillerDebugInterface.h>
00030 using namespace fawkes;
00031 
00032 /* function to release collected object via destructor */
00033 #ifdef __cplusplus
00034 
00035 static int tolua_collect_fawkes__SkillerDebugInterface__SetGraphMessage (lua_State* tolua_S)
00036 {
00037  fawkes::SkillerDebugInterface::SetGraphMessage* self = (fawkes::SkillerDebugInterface::SetGraphMessage*) tolua_tousertype(tolua_S,1,0);
00038         Mtolua_delete(self);
00039         return 0;
00040 }
00041 
00042 static int tolua_collect_fawkes__SkillerDebugInterface__SetGraphColoredMessage (lua_State* tolua_S)
00043 {
00044  fawkes::SkillerDebugInterface::SetGraphColoredMessage* self = (fawkes::SkillerDebugInterface::SetGraphColoredMessage*) tolua_tousertype(tolua_S,1,0);
00045         Mtolua_delete(self);
00046         return 0;
00047 }
00048 
00049 static int tolua_collect_fawkes__SkillerDebugInterface__SetGraphDirectionMessage (lua_State* tolua_S)
00050 {
00051  fawkes::SkillerDebugInterface::SetGraphDirectionMessage* self = (fawkes::SkillerDebugInterface::SetGraphDirectionMessage*) tolua_tousertype(tolua_S,1,0);
00052         Mtolua_delete(self);
00053         return 0;
00054 }
00055 #endif
00056 
00057 
00058 /* function to register type */
00059 static void tolua_reg_types (lua_State* tolua_S)
00060 {
00061  tolua_usertype(tolua_S,"Message");
00062  tolua_usertype(tolua_S,"fawkes::SkillerDebugInterface::SetGraphDirectionMessage");
00063  tolua_usertype(tolua_S,"fawkes::SkillerDebugInterface");
00064  tolua_usertype(tolua_S,"fawkes::SkillerDebugInterface::SetGraphMessage");
00065  tolua_usertype(tolua_S,"fawkes::SkillerDebugInterface::SetGraphColoredMessage");
00066  tolua_usertype(tolua_S,"Interface");
00067 }
00068 
00069 /* method: new of class  SetGraphMessage */
00070 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_new00
00071 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_new00(lua_State* tolua_S)
00072 {
00073 #ifndef TOLUA_RELEASE
00074  tolua_Error tolua_err;
00075  if (
00076      !tolua_isusertable(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphMessage",0,&tolua_err) ||
00077      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00078      !tolua_isnoobj(tolua_S,3,&tolua_err)
00079  )
00080   goto tolua_lerror;
00081  else
00082 #endif
00083  {
00084   char* ini_graph_fsm = ((char*)  tolua_tostring(tolua_S,2,0));
00085   {
00086    fawkes::SkillerDebugInterface::SetGraphMessage* tolua_ret = (fawkes::SkillerDebugInterface::SetGraphMessage*)  Mtolua_new((fawkes::SkillerDebugInterface::SetGraphMessage)(ini_graph_fsm));
00087     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerDebugInterface::SetGraphMessage");
00088   }
00089  }
00090  return 1;
00091 #ifndef TOLUA_RELEASE
00092  tolua_lerror:
00093  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00094  return 0;
00095 #endif
00096 }
00097 #endif //#ifndef TOLUA_DISABLE
00098 
00099 /* method: new_local of class  SetGraphMessage */
00100 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_new00_local
00101 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_new00_local(lua_State* tolua_S)
00102 {
00103 #ifndef TOLUA_RELEASE
00104  tolua_Error tolua_err;
00105  if (
00106      !tolua_isusertable(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphMessage",0,&tolua_err) ||
00107      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00108      !tolua_isnoobj(tolua_S,3,&tolua_err)
00109  )
00110   goto tolua_lerror;
00111  else
00112 #endif
00113  {
00114   char* ini_graph_fsm = ((char*)  tolua_tostring(tolua_S,2,0));
00115   {
00116    fawkes::SkillerDebugInterface::SetGraphMessage* tolua_ret = (fawkes::SkillerDebugInterface::SetGraphMessage*)  Mtolua_new((fawkes::SkillerDebugInterface::SetGraphMessage)(ini_graph_fsm));
00117     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerDebugInterface::SetGraphMessage");
00118     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00119   }
00120  }
00121  return 1;
00122 #ifndef TOLUA_RELEASE
00123  tolua_lerror:
00124  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00125  return 0;
00126 #endif
00127 }
00128 #endif //#ifndef TOLUA_DISABLE
00129 
00130 /* method: new of class  SetGraphMessage */
00131 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_new01
00132 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_new01(lua_State* tolua_S)
00133 {
00134  tolua_Error tolua_err;
00135  if (
00136      !tolua_isusertable(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphMessage",0,&tolua_err) ||
00137      !tolua_isnoobj(tolua_S,2,&tolua_err)
00138  )
00139   goto tolua_lerror;
00140  else
00141  {
00142   {
00143    fawkes::SkillerDebugInterface::SetGraphMessage* tolua_ret = (fawkes::SkillerDebugInterface::SetGraphMessage*)  Mtolua_new((fawkes::SkillerDebugInterface::SetGraphMessage)());
00144     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerDebugInterface::SetGraphMessage");
00145   }
00146  }
00147  return 1;
00148 tolua_lerror:
00149  return tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_new00(tolua_S);
00150 }
00151 #endif //#ifndef TOLUA_DISABLE
00152 
00153 /* method: new_local of class  SetGraphMessage */
00154 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_new01_local
00155 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_new01_local(lua_State* tolua_S)
00156 {
00157  tolua_Error tolua_err;
00158  if (
00159      !tolua_isusertable(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphMessage",0,&tolua_err) ||
00160      !tolua_isnoobj(tolua_S,2,&tolua_err)
00161  )
00162   goto tolua_lerror;
00163  else
00164  {
00165   {
00166    fawkes::SkillerDebugInterface::SetGraphMessage* tolua_ret = (fawkes::SkillerDebugInterface::SetGraphMessage*)  Mtolua_new((fawkes::SkillerDebugInterface::SetGraphMessage)());
00167     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerDebugInterface::SetGraphMessage");
00168     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00169   }
00170  }
00171  return 1;
00172 tolua_lerror:
00173  return tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_new00_local(tolua_S);
00174 }
00175 #endif //#ifndef TOLUA_DISABLE
00176 
00177 /* method: delete of class  SetGraphMessage */
00178 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_delete00
00179 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_delete00(lua_State* tolua_S)
00180 {
00181 #ifndef TOLUA_RELEASE
00182  tolua_Error tolua_err;
00183  if (
00184      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphMessage",0,&tolua_err) ||
00185      !tolua_isnoobj(tolua_S,2,&tolua_err)
00186  )
00187   goto tolua_lerror;
00188  else
00189 #endif
00190  {
00191   fawkes::SkillerDebugInterface::SetGraphMessage* self = (fawkes::SkillerDebugInterface::SetGraphMessage*)  tolua_tousertype(tolua_S,1,0);
00192 #ifndef TOLUA_RELEASE
00193   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00194 #endif
00195   Mtolua_delete(self);
00196  }
00197  return 0;
00198 #ifndef TOLUA_RELEASE
00199  tolua_lerror:
00200  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00201  return 0;
00202 #endif
00203 }
00204 #endif //#ifndef TOLUA_DISABLE
00205 
00206 /* method: graph_fsm of class  SetGraphMessage */
00207 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_graph_fsm00
00208 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_graph_fsm00(lua_State* tolua_S)
00209 {
00210 #ifndef TOLUA_RELEASE
00211  tolua_Error tolua_err;
00212  if (
00213      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphMessage",0,&tolua_err) ||
00214      !tolua_isnoobj(tolua_S,2,&tolua_err)
00215  )
00216   goto tolua_lerror;
00217  else
00218 #endif
00219  {
00220   fawkes::SkillerDebugInterface::SetGraphMessage* self = (fawkes::SkillerDebugInterface::SetGraphMessage*)  tolua_tousertype(tolua_S,1,0);
00221 #ifndef TOLUA_RELEASE
00222   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'graph_fsm'", NULL);
00223 #endif
00224   {
00225    char* tolua_ret = (char*)  self->graph_fsm();
00226    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00227   }
00228  }
00229  return 1;
00230 #ifndef TOLUA_RELEASE
00231  tolua_lerror:
00232  tolua_error(tolua_S,"#ferror in function 'graph_fsm'.",&tolua_err);
00233  return 0;
00234 #endif
00235 }
00236 #endif //#ifndef TOLUA_DISABLE
00237 
00238 /* method: set_graph_fsm of class  SetGraphMessage */
00239 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_set_graph_fsm00
00240 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_set_graph_fsm00(lua_State* tolua_S)
00241 {
00242 #ifndef TOLUA_RELEASE
00243  tolua_Error tolua_err;
00244  if (
00245      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphMessage",0,&tolua_err) ||
00246      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00247      !tolua_isnoobj(tolua_S,3,&tolua_err)
00248  )
00249   goto tolua_lerror;
00250  else
00251 #endif
00252  {
00253   fawkes::SkillerDebugInterface::SetGraphMessage* self = (fawkes::SkillerDebugInterface::SetGraphMessage*)  tolua_tousertype(tolua_S,1,0);
00254   const char* new_graph_fsm = ((const char*)  tolua_tostring(tolua_S,2,0));
00255 #ifndef TOLUA_RELEASE
00256   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_graph_fsm'", NULL);
00257 #endif
00258   {
00259    self->set_graph_fsm(new_graph_fsm);
00260   }
00261  }
00262  return 0;
00263 #ifndef TOLUA_RELEASE
00264  tolua_lerror:
00265  tolua_error(tolua_S,"#ferror in function 'set_graph_fsm'.",&tolua_err);
00266  return 0;
00267 #endif
00268 }
00269 #endif //#ifndef TOLUA_DISABLE
00270 
00271 /* method: maxlenof_graph_fsm of class  SetGraphMessage */
00272 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_maxlenof_graph_fsm00
00273 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_maxlenof_graph_fsm00(lua_State* tolua_S)
00274 {
00275 #ifndef TOLUA_RELEASE
00276  tolua_Error tolua_err;
00277  if (
00278      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface::SetGraphMessage",0,&tolua_err) ||
00279      !tolua_isnoobj(tolua_S,2,&tolua_err)
00280  )
00281   goto tolua_lerror;
00282  else
00283 #endif
00284  {
00285   const fawkes::SkillerDebugInterface::SetGraphMessage* self = (const fawkes::SkillerDebugInterface::SetGraphMessage*)  tolua_tousertype(tolua_S,1,0);
00286 #ifndef TOLUA_RELEASE
00287   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_graph_fsm'", NULL);
00288 #endif
00289   {
00290    int tolua_ret = (int)  self->maxlenof_graph_fsm();
00291    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00292   }
00293  }
00294  return 1;
00295 #ifndef TOLUA_RELEASE
00296  tolua_lerror:
00297  tolua_error(tolua_S,"#ferror in function 'maxlenof_graph_fsm'.",&tolua_err);
00298  return 0;
00299 #endif
00300 }
00301 #endif //#ifndef TOLUA_DISABLE
00302 
00303 /* method: new of class  SetGraphDirectionMessage */
00304 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_new00
00305 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_new00(lua_State* tolua_S)
00306 {
00307 #ifndef TOLUA_RELEASE
00308  tolua_Error tolua_err;
00309  if (
00310      !tolua_isusertable(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphDirectionMessage",0,&tolua_err) ||
00311      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00312      !tolua_isnoobj(tolua_S,3,&tolua_err)
00313  )
00314   goto tolua_lerror;
00315  else
00316 #endif
00317  {
00318   fawkes::SkillerDebugInterface::GraphDirectionEnum ini_graph_dir = ((fawkes::SkillerDebugInterface::GraphDirectionEnum) (int)  tolua_tonumber(tolua_S,2,0));
00319   {
00320    fawkes::SkillerDebugInterface::SetGraphDirectionMessage* tolua_ret = (fawkes::SkillerDebugInterface::SetGraphDirectionMessage*)  Mtolua_new((fawkes::SkillerDebugInterface::SetGraphDirectionMessage)(ini_graph_dir));
00321     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerDebugInterface::SetGraphDirectionMessage");
00322   }
00323  }
00324  return 1;
00325 #ifndef TOLUA_RELEASE
00326  tolua_lerror:
00327  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00328  return 0;
00329 #endif
00330 }
00331 #endif //#ifndef TOLUA_DISABLE
00332 
00333 /* method: new_local of class  SetGraphDirectionMessage */
00334 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_new00_local
00335 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_new00_local(lua_State* tolua_S)
00336 {
00337 #ifndef TOLUA_RELEASE
00338  tolua_Error tolua_err;
00339  if (
00340      !tolua_isusertable(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphDirectionMessage",0,&tolua_err) ||
00341      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00342      !tolua_isnoobj(tolua_S,3,&tolua_err)
00343  )
00344   goto tolua_lerror;
00345  else
00346 #endif
00347  {
00348   fawkes::SkillerDebugInterface::GraphDirectionEnum ini_graph_dir = ((fawkes::SkillerDebugInterface::GraphDirectionEnum) (int)  tolua_tonumber(tolua_S,2,0));
00349   {
00350    fawkes::SkillerDebugInterface::SetGraphDirectionMessage* tolua_ret = (fawkes::SkillerDebugInterface::SetGraphDirectionMessage*)  Mtolua_new((fawkes::SkillerDebugInterface::SetGraphDirectionMessage)(ini_graph_dir));
00351     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerDebugInterface::SetGraphDirectionMessage");
00352     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00353   }
00354  }
00355  return 1;
00356 #ifndef TOLUA_RELEASE
00357  tolua_lerror:
00358  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00359  return 0;
00360 #endif
00361 }
00362 #endif //#ifndef TOLUA_DISABLE
00363 
00364 /* method: new of class  SetGraphDirectionMessage */
00365 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_new01
00366 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_new01(lua_State* tolua_S)
00367 {
00368  tolua_Error tolua_err;
00369  if (
00370      !tolua_isusertable(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphDirectionMessage",0,&tolua_err) ||
00371      !tolua_isnoobj(tolua_S,2,&tolua_err)
00372  )
00373   goto tolua_lerror;
00374  else
00375  {
00376   {
00377    fawkes::SkillerDebugInterface::SetGraphDirectionMessage* tolua_ret = (fawkes::SkillerDebugInterface::SetGraphDirectionMessage*)  Mtolua_new((fawkes::SkillerDebugInterface::SetGraphDirectionMessage)());
00378     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerDebugInterface::SetGraphDirectionMessage");
00379   }
00380  }
00381  return 1;
00382 tolua_lerror:
00383  return tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_new00(tolua_S);
00384 }
00385 #endif //#ifndef TOLUA_DISABLE
00386 
00387 /* method: new_local of class  SetGraphDirectionMessage */
00388 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_new01_local
00389 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_new01_local(lua_State* tolua_S)
00390 {
00391  tolua_Error tolua_err;
00392  if (
00393      !tolua_isusertable(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphDirectionMessage",0,&tolua_err) ||
00394      !tolua_isnoobj(tolua_S,2,&tolua_err)
00395  )
00396   goto tolua_lerror;
00397  else
00398  {
00399   {
00400    fawkes::SkillerDebugInterface::SetGraphDirectionMessage* tolua_ret = (fawkes::SkillerDebugInterface::SetGraphDirectionMessage*)  Mtolua_new((fawkes::SkillerDebugInterface::SetGraphDirectionMessage)());
00401     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerDebugInterface::SetGraphDirectionMessage");
00402     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00403   }
00404  }
00405  return 1;
00406 tolua_lerror:
00407  return tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_new00_local(tolua_S);
00408 }
00409 #endif //#ifndef TOLUA_DISABLE
00410 
00411 /* method: delete of class  SetGraphDirectionMessage */
00412 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_delete00
00413 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_delete00(lua_State* tolua_S)
00414 {
00415 #ifndef TOLUA_RELEASE
00416  tolua_Error tolua_err;
00417  if (
00418      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphDirectionMessage",0,&tolua_err) ||
00419      !tolua_isnoobj(tolua_S,2,&tolua_err)
00420  )
00421   goto tolua_lerror;
00422  else
00423 #endif
00424  {
00425   fawkes::SkillerDebugInterface::SetGraphDirectionMessage* self = (fawkes::SkillerDebugInterface::SetGraphDirectionMessage*)  tolua_tousertype(tolua_S,1,0);
00426 #ifndef TOLUA_RELEASE
00427   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00428 #endif
00429   Mtolua_delete(self);
00430  }
00431  return 0;
00432 #ifndef TOLUA_RELEASE
00433  tolua_lerror:
00434  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00435  return 0;
00436 #endif
00437 }
00438 #endif //#ifndef TOLUA_DISABLE
00439 
00440 /* method: graph_dir of class  SetGraphDirectionMessage */
00441 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_graph_dir00
00442 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_graph_dir00(lua_State* tolua_S)
00443 {
00444 #ifndef TOLUA_RELEASE
00445  tolua_Error tolua_err;
00446  if (
00447      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphDirectionMessage",0,&tolua_err) ||
00448      !tolua_isnoobj(tolua_S,2,&tolua_err)
00449  )
00450   goto tolua_lerror;
00451  else
00452 #endif
00453  {
00454   fawkes::SkillerDebugInterface::SetGraphDirectionMessage* self = (fawkes::SkillerDebugInterface::SetGraphDirectionMessage*)  tolua_tousertype(tolua_S,1,0);
00455 #ifndef TOLUA_RELEASE
00456   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'graph_dir'", NULL);
00457 #endif
00458   {
00459    fawkes::SkillerDebugInterface::GraphDirectionEnum tolua_ret = (fawkes::SkillerDebugInterface::GraphDirectionEnum)  self->graph_dir();
00460    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00461   }
00462  }
00463  return 1;
00464 #ifndef TOLUA_RELEASE
00465  tolua_lerror:
00466  tolua_error(tolua_S,"#ferror in function 'graph_dir'.",&tolua_err);
00467  return 0;
00468 #endif
00469 }
00470 #endif //#ifndef TOLUA_DISABLE
00471 
00472 /* method: set_graph_dir of class  SetGraphDirectionMessage */
00473 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_set_graph_dir00
00474 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_set_graph_dir00(lua_State* tolua_S)
00475 {
00476 #ifndef TOLUA_RELEASE
00477  tolua_Error tolua_err;
00478  if (
00479      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphDirectionMessage",0,&tolua_err) ||
00480      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
00481      !tolua_isnoobj(tolua_S,3,&tolua_err)
00482  )
00483   goto tolua_lerror;
00484  else
00485 #endif
00486  {
00487   fawkes::SkillerDebugInterface::SetGraphDirectionMessage* self = (fawkes::SkillerDebugInterface::SetGraphDirectionMessage*)  tolua_tousertype(tolua_S,1,0);
00488   const fawkes::SkillerDebugInterface::GraphDirectionEnum new_graph_dir = ((const fawkes::SkillerDebugInterface::GraphDirectionEnum) (int)  tolua_tonumber(tolua_S,2,0));
00489 #ifndef TOLUA_RELEASE
00490   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_graph_dir'", NULL);
00491 #endif
00492   {
00493    self->set_graph_dir(new_graph_dir);
00494   }
00495  }
00496  return 0;
00497 #ifndef TOLUA_RELEASE
00498  tolua_lerror:
00499  tolua_error(tolua_S,"#ferror in function 'set_graph_dir'.",&tolua_err);
00500  return 0;
00501 #endif
00502 }
00503 #endif //#ifndef TOLUA_DISABLE
00504 
00505 /* method: maxlenof_graph_dir of class  SetGraphDirectionMessage */
00506 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_maxlenof_graph_dir00
00507 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_maxlenof_graph_dir00(lua_State* tolua_S)
00508 {
00509 #ifndef TOLUA_RELEASE
00510  tolua_Error tolua_err;
00511  if (
00512      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface::SetGraphDirectionMessage",0,&tolua_err) ||
00513      !tolua_isnoobj(tolua_S,2,&tolua_err)
00514  )
00515   goto tolua_lerror;
00516  else
00517 #endif
00518  {
00519   const fawkes::SkillerDebugInterface::SetGraphDirectionMessage* self = (const fawkes::SkillerDebugInterface::SetGraphDirectionMessage*)  tolua_tousertype(tolua_S,1,0);
00520 #ifndef TOLUA_RELEASE
00521   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_graph_dir'", NULL);
00522 #endif
00523   {
00524    int tolua_ret = (int)  self->maxlenof_graph_dir();
00525    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00526   }
00527  }
00528  return 1;
00529 #ifndef TOLUA_RELEASE
00530  tolua_lerror:
00531  tolua_error(tolua_S,"#ferror in function 'maxlenof_graph_dir'.",&tolua_err);
00532  return 0;
00533 #endif
00534 }
00535 #endif //#ifndef TOLUA_DISABLE
00536 
00537 /* method: new of class  SetGraphColoredMessage */
00538 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_new00
00539 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_new00(lua_State* tolua_S)
00540 {
00541 #ifndef TOLUA_RELEASE
00542  tolua_Error tolua_err;
00543  if (
00544      !tolua_isusertable(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphColoredMessage",0,&tolua_err) ||
00545      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
00546      !tolua_isnoobj(tolua_S,3,&tolua_err)
00547  )
00548   goto tolua_lerror;
00549  else
00550 #endif
00551  {
00552   bool ini_graph_colored = ((bool)  tolua_toboolean(tolua_S,2,0));
00553   {
00554    fawkes::SkillerDebugInterface::SetGraphColoredMessage* tolua_ret = (fawkes::SkillerDebugInterface::SetGraphColoredMessage*)  Mtolua_new((fawkes::SkillerDebugInterface::SetGraphColoredMessage)(ini_graph_colored));
00555     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerDebugInterface::SetGraphColoredMessage");
00556   }
00557  }
00558  return 1;
00559 #ifndef TOLUA_RELEASE
00560  tolua_lerror:
00561  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00562  return 0;
00563 #endif
00564 }
00565 #endif //#ifndef TOLUA_DISABLE
00566 
00567 /* method: new_local of class  SetGraphColoredMessage */
00568 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_new00_local
00569 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_new00_local(lua_State* tolua_S)
00570 {
00571 #ifndef TOLUA_RELEASE
00572  tolua_Error tolua_err;
00573  if (
00574      !tolua_isusertable(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphColoredMessage",0,&tolua_err) ||
00575      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
00576      !tolua_isnoobj(tolua_S,3,&tolua_err)
00577  )
00578   goto tolua_lerror;
00579  else
00580 #endif
00581  {
00582   bool ini_graph_colored = ((bool)  tolua_toboolean(tolua_S,2,0));
00583   {
00584    fawkes::SkillerDebugInterface::SetGraphColoredMessage* tolua_ret = (fawkes::SkillerDebugInterface::SetGraphColoredMessage*)  Mtolua_new((fawkes::SkillerDebugInterface::SetGraphColoredMessage)(ini_graph_colored));
00585     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerDebugInterface::SetGraphColoredMessage");
00586     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00587   }
00588  }
00589  return 1;
00590 #ifndef TOLUA_RELEASE
00591  tolua_lerror:
00592  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
00593  return 0;
00594 #endif
00595 }
00596 #endif //#ifndef TOLUA_DISABLE
00597 
00598 /* method: new of class  SetGraphColoredMessage */
00599 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_new01
00600 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_new01(lua_State* tolua_S)
00601 {
00602  tolua_Error tolua_err;
00603  if (
00604      !tolua_isusertable(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphColoredMessage",0,&tolua_err) ||
00605      !tolua_isnoobj(tolua_S,2,&tolua_err)
00606  )
00607   goto tolua_lerror;
00608  else
00609  {
00610   {
00611    fawkes::SkillerDebugInterface::SetGraphColoredMessage* tolua_ret = (fawkes::SkillerDebugInterface::SetGraphColoredMessage*)  Mtolua_new((fawkes::SkillerDebugInterface::SetGraphColoredMessage)());
00612     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerDebugInterface::SetGraphColoredMessage");
00613   }
00614  }
00615  return 1;
00616 tolua_lerror:
00617  return tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_new00(tolua_S);
00618 }
00619 #endif //#ifndef TOLUA_DISABLE
00620 
00621 /* method: new_local of class  SetGraphColoredMessage */
00622 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_new01_local
00623 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_new01_local(lua_State* tolua_S)
00624 {
00625  tolua_Error tolua_err;
00626  if (
00627      !tolua_isusertable(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphColoredMessage",0,&tolua_err) ||
00628      !tolua_isnoobj(tolua_S,2,&tolua_err)
00629  )
00630   goto tolua_lerror;
00631  else
00632  {
00633   {
00634    fawkes::SkillerDebugInterface::SetGraphColoredMessage* tolua_ret = (fawkes::SkillerDebugInterface::SetGraphColoredMessage*)  Mtolua_new((fawkes::SkillerDebugInterface::SetGraphColoredMessage)());
00635     tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerDebugInterface::SetGraphColoredMessage");
00636     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
00637   }
00638  }
00639  return 1;
00640 tolua_lerror:
00641  return tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_new00_local(tolua_S);
00642 }
00643 #endif //#ifndef TOLUA_DISABLE
00644 
00645 /* method: delete of class  SetGraphColoredMessage */
00646 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_delete00
00647 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_delete00(lua_State* tolua_S)
00648 {
00649 #ifndef TOLUA_RELEASE
00650  tolua_Error tolua_err;
00651  if (
00652      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphColoredMessage",0,&tolua_err) ||
00653      !tolua_isnoobj(tolua_S,2,&tolua_err)
00654  )
00655   goto tolua_lerror;
00656  else
00657 #endif
00658  {
00659   fawkes::SkillerDebugInterface::SetGraphColoredMessage* self = (fawkes::SkillerDebugInterface::SetGraphColoredMessage*)  tolua_tousertype(tolua_S,1,0);
00660 #ifndef TOLUA_RELEASE
00661   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
00662 #endif
00663   Mtolua_delete(self);
00664  }
00665  return 0;
00666 #ifndef TOLUA_RELEASE
00667  tolua_lerror:
00668  tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
00669  return 0;
00670 #endif
00671 }
00672 #endif //#ifndef TOLUA_DISABLE
00673 
00674 /* method: is_graph_colored of class  SetGraphColoredMessage */
00675 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_is_graph_colored00
00676 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_is_graph_colored00(lua_State* tolua_S)
00677 {
00678 #ifndef TOLUA_RELEASE
00679  tolua_Error tolua_err;
00680  if (
00681      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphColoredMessage",0,&tolua_err) ||
00682      !tolua_isnoobj(tolua_S,2,&tolua_err)
00683  )
00684   goto tolua_lerror;
00685  else
00686 #endif
00687  {
00688   fawkes::SkillerDebugInterface::SetGraphColoredMessage* self = (fawkes::SkillerDebugInterface::SetGraphColoredMessage*)  tolua_tousertype(tolua_S,1,0);
00689 #ifndef TOLUA_RELEASE
00690   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_graph_colored'", NULL);
00691 #endif
00692   {
00693    bool tolua_ret = (bool)  self->is_graph_colored();
00694    tolua_pushboolean(tolua_S,(bool)tolua_ret);
00695   }
00696  }
00697  return 1;
00698 #ifndef TOLUA_RELEASE
00699  tolua_lerror:
00700  tolua_error(tolua_S,"#ferror in function 'is_graph_colored'.",&tolua_err);
00701  return 0;
00702 #endif
00703 }
00704 #endif //#ifndef TOLUA_DISABLE
00705 
00706 /* method: set_graph_colored of class  SetGraphColoredMessage */
00707 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_set_graph_colored00
00708 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_set_graph_colored00(lua_State* tolua_S)
00709 {
00710 #ifndef TOLUA_RELEASE
00711  tolua_Error tolua_err;
00712  if (
00713      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface::SetGraphColoredMessage",0,&tolua_err) ||
00714      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
00715      !tolua_isnoobj(tolua_S,3,&tolua_err)
00716  )
00717   goto tolua_lerror;
00718  else
00719 #endif
00720  {
00721   fawkes::SkillerDebugInterface::SetGraphColoredMessage* self = (fawkes::SkillerDebugInterface::SetGraphColoredMessage*)  tolua_tousertype(tolua_S,1,0);
00722   const bool new_graph_colored = ((const bool)  tolua_toboolean(tolua_S,2,0));
00723 #ifndef TOLUA_RELEASE
00724   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_graph_colored'", NULL);
00725 #endif
00726   {
00727    self->set_graph_colored(new_graph_colored);
00728   }
00729  }
00730  return 0;
00731 #ifndef TOLUA_RELEASE
00732  tolua_lerror:
00733  tolua_error(tolua_S,"#ferror in function 'set_graph_colored'.",&tolua_err);
00734  return 0;
00735 #endif
00736 }
00737 #endif //#ifndef TOLUA_DISABLE
00738 
00739 /* method: maxlenof_graph_colored of class  SetGraphColoredMessage */
00740 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_maxlenof_graph_colored00
00741 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_maxlenof_graph_colored00(lua_State* tolua_S)
00742 {
00743 #ifndef TOLUA_RELEASE
00744  tolua_Error tolua_err;
00745  if (
00746      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface::SetGraphColoredMessage",0,&tolua_err) ||
00747      !tolua_isnoobj(tolua_S,2,&tolua_err)
00748  )
00749   goto tolua_lerror;
00750  else
00751 #endif
00752  {
00753   const fawkes::SkillerDebugInterface::SetGraphColoredMessage* self = (const fawkes::SkillerDebugInterface::SetGraphColoredMessage*)  tolua_tousertype(tolua_S,1,0);
00754 #ifndef TOLUA_RELEASE
00755   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_graph_colored'", NULL);
00756 #endif
00757   {
00758    int tolua_ret = (int)  self->maxlenof_graph_colored();
00759    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00760   }
00761  }
00762  return 1;
00763 #ifndef TOLUA_RELEASE
00764  tolua_lerror:
00765  tolua_error(tolua_S,"#ferror in function 'maxlenof_graph_colored'.",&tolua_err);
00766  return 0;
00767 #endif
00768 }
00769 #endif //#ifndef TOLUA_DISABLE
00770 
00771 /* method: graph_fsm of class  fawkes::SkillerDebugInterface */
00772 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_graph_fsm00
00773 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_graph_fsm00(lua_State* tolua_S)
00774 {
00775 #ifndef TOLUA_RELEASE
00776  tolua_Error tolua_err;
00777  if (
00778      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
00779      !tolua_isnoobj(tolua_S,2,&tolua_err)
00780  )
00781   goto tolua_lerror;
00782  else
00783 #endif
00784  {
00785   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
00786 #ifndef TOLUA_RELEASE
00787   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'graph_fsm'", NULL);
00788 #endif
00789   {
00790    char* tolua_ret = (char*)  self->graph_fsm();
00791    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00792   }
00793  }
00794  return 1;
00795 #ifndef TOLUA_RELEASE
00796  tolua_lerror:
00797  tolua_error(tolua_S,"#ferror in function 'graph_fsm'.",&tolua_err);
00798  return 0;
00799 #endif
00800 }
00801 #endif //#ifndef TOLUA_DISABLE
00802 
00803 /* method: set_graph_fsm of class  fawkes::SkillerDebugInterface */
00804 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_set_graph_fsm00
00805 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_set_graph_fsm00(lua_State* tolua_S)
00806 {
00807 #ifndef TOLUA_RELEASE
00808  tolua_Error tolua_err;
00809  if (
00810      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
00811      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00812      !tolua_isnoobj(tolua_S,3,&tolua_err)
00813  )
00814   goto tolua_lerror;
00815  else
00816 #endif
00817  {
00818   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
00819   const char* new_graph_fsm = ((const char*)  tolua_tostring(tolua_S,2,0));
00820 #ifndef TOLUA_RELEASE
00821   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_graph_fsm'", NULL);
00822 #endif
00823   {
00824    self->set_graph_fsm(new_graph_fsm);
00825   }
00826  }
00827  return 0;
00828 #ifndef TOLUA_RELEASE
00829  tolua_lerror:
00830  tolua_error(tolua_S,"#ferror in function 'set_graph_fsm'.",&tolua_err);
00831  return 0;
00832 #endif
00833 }
00834 #endif //#ifndef TOLUA_DISABLE
00835 
00836 /* method: maxlenof_graph_fsm of class  fawkes::SkillerDebugInterface */
00837 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_maxlenof_graph_fsm00
00838 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_maxlenof_graph_fsm00(lua_State* tolua_S)
00839 {
00840 #ifndef TOLUA_RELEASE
00841  tolua_Error tolua_err;
00842  if (
00843      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
00844      !tolua_isnoobj(tolua_S,2,&tolua_err)
00845  )
00846   goto tolua_lerror;
00847  else
00848 #endif
00849  {
00850   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
00851 #ifndef TOLUA_RELEASE
00852   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_graph_fsm'", NULL);
00853 #endif
00854   {
00855    int tolua_ret = (int)  self->maxlenof_graph_fsm();
00856    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00857   }
00858  }
00859  return 1;
00860 #ifndef TOLUA_RELEASE
00861  tolua_lerror:
00862  tolua_error(tolua_S,"#ferror in function 'maxlenof_graph_fsm'.",&tolua_err);
00863  return 0;
00864 #endif
00865 }
00866 #endif //#ifndef TOLUA_DISABLE
00867 
00868 /* method: graph of class  fawkes::SkillerDebugInterface */
00869 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_graph00
00870 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_graph00(lua_State* tolua_S)
00871 {
00872 #ifndef TOLUA_RELEASE
00873  tolua_Error tolua_err;
00874  if (
00875      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
00876      !tolua_isnoobj(tolua_S,2,&tolua_err)
00877  )
00878   goto tolua_lerror;
00879  else
00880 #endif
00881  {
00882   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
00883 #ifndef TOLUA_RELEASE
00884   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'graph'", NULL);
00885 #endif
00886   {
00887    char* tolua_ret = (char*)  self->graph();
00888    tolua_pushstring(tolua_S,(const char*)tolua_ret);
00889   }
00890  }
00891  return 1;
00892 #ifndef TOLUA_RELEASE
00893  tolua_lerror:
00894  tolua_error(tolua_S,"#ferror in function 'graph'.",&tolua_err);
00895  return 0;
00896 #endif
00897 }
00898 #endif //#ifndef TOLUA_DISABLE
00899 
00900 /* method: set_graph of class  fawkes::SkillerDebugInterface */
00901 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_set_graph00
00902 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_set_graph00(lua_State* tolua_S)
00903 {
00904 #ifndef TOLUA_RELEASE
00905  tolua_Error tolua_err;
00906  if (
00907      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
00908      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
00909      !tolua_isnoobj(tolua_S,3,&tolua_err)
00910  )
00911   goto tolua_lerror;
00912  else
00913 #endif
00914  {
00915   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
00916   const char* new_graph = ((const char*)  tolua_tostring(tolua_S,2,0));
00917 #ifndef TOLUA_RELEASE
00918   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_graph'", NULL);
00919 #endif
00920   {
00921    self->set_graph(new_graph);
00922   }
00923  }
00924  return 0;
00925 #ifndef TOLUA_RELEASE
00926  tolua_lerror:
00927  tolua_error(tolua_S,"#ferror in function 'set_graph'.",&tolua_err);
00928  return 0;
00929 #endif
00930 }
00931 #endif //#ifndef TOLUA_DISABLE
00932 
00933 /* method: maxlenof_graph of class  fawkes::SkillerDebugInterface */
00934 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_maxlenof_graph00
00935 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_maxlenof_graph00(lua_State* tolua_S)
00936 {
00937 #ifndef TOLUA_RELEASE
00938  tolua_Error tolua_err;
00939  if (
00940      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
00941      !tolua_isnoobj(tolua_S,2,&tolua_err)
00942  )
00943   goto tolua_lerror;
00944  else
00945 #endif
00946  {
00947   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
00948 #ifndef TOLUA_RELEASE
00949   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_graph'", NULL);
00950 #endif
00951   {
00952    int tolua_ret = (int)  self->maxlenof_graph();
00953    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00954   }
00955  }
00956  return 1;
00957 #ifndef TOLUA_RELEASE
00958  tolua_lerror:
00959  tolua_error(tolua_S,"#ferror in function 'maxlenof_graph'.",&tolua_err);
00960  return 0;
00961 #endif
00962 }
00963 #endif //#ifndef TOLUA_DISABLE
00964 
00965 /* method: graph_dir of class  fawkes::SkillerDebugInterface */
00966 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_graph_dir00
00967 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_graph_dir00(lua_State* tolua_S)
00968 {
00969 #ifndef TOLUA_RELEASE
00970  tolua_Error tolua_err;
00971  if (
00972      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
00973      !tolua_isnoobj(tolua_S,2,&tolua_err)
00974  )
00975   goto tolua_lerror;
00976  else
00977 #endif
00978  {
00979   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
00980 #ifndef TOLUA_RELEASE
00981   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'graph_dir'", NULL);
00982 #endif
00983   {
00984    fawkes::SkillerDebugInterface::GraphDirectionEnum tolua_ret = (fawkes::SkillerDebugInterface::GraphDirectionEnum)  self->graph_dir();
00985    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
00986   }
00987  }
00988  return 1;
00989 #ifndef TOLUA_RELEASE
00990  tolua_lerror:
00991  tolua_error(tolua_S,"#ferror in function 'graph_dir'.",&tolua_err);
00992  return 0;
00993 #endif
00994 }
00995 #endif //#ifndef TOLUA_DISABLE
00996 
00997 /* method: set_graph_dir of class  fawkes::SkillerDebugInterface */
00998 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_set_graph_dir00
00999 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_set_graph_dir00(lua_State* tolua_S)
01000 {
01001 #ifndef TOLUA_RELEASE
01002  tolua_Error tolua_err;
01003  if (
01004      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
01005      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01006      !tolua_isnoobj(tolua_S,3,&tolua_err)
01007  )
01008   goto tolua_lerror;
01009  else
01010 #endif
01011  {
01012   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01013   const fawkes::SkillerDebugInterface::GraphDirectionEnum new_graph_dir = ((const fawkes::SkillerDebugInterface::GraphDirectionEnum) (int)  tolua_tonumber(tolua_S,2,0));
01014 #ifndef TOLUA_RELEASE
01015   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_graph_dir'", NULL);
01016 #endif
01017   {
01018    self->set_graph_dir(new_graph_dir);
01019   }
01020  }
01021  return 0;
01022 #ifndef TOLUA_RELEASE
01023  tolua_lerror:
01024  tolua_error(tolua_S,"#ferror in function 'set_graph_dir'.",&tolua_err);
01025  return 0;
01026 #endif
01027 }
01028 #endif //#ifndef TOLUA_DISABLE
01029 
01030 /* method: maxlenof_graph_dir of class  fawkes::SkillerDebugInterface */
01031 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_maxlenof_graph_dir00
01032 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_maxlenof_graph_dir00(lua_State* tolua_S)
01033 {
01034 #ifndef TOLUA_RELEASE
01035  tolua_Error tolua_err;
01036  if (
01037      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01038      !tolua_isnoobj(tolua_S,2,&tolua_err)
01039  )
01040   goto tolua_lerror;
01041  else
01042 #endif
01043  {
01044   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01045 #ifndef TOLUA_RELEASE
01046   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_graph_dir'", NULL);
01047 #endif
01048   {
01049    int tolua_ret = (int)  self->maxlenof_graph_dir();
01050    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01051   }
01052  }
01053  return 1;
01054 #ifndef TOLUA_RELEASE
01055  tolua_lerror:
01056  tolua_error(tolua_S,"#ferror in function 'maxlenof_graph_dir'.",&tolua_err);
01057  return 0;
01058 #endif
01059 }
01060 #endif //#ifndef TOLUA_DISABLE
01061 
01062 /* method: is_graph_colored of class  fawkes::SkillerDebugInterface */
01063 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_is_graph_colored00
01064 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_is_graph_colored00(lua_State* tolua_S)
01065 {
01066 #ifndef TOLUA_RELEASE
01067  tolua_Error tolua_err;
01068  if (
01069      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
01070      !tolua_isnoobj(tolua_S,2,&tolua_err)
01071  )
01072   goto tolua_lerror;
01073  else
01074 #endif
01075  {
01076   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01077 #ifndef TOLUA_RELEASE
01078   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_graph_colored'", NULL);
01079 #endif
01080   {
01081    bool tolua_ret = (bool)  self->is_graph_colored();
01082    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01083   }
01084  }
01085  return 1;
01086 #ifndef TOLUA_RELEASE
01087  tolua_lerror:
01088  tolua_error(tolua_S,"#ferror in function 'is_graph_colored'.",&tolua_err);
01089  return 0;
01090 #endif
01091 }
01092 #endif //#ifndef TOLUA_DISABLE
01093 
01094 /* method: set_graph_colored of class  fawkes::SkillerDebugInterface */
01095 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_set_graph_colored00
01096 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_set_graph_colored00(lua_State* tolua_S)
01097 {
01098 #ifndef TOLUA_RELEASE
01099  tolua_Error tolua_err;
01100  if (
01101      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
01102      !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
01103      !tolua_isnoobj(tolua_S,3,&tolua_err)
01104  )
01105   goto tolua_lerror;
01106  else
01107 #endif
01108  {
01109   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01110   const bool new_graph_colored = ((const bool)  tolua_toboolean(tolua_S,2,0));
01111 #ifndef TOLUA_RELEASE
01112   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_graph_colored'", NULL);
01113 #endif
01114   {
01115    self->set_graph_colored(new_graph_colored);
01116   }
01117  }
01118  return 0;
01119 #ifndef TOLUA_RELEASE
01120  tolua_lerror:
01121  tolua_error(tolua_S,"#ferror in function 'set_graph_colored'.",&tolua_err);
01122  return 0;
01123 #endif
01124 }
01125 #endif //#ifndef TOLUA_DISABLE
01126 
01127 /* method: maxlenof_graph_colored of class  fawkes::SkillerDebugInterface */
01128 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_maxlenof_graph_colored00
01129 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_maxlenof_graph_colored00(lua_State* tolua_S)
01130 {
01131 #ifndef TOLUA_RELEASE
01132  tolua_Error tolua_err;
01133  if (
01134      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01135      !tolua_isnoobj(tolua_S,2,&tolua_err)
01136  )
01137   goto tolua_lerror;
01138  else
01139 #endif
01140  {
01141   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01142 #ifndef TOLUA_RELEASE
01143   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_graph_colored'", NULL);
01144 #endif
01145   {
01146    int tolua_ret = (int)  self->maxlenof_graph_colored();
01147    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01148   }
01149  }
01150  return 1;
01151 #ifndef TOLUA_RELEASE
01152  tolua_lerror:
01153  tolua_error(tolua_S,"#ferror in function 'maxlenof_graph_colored'.",&tolua_err);
01154  return 0;
01155 #endif
01156 }
01157 #endif //#ifndef TOLUA_DISABLE
01158 
01159 /* method: oftype of class  fawkes::SkillerDebugInterface */
01160 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_oftype00
01161 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_oftype00(lua_State* tolua_S)
01162 {
01163 #ifndef TOLUA_RELEASE
01164  tolua_Error tolua_err;
01165  if (
01166      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01167      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01168      !tolua_isnoobj(tolua_S,3,&tolua_err)
01169  )
01170   goto tolua_lerror;
01171  else
01172 #endif
01173  {
01174   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01175   const char* interface_type = ((const char*)  tolua_tostring(tolua_S,2,0));
01176 #ifndef TOLUA_RELEASE
01177   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL);
01178 #endif
01179   {
01180    bool tolua_ret = (bool)  self->oftype(interface_type);
01181    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01182   }
01183  }
01184  return 1;
01185 #ifndef TOLUA_RELEASE
01186  tolua_lerror:
01187  tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err);
01188  return 0;
01189 #endif
01190 }
01191 #endif //#ifndef TOLUA_DISABLE
01192 
01193 /* method: datachunk of class  fawkes::SkillerDebugInterface */
01194 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_datachunk00
01195 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_datachunk00(lua_State* tolua_S)
01196 {
01197 #ifndef TOLUA_RELEASE
01198  tolua_Error tolua_err;
01199  if (
01200      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01201      !tolua_isnoobj(tolua_S,2,&tolua_err)
01202  )
01203   goto tolua_lerror;
01204  else
01205 #endif
01206  {
01207   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01208 #ifndef TOLUA_RELEASE
01209   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL);
01210 #endif
01211   {
01212    const void* tolua_ret = (const void*)  self->datachunk();
01213    tolua_pushuserdata(tolua_S,(void*)tolua_ret);
01214   }
01215  }
01216  return 1;
01217 #ifndef TOLUA_RELEASE
01218  tolua_lerror:
01219  tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err);
01220  return 0;
01221 #endif
01222 }
01223 #endif //#ifndef TOLUA_DISABLE
01224 
01225 /* method: datasize of class  fawkes::SkillerDebugInterface */
01226 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_datasize00
01227 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_datasize00(lua_State* tolua_S)
01228 {
01229 #ifndef TOLUA_RELEASE
01230  tolua_Error tolua_err;
01231  if (
01232      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01233      !tolua_isnoobj(tolua_S,2,&tolua_err)
01234  )
01235   goto tolua_lerror;
01236  else
01237 #endif
01238  {
01239   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01240 #ifndef TOLUA_RELEASE
01241   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL);
01242 #endif
01243   {
01244    unsigned int tolua_ret = (unsigned int)  self->datasize();
01245    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01246   }
01247  }
01248  return 1;
01249 #ifndef TOLUA_RELEASE
01250  tolua_lerror:
01251  tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err);
01252  return 0;
01253 #endif
01254 }
01255 #endif //#ifndef TOLUA_DISABLE
01256 
01257 /* method: type of class  fawkes::SkillerDebugInterface */
01258 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_type00
01259 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_type00(lua_State* tolua_S)
01260 {
01261 #ifndef TOLUA_RELEASE
01262  tolua_Error tolua_err;
01263  if (
01264      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01265      !tolua_isnoobj(tolua_S,2,&tolua_err)
01266  )
01267   goto tolua_lerror;
01268  else
01269 #endif
01270  {
01271   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01272 #ifndef TOLUA_RELEASE
01273   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL);
01274 #endif
01275   {
01276    const char* tolua_ret = (const char*)  self->type();
01277    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01278   }
01279  }
01280  return 1;
01281 #ifndef TOLUA_RELEASE
01282  tolua_lerror:
01283  tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err);
01284  return 0;
01285 #endif
01286 }
01287 #endif //#ifndef TOLUA_DISABLE
01288 
01289 /* method: id of class  fawkes::SkillerDebugInterface */
01290 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_id00
01291 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_id00(lua_State* tolua_S)
01292 {
01293 #ifndef TOLUA_RELEASE
01294  tolua_Error tolua_err;
01295  if (
01296      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01297      !tolua_isnoobj(tolua_S,2,&tolua_err)
01298  )
01299   goto tolua_lerror;
01300  else
01301 #endif
01302  {
01303   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01304 #ifndef TOLUA_RELEASE
01305   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL);
01306 #endif
01307   {
01308    const char* tolua_ret = (const char*)  self->id();
01309    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01310   }
01311  }
01312  return 1;
01313 #ifndef TOLUA_RELEASE
01314  tolua_lerror:
01315  tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
01316  return 0;
01317 #endif
01318 }
01319 #endif //#ifndef TOLUA_DISABLE
01320 
01321 /* method: uid of class  fawkes::SkillerDebugInterface */
01322 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_uid00
01323 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_uid00(lua_State* tolua_S)
01324 {
01325 #ifndef TOLUA_RELEASE
01326  tolua_Error tolua_err;
01327  if (
01328      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01329      !tolua_isnoobj(tolua_S,2,&tolua_err)
01330  )
01331   goto tolua_lerror;
01332  else
01333 #endif
01334  {
01335   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01336 #ifndef TOLUA_RELEASE
01337   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL);
01338 #endif
01339   {
01340    const char* tolua_ret = (const char*)  self->uid();
01341    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01342   }
01343  }
01344  return 1;
01345 #ifndef TOLUA_RELEASE
01346  tolua_lerror:
01347  tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err);
01348  return 0;
01349 #endif
01350 }
01351 #endif //#ifndef TOLUA_DISABLE
01352 
01353 /* method: serial of class  fawkes::SkillerDebugInterface */
01354 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_serial00
01355 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_serial00(lua_State* tolua_S)
01356 {
01357 #ifndef TOLUA_RELEASE
01358  tolua_Error tolua_err;
01359  if (
01360      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01361      !tolua_isnoobj(tolua_S,2,&tolua_err)
01362  )
01363   goto tolua_lerror;
01364  else
01365 #endif
01366  {
01367   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01368 #ifndef TOLUA_RELEASE
01369   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL);
01370 #endif
01371   {
01372    unsigned int tolua_ret = (unsigned int)  self->serial();
01373    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01374   }
01375  }
01376  return 1;
01377 #ifndef TOLUA_RELEASE
01378  tolua_lerror:
01379  tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err);
01380  return 0;
01381 #endif
01382 }
01383 #endif //#ifndef TOLUA_DISABLE
01384 
01385 /* method: mem_serial of class  fawkes::SkillerDebugInterface */
01386 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_mem_serial00
01387 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_mem_serial00(lua_State* tolua_S)
01388 {
01389 #ifndef TOLUA_RELEASE
01390  tolua_Error tolua_err;
01391  if (
01392      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01393      !tolua_isnoobj(tolua_S,2,&tolua_err)
01394  )
01395   goto tolua_lerror;
01396  else
01397 #endif
01398  {
01399   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01400 #ifndef TOLUA_RELEASE
01401   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL);
01402 #endif
01403   {
01404    unsigned int tolua_ret = (unsigned int)  self->mem_serial();
01405    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01406   }
01407  }
01408  return 1;
01409 #ifndef TOLUA_RELEASE
01410  tolua_lerror:
01411  tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err);
01412  return 0;
01413 #endif
01414 }
01415 #endif //#ifndef TOLUA_DISABLE
01416 
01417 /* method: operator== of class  fawkes::SkillerDebugInterface */
01418 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface__eq00
01419 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface__eq00(lua_State* tolua_S)
01420 {
01421 #ifndef TOLUA_RELEASE
01422  tolua_Error tolua_err;
01423  if (
01424      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01425      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) ||
01426      !tolua_isnoobj(tolua_S,3,&tolua_err)
01427  )
01428   goto tolua_lerror;
01429  else
01430 #endif
01431  {
01432   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01433   Interface* comp = ((Interface*)  tolua_tousertype(tolua_S,2,0));
01434 #ifndef TOLUA_RELEASE
01435   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
01436 #endif
01437   {
01438    bool tolua_ret = (bool)  self->operator==(*comp);
01439    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01440   }
01441  }
01442  return 1;
01443 #ifndef TOLUA_RELEASE
01444  tolua_lerror:
01445  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
01446  return 0;
01447 #endif
01448 }
01449 #endif //#ifndef TOLUA_DISABLE
01450 
01451 /* method: hash of class  fawkes::SkillerDebugInterface */
01452 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_hash00
01453 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_hash00(lua_State* tolua_S)
01454 {
01455 #ifndef TOLUA_RELEASE
01456  tolua_Error tolua_err;
01457  if (
01458      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01459      !tolua_isnoobj(tolua_S,2,&tolua_err)
01460  )
01461   goto tolua_lerror;
01462  else
01463 #endif
01464  {
01465   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01466 #ifndef TOLUA_RELEASE
01467   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL);
01468 #endif
01469   {
01470    unsigned const char* tolua_ret = ( unsigned const char*)  self->hash();
01471    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01472   }
01473  }
01474  return 1;
01475 #ifndef TOLUA_RELEASE
01476  tolua_lerror:
01477  tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err);
01478  return 0;
01479 #endif
01480 }
01481 #endif //#ifndef TOLUA_DISABLE
01482 
01483 /* method: hash_size of class  fawkes::SkillerDebugInterface */
01484 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_hash_size00
01485 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_hash_size00(lua_State* tolua_S)
01486 {
01487 #ifndef TOLUA_RELEASE
01488  tolua_Error tolua_err;
01489  if (
01490      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01491      !tolua_isnoobj(tolua_S,2,&tolua_err)
01492  )
01493   goto tolua_lerror;
01494  else
01495 #endif
01496  {
01497   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01498 #ifndef TOLUA_RELEASE
01499   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL);
01500 #endif
01501   {
01502    int tolua_ret = (int)  self->hash_size();
01503    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01504   }
01505  }
01506  return 1;
01507 #ifndef TOLUA_RELEASE
01508  tolua_lerror:
01509  tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err);
01510  return 0;
01511 #endif
01512 }
01513 #endif //#ifndef TOLUA_DISABLE
01514 
01515 /* method: hash_printable of class  fawkes::SkillerDebugInterface */
01516 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_hash_printable00
01517 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_hash_printable00(lua_State* tolua_S)
01518 {
01519 #ifndef TOLUA_RELEASE
01520  tolua_Error tolua_err;
01521  if (
01522      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01523      !tolua_isnoobj(tolua_S,2,&tolua_err)
01524  )
01525   goto tolua_lerror;
01526  else
01527 #endif
01528  {
01529   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01530 #ifndef TOLUA_RELEASE
01531   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL);
01532 #endif
01533   {
01534    const char* tolua_ret = (const char*)  self->hash_printable();
01535    tolua_pushstring(tolua_S,(const char*)tolua_ret);
01536   }
01537  }
01538  return 1;
01539 #ifndef TOLUA_RELEASE
01540  tolua_lerror:
01541  tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err);
01542  return 0;
01543 #endif
01544 }
01545 #endif //#ifndef TOLUA_DISABLE
01546 
01547 /* method: is_writer of class  fawkes::SkillerDebugInterface */
01548 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_is_writer00
01549 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_is_writer00(lua_State* tolua_S)
01550 {
01551 #ifndef TOLUA_RELEASE
01552  tolua_Error tolua_err;
01553  if (
01554      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01555      !tolua_isnoobj(tolua_S,2,&tolua_err)
01556  )
01557   goto tolua_lerror;
01558  else
01559 #endif
01560  {
01561   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01562 #ifndef TOLUA_RELEASE
01563   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL);
01564 #endif
01565   {
01566    bool tolua_ret = (bool)  self->is_writer();
01567    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01568   }
01569  }
01570  return 1;
01571 #ifndef TOLUA_RELEASE
01572  tolua_lerror:
01573  tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err);
01574  return 0;
01575 #endif
01576 }
01577 #endif //#ifndef TOLUA_DISABLE
01578 
01579 /* method: set_from_chunk of class  fawkes::SkillerDebugInterface */
01580 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_set_from_chunk00
01581 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_set_from_chunk00(lua_State* tolua_S)
01582 {
01583 #ifndef TOLUA_RELEASE
01584  tolua_Error tolua_err;
01585  if (
01586      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
01587      !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
01588      !tolua_isnoobj(tolua_S,3,&tolua_err)
01589  )
01590   goto tolua_lerror;
01591  else
01592 #endif
01593  {
01594   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01595   void* chunk = ((void*)  tolua_touserdata(tolua_S,2,0));
01596 #ifndef TOLUA_RELEASE
01597   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL);
01598 #endif
01599   {
01600    self->set_from_chunk(chunk);
01601   }
01602  }
01603  return 0;
01604 #ifndef TOLUA_RELEASE
01605  tolua_lerror:
01606  tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err);
01607  return 0;
01608 #endif
01609 }
01610 #endif //#ifndef TOLUA_DISABLE
01611 
01612 /* method: create_message of class  fawkes::SkillerDebugInterface */
01613 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_create_message00
01614 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_create_message00(lua_State* tolua_S)
01615 {
01616 #ifndef TOLUA_RELEASE
01617  tolua_Error tolua_err;
01618  if (
01619      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01620      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
01621      !tolua_isnoobj(tolua_S,3,&tolua_err)
01622  )
01623   goto tolua_lerror;
01624  else
01625 #endif
01626  {
01627   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01628   const char* type = ((const char*)  tolua_tostring(tolua_S,2,0));
01629 #ifndef TOLUA_RELEASE
01630   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL);
01631 #endif
01632   {
01633    Message* tolua_ret = (Message*)  self->create_message(type);
01634     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
01635   }
01636  }
01637  return 1;
01638 #ifndef TOLUA_RELEASE
01639  tolua_lerror:
01640  tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err);
01641  return 0;
01642 #endif
01643 }
01644 #endif //#ifndef TOLUA_DISABLE
01645 
01646 /* method: read of class  fawkes::SkillerDebugInterface */
01647 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_read00
01648 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_read00(lua_State* tolua_S)
01649 {
01650 #ifndef TOLUA_RELEASE
01651  tolua_Error tolua_err;
01652  if (
01653      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
01654      !tolua_isnoobj(tolua_S,2,&tolua_err)
01655  )
01656   goto tolua_lerror;
01657  else
01658 #endif
01659  {
01660   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01661 #ifndef TOLUA_RELEASE
01662   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL);
01663 #endif
01664   {
01665    self->read();
01666   }
01667  }
01668  return 0;
01669 #ifndef TOLUA_RELEASE
01670  tolua_lerror:
01671  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
01672  return 0;
01673 #endif
01674 }
01675 #endif //#ifndef TOLUA_DISABLE
01676 
01677 /* method: write of class  fawkes::SkillerDebugInterface */
01678 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_write00
01679 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_write00(lua_State* tolua_S)
01680 {
01681 #ifndef TOLUA_RELEASE
01682  tolua_Error tolua_err;
01683  if (
01684      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
01685      !tolua_isnoobj(tolua_S,2,&tolua_err)
01686  )
01687   goto tolua_lerror;
01688  else
01689 #endif
01690  {
01691   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01692 #ifndef TOLUA_RELEASE
01693   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL);
01694 #endif
01695   {
01696    self->write();
01697   }
01698  }
01699  return 0;
01700 #ifndef TOLUA_RELEASE
01701  tolua_lerror:
01702  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
01703  return 0;
01704 #endif
01705 }
01706 #endif //#ifndef TOLUA_DISABLE
01707 
01708 /* method: has_writer of class  fawkes::SkillerDebugInterface */
01709 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_has_writer00
01710 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_has_writer00(lua_State* tolua_S)
01711 {
01712 #ifndef TOLUA_RELEASE
01713  tolua_Error tolua_err;
01714  if (
01715      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01716      !tolua_isnoobj(tolua_S,2,&tolua_err)
01717  )
01718   goto tolua_lerror;
01719  else
01720 #endif
01721  {
01722   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01723 #ifndef TOLUA_RELEASE
01724   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL);
01725 #endif
01726   {
01727    bool tolua_ret = (bool)  self->has_writer();
01728    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01729   }
01730  }
01731  return 1;
01732 #ifndef TOLUA_RELEASE
01733  tolua_lerror:
01734  tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err);
01735  return 0;
01736 #endif
01737 }
01738 #endif //#ifndef TOLUA_DISABLE
01739 
01740 /* method: num_readers of class  fawkes::SkillerDebugInterface */
01741 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_num_readers00
01742 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_num_readers00(lua_State* tolua_S)
01743 {
01744 #ifndef TOLUA_RELEASE
01745  tolua_Error tolua_err;
01746  if (
01747      !tolua_isusertype(tolua_S,1,"const fawkes::SkillerDebugInterface",0,&tolua_err) ||
01748      !tolua_isnoobj(tolua_S,2,&tolua_err)
01749  )
01750   goto tolua_lerror;
01751  else
01752 #endif
01753  {
01754   const fawkes::SkillerDebugInterface* self = (const fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01755 #ifndef TOLUA_RELEASE
01756   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL);
01757 #endif
01758   {
01759    unsigned int tolua_ret = (unsigned int)  self->num_readers();
01760    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01761   }
01762  }
01763  return 1;
01764 #ifndef TOLUA_RELEASE
01765  tolua_lerror:
01766  tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err);
01767  return 0;
01768 #endif
01769 }
01770 #endif //#ifndef TOLUA_DISABLE
01771 
01772 /* method: msgq_enqueue_copy of class  fawkes::SkillerDebugInterface */
01773 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_enqueue_copy00
01774 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_enqueue_copy00(lua_State* tolua_S)
01775 {
01776 #ifndef TOLUA_RELEASE
01777  tolua_Error tolua_err;
01778  if (
01779      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
01780      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
01781      !tolua_isnoobj(tolua_S,3,&tolua_err)
01782  )
01783   goto tolua_lerror;
01784  else
01785 #endif
01786  {
01787   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01788   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
01789 #ifndef TOLUA_RELEASE
01790   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL);
01791 #endif
01792   {
01793    unsigned int tolua_ret = (unsigned int)  self->msgq_enqueue_copy(message);
01794    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01795   }
01796  }
01797  return 1;
01798 #ifndef TOLUA_RELEASE
01799  tolua_lerror:
01800  tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err);
01801  return 0;
01802 #endif
01803 }
01804 #endif //#ifndef TOLUA_DISABLE
01805 
01806 /* method: msgq_remove of class  fawkes::SkillerDebugInterface */
01807 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_remove00
01808 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_remove00(lua_State* tolua_S)
01809 {
01810 #ifndef TOLUA_RELEASE
01811  tolua_Error tolua_err;
01812  if (
01813      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
01814      !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) ||
01815      !tolua_isnoobj(tolua_S,3,&tolua_err)
01816  )
01817   goto tolua_lerror;
01818  else
01819 #endif
01820  {
01821   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01822   Message* message = ((Message*)  tolua_tousertype(tolua_S,2,0));
01823 #ifndef TOLUA_RELEASE
01824   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
01825 #endif
01826   {
01827    self->msgq_remove(message);
01828   }
01829  }
01830  return 0;
01831 #ifndef TOLUA_RELEASE
01832  tolua_lerror:
01833  tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err);
01834  return 0;
01835 #endif
01836 }
01837 #endif //#ifndef TOLUA_DISABLE
01838 
01839 /* method: msgq_remove of class  fawkes::SkillerDebugInterface */
01840 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_remove01
01841 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_remove01(lua_State* tolua_S)
01842 {
01843  tolua_Error tolua_err;
01844  if (
01845      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
01846      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
01847      !tolua_isnoobj(tolua_S,3,&tolua_err)
01848  )
01849   goto tolua_lerror;
01850  else
01851  {
01852   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01853   unsigned int message_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
01854 #ifndef TOLUA_RELEASE
01855   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL);
01856 #endif
01857   {
01858    self->msgq_remove(message_id);
01859   }
01860  }
01861  return 0;
01862 tolua_lerror:
01863  return tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_remove00(tolua_S);
01864 }
01865 #endif //#ifndef TOLUA_DISABLE
01866 
01867 /* method: msgq_size of class  fawkes::SkillerDebugInterface */
01868 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_size00
01869 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_size00(lua_State* tolua_S)
01870 {
01871 #ifndef TOLUA_RELEASE
01872  tolua_Error tolua_err;
01873  if (
01874      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
01875      !tolua_isnoobj(tolua_S,2,&tolua_err)
01876  )
01877   goto tolua_lerror;
01878  else
01879 #endif
01880  {
01881   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01882 #ifndef TOLUA_RELEASE
01883   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL);
01884 #endif
01885   {
01886    unsigned int tolua_ret = (unsigned int)  self->msgq_size();
01887    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
01888   }
01889  }
01890  return 1;
01891 #ifndef TOLUA_RELEASE
01892  tolua_lerror:
01893  tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err);
01894  return 0;
01895 #endif
01896 }
01897 #endif //#ifndef TOLUA_DISABLE
01898 
01899 /* method: msgq_flush of class  fawkes::SkillerDebugInterface */
01900 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_flush00
01901 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_flush00(lua_State* tolua_S)
01902 {
01903 #ifndef TOLUA_RELEASE
01904  tolua_Error tolua_err;
01905  if (
01906      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
01907      !tolua_isnoobj(tolua_S,2,&tolua_err)
01908  )
01909   goto tolua_lerror;
01910  else
01911 #endif
01912  {
01913   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01914 #ifndef TOLUA_RELEASE
01915   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL);
01916 #endif
01917   {
01918    self->msgq_flush();
01919   }
01920  }
01921  return 0;
01922 #ifndef TOLUA_RELEASE
01923  tolua_lerror:
01924  tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err);
01925  return 0;
01926 #endif
01927 }
01928 #endif //#ifndef TOLUA_DISABLE
01929 
01930 /* method: msgq_lock of class  fawkes::SkillerDebugInterface */
01931 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_lock00
01932 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_lock00(lua_State* tolua_S)
01933 {
01934 #ifndef TOLUA_RELEASE
01935  tolua_Error tolua_err;
01936  if (
01937      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
01938      !tolua_isnoobj(tolua_S,2,&tolua_err)
01939  )
01940   goto tolua_lerror;
01941  else
01942 #endif
01943  {
01944   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01945 #ifndef TOLUA_RELEASE
01946   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL);
01947 #endif
01948   {
01949    self->msgq_lock();
01950   }
01951  }
01952  return 0;
01953 #ifndef TOLUA_RELEASE
01954  tolua_lerror:
01955  tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err);
01956  return 0;
01957 #endif
01958 }
01959 #endif //#ifndef TOLUA_DISABLE
01960 
01961 /* method: msgq_try_lock of class  fawkes::SkillerDebugInterface */
01962 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_try_lock00
01963 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_try_lock00(lua_State* tolua_S)
01964 {
01965 #ifndef TOLUA_RELEASE
01966  tolua_Error tolua_err;
01967  if (
01968      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
01969      !tolua_isnoobj(tolua_S,2,&tolua_err)
01970  )
01971   goto tolua_lerror;
01972  else
01973 #endif
01974  {
01975   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
01976 #ifndef TOLUA_RELEASE
01977   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL);
01978 #endif
01979   {
01980    bool tolua_ret = (bool)  self->msgq_try_lock();
01981    tolua_pushboolean(tolua_S,(bool)tolua_ret);
01982   }
01983  }
01984  return 1;
01985 #ifndef TOLUA_RELEASE
01986  tolua_lerror:
01987  tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err);
01988  return 0;
01989 #endif
01990 }
01991 #endif //#ifndef TOLUA_DISABLE
01992 
01993 /* method: msgq_unlock of class  fawkes::SkillerDebugInterface */
01994 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_unlock00
01995 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_unlock00(lua_State* tolua_S)
01996 {
01997 #ifndef TOLUA_RELEASE
01998  tolua_Error tolua_err;
01999  if (
02000      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
02001      !tolua_isnoobj(tolua_S,2,&tolua_err)
02002  )
02003   goto tolua_lerror;
02004  else
02005 #endif
02006  {
02007   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
02008 #ifndef TOLUA_RELEASE
02009   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL);
02010 #endif
02011   {
02012    self->msgq_unlock();
02013   }
02014  }
02015  return 0;
02016 #ifndef TOLUA_RELEASE
02017  tolua_lerror:
02018  tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err);
02019  return 0;
02020 #endif
02021 }
02022 #endif //#ifndef TOLUA_DISABLE
02023 
02024 /* method: msgq_pop of class  fawkes::SkillerDebugInterface */
02025 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_pop00
02026 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_pop00(lua_State* tolua_S)
02027 {
02028 #ifndef TOLUA_RELEASE
02029  tolua_Error tolua_err;
02030  if (
02031      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
02032      !tolua_isnoobj(tolua_S,2,&tolua_err)
02033  )
02034   goto tolua_lerror;
02035  else
02036 #endif
02037  {
02038   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
02039 #ifndef TOLUA_RELEASE
02040   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL);
02041 #endif
02042   {
02043    self->msgq_pop();
02044   }
02045  }
02046  return 0;
02047 #ifndef TOLUA_RELEASE
02048  tolua_lerror:
02049  tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err);
02050  return 0;
02051 #endif
02052 }
02053 #endif //#ifndef TOLUA_DISABLE
02054 
02055 /* method: msgq_first of class  fawkes::SkillerDebugInterface */
02056 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_first00
02057 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_first00(lua_State* tolua_S)
02058 {
02059 #ifndef TOLUA_RELEASE
02060  tolua_Error tolua_err;
02061  if (
02062      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
02063      !tolua_isnoobj(tolua_S,2,&tolua_err)
02064  )
02065   goto tolua_lerror;
02066  else
02067 #endif
02068  {
02069   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
02070 #ifndef TOLUA_RELEASE
02071   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL);
02072 #endif
02073   {
02074    Message* tolua_ret = (Message*)  self->msgq_first();
02075     tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message");
02076   }
02077  }
02078  return 1;
02079 #ifndef TOLUA_RELEASE
02080  tolua_lerror:
02081  tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err);
02082  return 0;
02083 #endif
02084 }
02085 #endif //#ifndef TOLUA_DISABLE
02086 
02087 /* method: msgq_empty of class  fawkes::SkillerDebugInterface */
02088 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_empty00
02089 static int tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_empty00(lua_State* tolua_S)
02090 {
02091 #ifndef TOLUA_RELEASE
02092  tolua_Error tolua_err;
02093  if (
02094      !tolua_isusertype(tolua_S,1,"fawkes::SkillerDebugInterface",0,&tolua_err) ||
02095      !tolua_isnoobj(tolua_S,2,&tolua_err)
02096  )
02097   goto tolua_lerror;
02098  else
02099 #endif
02100  {
02101   fawkes::SkillerDebugInterface* self = (fawkes::SkillerDebugInterface*)  tolua_tousertype(tolua_S,1,0);
02102 #ifndef TOLUA_RELEASE
02103   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL);
02104 #endif
02105   {
02106    bool tolua_ret = (bool)  self->msgq_empty();
02107    tolua_pushboolean(tolua_S,(bool)tolua_ret);
02108   }
02109  }
02110  return 1;
02111 #ifndef TOLUA_RELEASE
02112  tolua_lerror:
02113  tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err);
02114  return 0;
02115 #endif
02116 }
02117 #endif //#ifndef TOLUA_DISABLE
02118 
02119 /* Open function */
02120 TOLUA_API int tolua_interfaces_SkillerDebugInterface_open (lua_State* tolua_S)
02121 {
02122  tolua_open(tolua_S);
02123  tolua_reg_types(tolua_S);
02124  tolua_module(tolua_S,NULL,0);
02125  tolua_beginmodule(tolua_S,NULL);
02126   tolua_module(tolua_S,"fawkes",0);
02127   tolua_beginmodule(tolua_S,"fawkes");
02128    tolua_cclass(tolua_S,"SkillerDebugInterface","fawkes::SkillerDebugInterface","Interface",NULL);
02129    tolua_beginmodule(tolua_S,"SkillerDebugInterface");
02130     tolua_constant(tolua_S,"GD_TOP_BOTTOM",fawkes::SkillerDebugInterface::GD_TOP_BOTTOM);
02131     tolua_constant(tolua_S,"GD_BOTTOM_TOP",fawkes::SkillerDebugInterface::GD_BOTTOM_TOP);
02132     tolua_constant(tolua_S,"GD_LEFT_RIGHT",fawkes::SkillerDebugInterface::GD_LEFT_RIGHT);
02133     tolua_constant(tolua_S,"GD_RIGHT_LEFT",fawkes::SkillerDebugInterface::GD_RIGHT_LEFT);
02134     #ifdef __cplusplus
02135     tolua_cclass(tolua_S,"SetGraphMessage","fawkes::SkillerDebugInterface::SetGraphMessage","Message",tolua_collect_fawkes__SkillerDebugInterface__SetGraphMessage);
02136     #else
02137     tolua_cclass(tolua_S,"SetGraphMessage","fawkes::SkillerDebugInterface::SetGraphMessage","Message",NULL);
02138     #endif
02139     tolua_beginmodule(tolua_S,"SetGraphMessage");
02140      tolua_function(tolua_S,"new",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_new00);
02141      tolua_function(tolua_S,"new_local",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_new00_local);
02142      tolua_function(tolua_S,".call",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_new00_local);
02143      tolua_function(tolua_S,"new",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_new01);
02144      tolua_function(tolua_S,"new_local",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_new01_local);
02145      tolua_function(tolua_S,".call",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_new01_local);
02146      tolua_function(tolua_S,"delete",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_delete00);
02147      tolua_function(tolua_S,"graph_fsm",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_graph_fsm00);
02148      tolua_function(tolua_S,"set_graph_fsm",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_set_graph_fsm00);
02149      tolua_function(tolua_S,"maxlenof_graph_fsm",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphMessage_maxlenof_graph_fsm00);
02150     tolua_endmodule(tolua_S);
02151     #ifdef __cplusplus
02152     tolua_cclass(tolua_S,"SetGraphDirectionMessage","fawkes::SkillerDebugInterface::SetGraphDirectionMessage","Message",tolua_collect_fawkes__SkillerDebugInterface__SetGraphDirectionMessage);
02153     #else
02154     tolua_cclass(tolua_S,"SetGraphDirectionMessage","fawkes::SkillerDebugInterface::SetGraphDirectionMessage","Message",NULL);
02155     #endif
02156     tolua_beginmodule(tolua_S,"SetGraphDirectionMessage");
02157      tolua_function(tolua_S,"new",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_new00);
02158      tolua_function(tolua_S,"new_local",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_new00_local);
02159      tolua_function(tolua_S,".call",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_new00_local);
02160      tolua_function(tolua_S,"new",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_new01);
02161      tolua_function(tolua_S,"new_local",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_new01_local);
02162      tolua_function(tolua_S,".call",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_new01_local);
02163      tolua_function(tolua_S,"delete",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_delete00);
02164      tolua_function(tolua_S,"graph_dir",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_graph_dir00);
02165      tolua_function(tolua_S,"set_graph_dir",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_set_graph_dir00);
02166      tolua_function(tolua_S,"maxlenof_graph_dir",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphDirectionMessage_maxlenof_graph_dir00);
02167     tolua_endmodule(tolua_S);
02168     #ifdef __cplusplus
02169     tolua_cclass(tolua_S,"SetGraphColoredMessage","fawkes::SkillerDebugInterface::SetGraphColoredMessage","Message",tolua_collect_fawkes__SkillerDebugInterface__SetGraphColoredMessage);
02170     #else
02171     tolua_cclass(tolua_S,"SetGraphColoredMessage","fawkes::SkillerDebugInterface::SetGraphColoredMessage","Message",NULL);
02172     #endif
02173     tolua_beginmodule(tolua_S,"SetGraphColoredMessage");
02174      tolua_function(tolua_S,"new",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_new00);
02175      tolua_function(tolua_S,"new_local",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_new00_local);
02176      tolua_function(tolua_S,".call",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_new00_local);
02177      tolua_function(tolua_S,"new",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_new01);
02178      tolua_function(tolua_S,"new_local",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_new01_local);
02179      tolua_function(tolua_S,".call",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_new01_local);
02180      tolua_function(tolua_S,"delete",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_delete00);
02181      tolua_function(tolua_S,"is_graph_colored",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_is_graph_colored00);
02182      tolua_function(tolua_S,"set_graph_colored",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_set_graph_colored00);
02183      tolua_function(tolua_S,"maxlenof_graph_colored",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_SetGraphColoredMessage_maxlenof_graph_colored00);
02184     tolua_endmodule(tolua_S);
02185     tolua_function(tolua_S,"graph_fsm",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_graph_fsm00);
02186     tolua_function(tolua_S,"set_graph_fsm",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_set_graph_fsm00);
02187     tolua_function(tolua_S,"maxlenof_graph_fsm",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_maxlenof_graph_fsm00);
02188     tolua_function(tolua_S,"graph",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_graph00);
02189     tolua_function(tolua_S,"set_graph",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_set_graph00);
02190     tolua_function(tolua_S,"maxlenof_graph",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_maxlenof_graph00);
02191     tolua_function(tolua_S,"graph_dir",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_graph_dir00);
02192     tolua_function(tolua_S,"set_graph_dir",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_set_graph_dir00);
02193     tolua_function(tolua_S,"maxlenof_graph_dir",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_maxlenof_graph_dir00);
02194     tolua_function(tolua_S,"is_graph_colored",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_is_graph_colored00);
02195     tolua_function(tolua_S,"set_graph_colored",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_set_graph_colored00);
02196     tolua_function(tolua_S,"maxlenof_graph_colored",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_maxlenof_graph_colored00);
02197     tolua_function(tolua_S,"oftype",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_oftype00);
02198     tolua_function(tolua_S,"datachunk",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_datachunk00);
02199     tolua_function(tolua_S,"datasize",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_datasize00);
02200     tolua_function(tolua_S,"type",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_type00);
02201     tolua_function(tolua_S,"id",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_id00);
02202     tolua_function(tolua_S,"uid",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_uid00);
02203     tolua_function(tolua_S,"serial",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_serial00);
02204     tolua_function(tolua_S,"mem_serial",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_mem_serial00);
02205     tolua_function(tolua_S,".eq",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface__eq00);
02206     tolua_function(tolua_S,"hash",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_hash00);
02207     tolua_function(tolua_S,"hash_size",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_hash_size00);
02208     tolua_function(tolua_S,"hash_printable",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_hash_printable00);
02209     tolua_function(tolua_S,"is_writer",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_is_writer00);
02210     tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_set_from_chunk00);
02211     tolua_function(tolua_S,"create_message",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_create_message00);
02212     tolua_function(tolua_S,"read",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_read00);
02213     tolua_function(tolua_S,"write",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_write00);
02214     tolua_function(tolua_S,"has_writer",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_has_writer00);
02215     tolua_function(tolua_S,"num_readers",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_num_readers00);
02216     tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_enqueue_copy00);
02217     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_remove00);
02218     tolua_function(tolua_S,"msgq_remove",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_remove01);
02219     tolua_function(tolua_S,"msgq_size",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_size00);
02220     tolua_function(tolua_S,"msgq_flush",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_flush00);
02221     tolua_function(tolua_S,"msgq_lock",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_lock00);
02222     tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_try_lock00);
02223     tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_unlock00);
02224     tolua_function(tolua_S,"msgq_pop",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_pop00);
02225     tolua_function(tolua_S,"msgq_first",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_first00);
02226     tolua_function(tolua_S,"msgq_empty",tolua_interfaces_SkillerDebugInterface_fawkes_SkillerDebugInterface_msgq_empty00);
02227    tolua_endmodule(tolua_S);
02228   tolua_endmodule(tolua_S);
02229  tolua_endmodule(tolua_S);
02230  return 1;
02231 }
02232 
02233 
02234 extern "C" {
02235 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
02236  TOLUA_API int luaopen_interfaces_SkillerDebugInterface (lua_State* tolua_S) {
02237  return tolua_interfaces_SkillerDebugInterface_open(tolua_S);
02238 };
02239 #endif
02240 }
02241 
02242