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 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
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*) 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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