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