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