Fawkes API
Fawkes Development Version
|
00001 /* 00002 ** Lua binding: interfaces_SkillerInterface 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_SkillerInterface_open (lua_State* tolua_S); 00028 00029 #include <interfaces/SkillerInterface.h> 00030 using namespace fawkes; 00031 00032 /* function to release collected object via destructor */ 00033 #ifdef __cplusplus 00034 00035 static int tolua_collect_fawkes__SkillerInterface__StopExecMessage (lua_State* tolua_S) 00036 { 00037 fawkes::SkillerInterface::StopExecMessage* self = (fawkes::SkillerInterface::StopExecMessage*) tolua_tousertype(tolua_S,1,0); 00038 Mtolua_delete(self); 00039 return 0; 00040 } 00041 00042 static int tolua_collect_fawkes__SkillerInterface__ExecSkillMessage (lua_State* tolua_S) 00043 { 00044 fawkes::SkillerInterface::ExecSkillMessage* self = (fawkes::SkillerInterface::ExecSkillMessage*) tolua_tousertype(tolua_S,1,0); 00045 Mtolua_delete(self); 00046 return 0; 00047 } 00048 00049 static int tolua_collect_fawkes__SkillerInterface__ExecSkillContinuousMessage (lua_State* tolua_S) 00050 { 00051 fawkes::SkillerInterface::ExecSkillContinuousMessage* self = (fawkes::SkillerInterface::ExecSkillContinuousMessage*) tolua_tousertype(tolua_S,1,0); 00052 Mtolua_delete(self); 00053 return 0; 00054 } 00055 00056 static int tolua_collect_fawkes__SkillerInterface__ReleaseControlMessage (lua_State* tolua_S) 00057 { 00058 fawkes::SkillerInterface::ReleaseControlMessage* self = (fawkes::SkillerInterface::ReleaseControlMessage*) tolua_tousertype(tolua_S,1,0); 00059 Mtolua_delete(self); 00060 return 0; 00061 } 00062 00063 static int tolua_collect_fawkes__SkillerInterface__RestartInterpreterMessage (lua_State* tolua_S) 00064 { 00065 fawkes::SkillerInterface::RestartInterpreterMessage* self = (fawkes::SkillerInterface::RestartInterpreterMessage*) tolua_tousertype(tolua_S,1,0); 00066 Mtolua_delete(self); 00067 return 0; 00068 } 00069 00070 static int tolua_collect_fawkes__SkillerInterface__AcquireControlMessage (lua_State* tolua_S) 00071 { 00072 fawkes::SkillerInterface::AcquireControlMessage* self = (fawkes::SkillerInterface::AcquireControlMessage*) tolua_tousertype(tolua_S,1,0); 00073 Mtolua_delete(self); 00074 return 0; 00075 } 00076 #endif 00077 00078 00079 /* function to register type */ 00080 static void tolua_reg_types (lua_State* tolua_S) 00081 { 00082 tolua_usertype(tolua_S,"fawkes::SkillerInterface::ExecSkillContinuousMessage"); 00083 tolua_usertype(tolua_S,"fawkes::SkillerInterface::RestartInterpreterMessage"); 00084 tolua_usertype(tolua_S,"fawkes::SkillerInterface::StopExecMessage"); 00085 tolua_usertype(tolua_S,"fawkes::SkillerInterface"); 00086 tolua_usertype(tolua_S,"fawkes::SkillerInterface::ExecSkillMessage"); 00087 tolua_usertype(tolua_S,"fawkes::SkillerInterface::ReleaseControlMessage"); 00088 tolua_usertype(tolua_S,"Message"); 00089 tolua_usertype(tolua_S,"fawkes::SkillerInterface::AcquireControlMessage"); 00090 tolua_usertype(tolua_S,"Interface"); 00091 } 00092 00093 /* method: new of class ExecSkillMessage */ 00094 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_new00 00095 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_new00(lua_State* tolua_S) 00096 { 00097 #ifndef TOLUA_RELEASE 00098 tolua_Error tolua_err; 00099 if ( 00100 !tolua_isusertable(tolua_S,1,"fawkes::SkillerInterface::ExecSkillMessage",0,&tolua_err) || 00101 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00102 !tolua_isnoobj(tolua_S,3,&tolua_err) 00103 ) 00104 goto tolua_lerror; 00105 else 00106 #endif 00107 { 00108 char* ini_skill_string = ((char*) tolua_tostring(tolua_S,2,0)); 00109 { 00110 fawkes::SkillerInterface::ExecSkillMessage* tolua_ret = (fawkes::SkillerInterface::ExecSkillMessage*) Mtolua_new((fawkes::SkillerInterface::ExecSkillMessage)(ini_skill_string)); 00111 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerInterface::ExecSkillMessage"); 00112 } 00113 } 00114 return 1; 00115 #ifndef TOLUA_RELEASE 00116 tolua_lerror: 00117 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00118 return 0; 00119 #endif 00120 } 00121 #endif //#ifndef TOLUA_DISABLE 00122 00123 /* method: new_local of class ExecSkillMessage */ 00124 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_new00_local 00125 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_new00_local(lua_State* tolua_S) 00126 { 00127 #ifndef TOLUA_RELEASE 00128 tolua_Error tolua_err; 00129 if ( 00130 !tolua_isusertable(tolua_S,1,"fawkes::SkillerInterface::ExecSkillMessage",0,&tolua_err) || 00131 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00132 !tolua_isnoobj(tolua_S,3,&tolua_err) 00133 ) 00134 goto tolua_lerror; 00135 else 00136 #endif 00137 { 00138 char* ini_skill_string = ((char*) tolua_tostring(tolua_S,2,0)); 00139 { 00140 fawkes::SkillerInterface::ExecSkillMessage* tolua_ret = (fawkes::SkillerInterface::ExecSkillMessage*) Mtolua_new((fawkes::SkillerInterface::ExecSkillMessage)(ini_skill_string)); 00141 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerInterface::ExecSkillMessage"); 00142 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00143 } 00144 } 00145 return 1; 00146 #ifndef TOLUA_RELEASE 00147 tolua_lerror: 00148 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00149 return 0; 00150 #endif 00151 } 00152 #endif //#ifndef TOLUA_DISABLE 00153 00154 /* method: new of class ExecSkillMessage */ 00155 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_new01 00156 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_new01(lua_State* tolua_S) 00157 { 00158 tolua_Error tolua_err; 00159 if ( 00160 !tolua_isusertable(tolua_S,1,"fawkes::SkillerInterface::ExecSkillMessage",0,&tolua_err) || 00161 !tolua_isnoobj(tolua_S,2,&tolua_err) 00162 ) 00163 goto tolua_lerror; 00164 else 00165 { 00166 { 00167 fawkes::SkillerInterface::ExecSkillMessage* tolua_ret = (fawkes::SkillerInterface::ExecSkillMessage*) Mtolua_new((fawkes::SkillerInterface::ExecSkillMessage)()); 00168 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerInterface::ExecSkillMessage"); 00169 } 00170 } 00171 return 1; 00172 tolua_lerror: 00173 return tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_new00(tolua_S); 00174 } 00175 #endif //#ifndef TOLUA_DISABLE 00176 00177 /* method: new_local of class ExecSkillMessage */ 00178 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_new01_local 00179 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_new01_local(lua_State* tolua_S) 00180 { 00181 tolua_Error tolua_err; 00182 if ( 00183 !tolua_isusertable(tolua_S,1,"fawkes::SkillerInterface::ExecSkillMessage",0,&tolua_err) || 00184 !tolua_isnoobj(tolua_S,2,&tolua_err) 00185 ) 00186 goto tolua_lerror; 00187 else 00188 { 00189 { 00190 fawkes::SkillerInterface::ExecSkillMessage* tolua_ret = (fawkes::SkillerInterface::ExecSkillMessage*) Mtolua_new((fawkes::SkillerInterface::ExecSkillMessage)()); 00191 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerInterface::ExecSkillMessage"); 00192 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00193 } 00194 } 00195 return 1; 00196 tolua_lerror: 00197 return tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_new00_local(tolua_S); 00198 } 00199 #endif //#ifndef TOLUA_DISABLE 00200 00201 /* method: delete of class ExecSkillMessage */ 00202 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_delete00 00203 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_delete00(lua_State* tolua_S) 00204 { 00205 #ifndef TOLUA_RELEASE 00206 tolua_Error tolua_err; 00207 if ( 00208 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface::ExecSkillMessage",0,&tolua_err) || 00209 !tolua_isnoobj(tolua_S,2,&tolua_err) 00210 ) 00211 goto tolua_lerror; 00212 else 00213 #endif 00214 { 00215 fawkes::SkillerInterface::ExecSkillMessage* self = (fawkes::SkillerInterface::ExecSkillMessage*) tolua_tousertype(tolua_S,1,0); 00216 #ifndef TOLUA_RELEASE 00217 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00218 #endif 00219 Mtolua_delete(self); 00220 } 00221 return 0; 00222 #ifndef TOLUA_RELEASE 00223 tolua_lerror: 00224 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00225 return 0; 00226 #endif 00227 } 00228 #endif //#ifndef TOLUA_DISABLE 00229 00230 /* method: skill_string of class ExecSkillMessage */ 00231 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_skill_string00 00232 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_skill_string00(lua_State* tolua_S) 00233 { 00234 #ifndef TOLUA_RELEASE 00235 tolua_Error tolua_err; 00236 if ( 00237 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface::ExecSkillMessage",0,&tolua_err) || 00238 !tolua_isnoobj(tolua_S,2,&tolua_err) 00239 ) 00240 goto tolua_lerror; 00241 else 00242 #endif 00243 { 00244 fawkes::SkillerInterface::ExecSkillMessage* self = (fawkes::SkillerInterface::ExecSkillMessage*) tolua_tousertype(tolua_S,1,0); 00245 #ifndef TOLUA_RELEASE 00246 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'skill_string'", NULL); 00247 #endif 00248 { 00249 char* tolua_ret = (char*) self->skill_string(); 00250 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00251 } 00252 } 00253 return 1; 00254 #ifndef TOLUA_RELEASE 00255 tolua_lerror: 00256 tolua_error(tolua_S,"#ferror in function 'skill_string'.",&tolua_err); 00257 return 0; 00258 #endif 00259 } 00260 #endif //#ifndef TOLUA_DISABLE 00261 00262 /* method: set_skill_string of class ExecSkillMessage */ 00263 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_set_skill_string00 00264 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_set_skill_string00(lua_State* tolua_S) 00265 { 00266 #ifndef TOLUA_RELEASE 00267 tolua_Error tolua_err; 00268 if ( 00269 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface::ExecSkillMessage",0,&tolua_err) || 00270 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00271 !tolua_isnoobj(tolua_S,3,&tolua_err) 00272 ) 00273 goto tolua_lerror; 00274 else 00275 #endif 00276 { 00277 fawkes::SkillerInterface::ExecSkillMessage* self = (fawkes::SkillerInterface::ExecSkillMessage*) tolua_tousertype(tolua_S,1,0); 00278 const char* new_skill_string = ((const char*) tolua_tostring(tolua_S,2,0)); 00279 #ifndef TOLUA_RELEASE 00280 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_skill_string'", NULL); 00281 #endif 00282 { 00283 self->set_skill_string(new_skill_string); 00284 } 00285 } 00286 return 0; 00287 #ifndef TOLUA_RELEASE 00288 tolua_lerror: 00289 tolua_error(tolua_S,"#ferror in function 'set_skill_string'.",&tolua_err); 00290 return 0; 00291 #endif 00292 } 00293 #endif //#ifndef TOLUA_DISABLE 00294 00295 /* method: maxlenof_skill_string of class ExecSkillMessage */ 00296 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_maxlenof_skill_string00 00297 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_maxlenof_skill_string00(lua_State* tolua_S) 00298 { 00299 #ifndef TOLUA_RELEASE 00300 tolua_Error tolua_err; 00301 if ( 00302 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface::ExecSkillMessage",0,&tolua_err) || 00303 !tolua_isnoobj(tolua_S,2,&tolua_err) 00304 ) 00305 goto tolua_lerror; 00306 else 00307 #endif 00308 { 00309 const fawkes::SkillerInterface::ExecSkillMessage* self = (const fawkes::SkillerInterface::ExecSkillMessage*) tolua_tousertype(tolua_S,1,0); 00310 #ifndef TOLUA_RELEASE 00311 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_skill_string'", NULL); 00312 #endif 00313 { 00314 int tolua_ret = (int) self->maxlenof_skill_string(); 00315 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00316 } 00317 } 00318 return 1; 00319 #ifndef TOLUA_RELEASE 00320 tolua_lerror: 00321 tolua_error(tolua_S,"#ferror in function 'maxlenof_skill_string'.",&tolua_err); 00322 return 0; 00323 #endif 00324 } 00325 #endif //#ifndef TOLUA_DISABLE 00326 00327 /* method: new of class ExecSkillContinuousMessage */ 00328 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_new00 00329 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_new00(lua_State* tolua_S) 00330 { 00331 #ifndef TOLUA_RELEASE 00332 tolua_Error tolua_err; 00333 if ( 00334 !tolua_isusertable(tolua_S,1,"fawkes::SkillerInterface::ExecSkillContinuousMessage",0,&tolua_err) || 00335 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00336 !tolua_isnoobj(tolua_S,3,&tolua_err) 00337 ) 00338 goto tolua_lerror; 00339 else 00340 #endif 00341 { 00342 char* ini_skill_string = ((char*) tolua_tostring(tolua_S,2,0)); 00343 { 00344 fawkes::SkillerInterface::ExecSkillContinuousMessage* tolua_ret = (fawkes::SkillerInterface::ExecSkillContinuousMessage*) Mtolua_new((fawkes::SkillerInterface::ExecSkillContinuousMessage)(ini_skill_string)); 00345 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerInterface::ExecSkillContinuousMessage"); 00346 } 00347 } 00348 return 1; 00349 #ifndef TOLUA_RELEASE 00350 tolua_lerror: 00351 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00352 return 0; 00353 #endif 00354 } 00355 #endif //#ifndef TOLUA_DISABLE 00356 00357 /* method: new_local of class ExecSkillContinuousMessage */ 00358 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_new00_local 00359 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_new00_local(lua_State* tolua_S) 00360 { 00361 #ifndef TOLUA_RELEASE 00362 tolua_Error tolua_err; 00363 if ( 00364 !tolua_isusertable(tolua_S,1,"fawkes::SkillerInterface::ExecSkillContinuousMessage",0,&tolua_err) || 00365 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00366 !tolua_isnoobj(tolua_S,3,&tolua_err) 00367 ) 00368 goto tolua_lerror; 00369 else 00370 #endif 00371 { 00372 char* ini_skill_string = ((char*) tolua_tostring(tolua_S,2,0)); 00373 { 00374 fawkes::SkillerInterface::ExecSkillContinuousMessage* tolua_ret = (fawkes::SkillerInterface::ExecSkillContinuousMessage*) Mtolua_new((fawkes::SkillerInterface::ExecSkillContinuousMessage)(ini_skill_string)); 00375 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerInterface::ExecSkillContinuousMessage"); 00376 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00377 } 00378 } 00379 return 1; 00380 #ifndef TOLUA_RELEASE 00381 tolua_lerror: 00382 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00383 return 0; 00384 #endif 00385 } 00386 #endif //#ifndef TOLUA_DISABLE 00387 00388 /* method: new of class ExecSkillContinuousMessage */ 00389 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_new01 00390 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_new01(lua_State* tolua_S) 00391 { 00392 tolua_Error tolua_err; 00393 if ( 00394 !tolua_isusertable(tolua_S,1,"fawkes::SkillerInterface::ExecSkillContinuousMessage",0,&tolua_err) || 00395 !tolua_isnoobj(tolua_S,2,&tolua_err) 00396 ) 00397 goto tolua_lerror; 00398 else 00399 { 00400 { 00401 fawkes::SkillerInterface::ExecSkillContinuousMessage* tolua_ret = (fawkes::SkillerInterface::ExecSkillContinuousMessage*) Mtolua_new((fawkes::SkillerInterface::ExecSkillContinuousMessage)()); 00402 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerInterface::ExecSkillContinuousMessage"); 00403 } 00404 } 00405 return 1; 00406 tolua_lerror: 00407 return tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_new00(tolua_S); 00408 } 00409 #endif //#ifndef TOLUA_DISABLE 00410 00411 /* method: new_local of class ExecSkillContinuousMessage */ 00412 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_new01_local 00413 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_new01_local(lua_State* tolua_S) 00414 { 00415 tolua_Error tolua_err; 00416 if ( 00417 !tolua_isusertable(tolua_S,1,"fawkes::SkillerInterface::ExecSkillContinuousMessage",0,&tolua_err) || 00418 !tolua_isnoobj(tolua_S,2,&tolua_err) 00419 ) 00420 goto tolua_lerror; 00421 else 00422 { 00423 { 00424 fawkes::SkillerInterface::ExecSkillContinuousMessage* tolua_ret = (fawkes::SkillerInterface::ExecSkillContinuousMessage*) Mtolua_new((fawkes::SkillerInterface::ExecSkillContinuousMessage)()); 00425 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerInterface::ExecSkillContinuousMessage"); 00426 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00427 } 00428 } 00429 return 1; 00430 tolua_lerror: 00431 return tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_new00_local(tolua_S); 00432 } 00433 #endif //#ifndef TOLUA_DISABLE 00434 00435 /* method: delete of class ExecSkillContinuousMessage */ 00436 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_delete00 00437 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_delete00(lua_State* tolua_S) 00438 { 00439 #ifndef TOLUA_RELEASE 00440 tolua_Error tolua_err; 00441 if ( 00442 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface::ExecSkillContinuousMessage",0,&tolua_err) || 00443 !tolua_isnoobj(tolua_S,2,&tolua_err) 00444 ) 00445 goto tolua_lerror; 00446 else 00447 #endif 00448 { 00449 fawkes::SkillerInterface::ExecSkillContinuousMessage* self = (fawkes::SkillerInterface::ExecSkillContinuousMessage*) tolua_tousertype(tolua_S,1,0); 00450 #ifndef TOLUA_RELEASE 00451 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00452 #endif 00453 Mtolua_delete(self); 00454 } 00455 return 0; 00456 #ifndef TOLUA_RELEASE 00457 tolua_lerror: 00458 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00459 return 0; 00460 #endif 00461 } 00462 #endif //#ifndef TOLUA_DISABLE 00463 00464 /* method: skill_string of class ExecSkillContinuousMessage */ 00465 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_skill_string00 00466 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_skill_string00(lua_State* tolua_S) 00467 { 00468 #ifndef TOLUA_RELEASE 00469 tolua_Error tolua_err; 00470 if ( 00471 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface::ExecSkillContinuousMessage",0,&tolua_err) || 00472 !tolua_isnoobj(tolua_S,2,&tolua_err) 00473 ) 00474 goto tolua_lerror; 00475 else 00476 #endif 00477 { 00478 fawkes::SkillerInterface::ExecSkillContinuousMessage* self = (fawkes::SkillerInterface::ExecSkillContinuousMessage*) tolua_tousertype(tolua_S,1,0); 00479 #ifndef TOLUA_RELEASE 00480 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'skill_string'", NULL); 00481 #endif 00482 { 00483 char* tolua_ret = (char*) self->skill_string(); 00484 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00485 } 00486 } 00487 return 1; 00488 #ifndef TOLUA_RELEASE 00489 tolua_lerror: 00490 tolua_error(tolua_S,"#ferror in function 'skill_string'.",&tolua_err); 00491 return 0; 00492 #endif 00493 } 00494 #endif //#ifndef TOLUA_DISABLE 00495 00496 /* method: set_skill_string of class ExecSkillContinuousMessage */ 00497 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_set_skill_string00 00498 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_set_skill_string00(lua_State* tolua_S) 00499 { 00500 #ifndef TOLUA_RELEASE 00501 tolua_Error tolua_err; 00502 if ( 00503 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface::ExecSkillContinuousMessage",0,&tolua_err) || 00504 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00505 !tolua_isnoobj(tolua_S,3,&tolua_err) 00506 ) 00507 goto tolua_lerror; 00508 else 00509 #endif 00510 { 00511 fawkes::SkillerInterface::ExecSkillContinuousMessage* self = (fawkes::SkillerInterface::ExecSkillContinuousMessage*) tolua_tousertype(tolua_S,1,0); 00512 const char* new_skill_string = ((const char*) tolua_tostring(tolua_S,2,0)); 00513 #ifndef TOLUA_RELEASE 00514 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_skill_string'", NULL); 00515 #endif 00516 { 00517 self->set_skill_string(new_skill_string); 00518 } 00519 } 00520 return 0; 00521 #ifndef TOLUA_RELEASE 00522 tolua_lerror: 00523 tolua_error(tolua_S,"#ferror in function 'set_skill_string'.",&tolua_err); 00524 return 0; 00525 #endif 00526 } 00527 #endif //#ifndef TOLUA_DISABLE 00528 00529 /* method: maxlenof_skill_string of class ExecSkillContinuousMessage */ 00530 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_maxlenof_skill_string00 00531 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_maxlenof_skill_string00(lua_State* tolua_S) 00532 { 00533 #ifndef TOLUA_RELEASE 00534 tolua_Error tolua_err; 00535 if ( 00536 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface::ExecSkillContinuousMessage",0,&tolua_err) || 00537 !tolua_isnoobj(tolua_S,2,&tolua_err) 00538 ) 00539 goto tolua_lerror; 00540 else 00541 #endif 00542 { 00543 const fawkes::SkillerInterface::ExecSkillContinuousMessage* self = (const fawkes::SkillerInterface::ExecSkillContinuousMessage*) tolua_tousertype(tolua_S,1,0); 00544 #ifndef TOLUA_RELEASE 00545 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_skill_string'", NULL); 00546 #endif 00547 { 00548 int tolua_ret = (int) self->maxlenof_skill_string(); 00549 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00550 } 00551 } 00552 return 1; 00553 #ifndef TOLUA_RELEASE 00554 tolua_lerror: 00555 tolua_error(tolua_S,"#ferror in function 'maxlenof_skill_string'.",&tolua_err); 00556 return 0; 00557 #endif 00558 } 00559 #endif //#ifndef TOLUA_DISABLE 00560 00561 /* method: new of class RestartInterpreterMessage */ 00562 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_RestartInterpreterMessage_new00 00563 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_RestartInterpreterMessage_new00(lua_State* tolua_S) 00564 { 00565 #ifndef TOLUA_RELEASE 00566 tolua_Error tolua_err; 00567 if ( 00568 !tolua_isusertable(tolua_S,1,"fawkes::SkillerInterface::RestartInterpreterMessage",0,&tolua_err) || 00569 !tolua_isnoobj(tolua_S,2,&tolua_err) 00570 ) 00571 goto tolua_lerror; 00572 else 00573 #endif 00574 { 00575 { 00576 fawkes::SkillerInterface::RestartInterpreterMessage* tolua_ret = (fawkes::SkillerInterface::RestartInterpreterMessage*) Mtolua_new((fawkes::SkillerInterface::RestartInterpreterMessage)()); 00577 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerInterface::RestartInterpreterMessage"); 00578 } 00579 } 00580 return 1; 00581 #ifndef TOLUA_RELEASE 00582 tolua_lerror: 00583 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00584 return 0; 00585 #endif 00586 } 00587 #endif //#ifndef TOLUA_DISABLE 00588 00589 /* method: new_local of class RestartInterpreterMessage */ 00590 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_RestartInterpreterMessage_new00_local 00591 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_RestartInterpreterMessage_new00_local(lua_State* tolua_S) 00592 { 00593 #ifndef TOLUA_RELEASE 00594 tolua_Error tolua_err; 00595 if ( 00596 !tolua_isusertable(tolua_S,1,"fawkes::SkillerInterface::RestartInterpreterMessage",0,&tolua_err) || 00597 !tolua_isnoobj(tolua_S,2,&tolua_err) 00598 ) 00599 goto tolua_lerror; 00600 else 00601 #endif 00602 { 00603 { 00604 fawkes::SkillerInterface::RestartInterpreterMessage* tolua_ret = (fawkes::SkillerInterface::RestartInterpreterMessage*) Mtolua_new((fawkes::SkillerInterface::RestartInterpreterMessage)()); 00605 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerInterface::RestartInterpreterMessage"); 00606 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00607 } 00608 } 00609 return 1; 00610 #ifndef TOLUA_RELEASE 00611 tolua_lerror: 00612 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00613 return 0; 00614 #endif 00615 } 00616 #endif //#ifndef TOLUA_DISABLE 00617 00618 /* method: delete of class RestartInterpreterMessage */ 00619 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_RestartInterpreterMessage_delete00 00620 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_RestartInterpreterMessage_delete00(lua_State* tolua_S) 00621 { 00622 #ifndef TOLUA_RELEASE 00623 tolua_Error tolua_err; 00624 if ( 00625 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface::RestartInterpreterMessage",0,&tolua_err) || 00626 !tolua_isnoobj(tolua_S,2,&tolua_err) 00627 ) 00628 goto tolua_lerror; 00629 else 00630 #endif 00631 { 00632 fawkes::SkillerInterface::RestartInterpreterMessage* self = (fawkes::SkillerInterface::RestartInterpreterMessage*) tolua_tousertype(tolua_S,1,0); 00633 #ifndef TOLUA_RELEASE 00634 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00635 #endif 00636 Mtolua_delete(self); 00637 } 00638 return 0; 00639 #ifndef TOLUA_RELEASE 00640 tolua_lerror: 00641 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00642 return 0; 00643 #endif 00644 } 00645 #endif //#ifndef TOLUA_DISABLE 00646 00647 /* method: new of class StopExecMessage */ 00648 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_StopExecMessage_new00 00649 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_StopExecMessage_new00(lua_State* tolua_S) 00650 { 00651 #ifndef TOLUA_RELEASE 00652 tolua_Error tolua_err; 00653 if ( 00654 !tolua_isusertable(tolua_S,1,"fawkes::SkillerInterface::StopExecMessage",0,&tolua_err) || 00655 !tolua_isnoobj(tolua_S,2,&tolua_err) 00656 ) 00657 goto tolua_lerror; 00658 else 00659 #endif 00660 { 00661 { 00662 fawkes::SkillerInterface::StopExecMessage* tolua_ret = (fawkes::SkillerInterface::StopExecMessage*) Mtolua_new((fawkes::SkillerInterface::StopExecMessage)()); 00663 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerInterface::StopExecMessage"); 00664 } 00665 } 00666 return 1; 00667 #ifndef TOLUA_RELEASE 00668 tolua_lerror: 00669 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00670 return 0; 00671 #endif 00672 } 00673 #endif //#ifndef TOLUA_DISABLE 00674 00675 /* method: new_local of class StopExecMessage */ 00676 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_StopExecMessage_new00_local 00677 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_StopExecMessage_new00_local(lua_State* tolua_S) 00678 { 00679 #ifndef TOLUA_RELEASE 00680 tolua_Error tolua_err; 00681 if ( 00682 !tolua_isusertable(tolua_S,1,"fawkes::SkillerInterface::StopExecMessage",0,&tolua_err) || 00683 !tolua_isnoobj(tolua_S,2,&tolua_err) 00684 ) 00685 goto tolua_lerror; 00686 else 00687 #endif 00688 { 00689 { 00690 fawkes::SkillerInterface::StopExecMessage* tolua_ret = (fawkes::SkillerInterface::StopExecMessage*) Mtolua_new((fawkes::SkillerInterface::StopExecMessage)()); 00691 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerInterface::StopExecMessage"); 00692 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00693 } 00694 } 00695 return 1; 00696 #ifndef TOLUA_RELEASE 00697 tolua_lerror: 00698 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00699 return 0; 00700 #endif 00701 } 00702 #endif //#ifndef TOLUA_DISABLE 00703 00704 /* method: delete of class StopExecMessage */ 00705 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_StopExecMessage_delete00 00706 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_StopExecMessage_delete00(lua_State* tolua_S) 00707 { 00708 #ifndef TOLUA_RELEASE 00709 tolua_Error tolua_err; 00710 if ( 00711 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface::StopExecMessage",0,&tolua_err) || 00712 !tolua_isnoobj(tolua_S,2,&tolua_err) 00713 ) 00714 goto tolua_lerror; 00715 else 00716 #endif 00717 { 00718 fawkes::SkillerInterface::StopExecMessage* self = (fawkes::SkillerInterface::StopExecMessage*) tolua_tousertype(tolua_S,1,0); 00719 #ifndef TOLUA_RELEASE 00720 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00721 #endif 00722 Mtolua_delete(self); 00723 } 00724 return 0; 00725 #ifndef TOLUA_RELEASE 00726 tolua_lerror: 00727 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00728 return 0; 00729 #endif 00730 } 00731 #endif //#ifndef TOLUA_DISABLE 00732 00733 /* method: new of class AcquireControlMessage */ 00734 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_AcquireControlMessage_new00 00735 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_AcquireControlMessage_new00(lua_State* tolua_S) 00736 { 00737 #ifndef TOLUA_RELEASE 00738 tolua_Error tolua_err; 00739 if ( 00740 !tolua_isusertable(tolua_S,1,"fawkes::SkillerInterface::AcquireControlMessage",0,&tolua_err) || 00741 !tolua_isnoobj(tolua_S,2,&tolua_err) 00742 ) 00743 goto tolua_lerror; 00744 else 00745 #endif 00746 { 00747 { 00748 fawkes::SkillerInterface::AcquireControlMessage* tolua_ret = (fawkes::SkillerInterface::AcquireControlMessage*) Mtolua_new((fawkes::SkillerInterface::AcquireControlMessage)()); 00749 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerInterface::AcquireControlMessage"); 00750 } 00751 } 00752 return 1; 00753 #ifndef TOLUA_RELEASE 00754 tolua_lerror: 00755 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00756 return 0; 00757 #endif 00758 } 00759 #endif //#ifndef TOLUA_DISABLE 00760 00761 /* method: new_local of class AcquireControlMessage */ 00762 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_AcquireControlMessage_new00_local 00763 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_AcquireControlMessage_new00_local(lua_State* tolua_S) 00764 { 00765 #ifndef TOLUA_RELEASE 00766 tolua_Error tolua_err; 00767 if ( 00768 !tolua_isusertable(tolua_S,1,"fawkes::SkillerInterface::AcquireControlMessage",0,&tolua_err) || 00769 !tolua_isnoobj(tolua_S,2,&tolua_err) 00770 ) 00771 goto tolua_lerror; 00772 else 00773 #endif 00774 { 00775 { 00776 fawkes::SkillerInterface::AcquireControlMessage* tolua_ret = (fawkes::SkillerInterface::AcquireControlMessage*) Mtolua_new((fawkes::SkillerInterface::AcquireControlMessage)()); 00777 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerInterface::AcquireControlMessage"); 00778 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00779 } 00780 } 00781 return 1; 00782 #ifndef TOLUA_RELEASE 00783 tolua_lerror: 00784 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00785 return 0; 00786 #endif 00787 } 00788 #endif //#ifndef TOLUA_DISABLE 00789 00790 /* method: delete of class AcquireControlMessage */ 00791 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_AcquireControlMessage_delete00 00792 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_AcquireControlMessage_delete00(lua_State* tolua_S) 00793 { 00794 #ifndef TOLUA_RELEASE 00795 tolua_Error tolua_err; 00796 if ( 00797 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface::AcquireControlMessage",0,&tolua_err) || 00798 !tolua_isnoobj(tolua_S,2,&tolua_err) 00799 ) 00800 goto tolua_lerror; 00801 else 00802 #endif 00803 { 00804 fawkes::SkillerInterface::AcquireControlMessage* self = (fawkes::SkillerInterface::AcquireControlMessage*) tolua_tousertype(tolua_S,1,0); 00805 #ifndef TOLUA_RELEASE 00806 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00807 #endif 00808 Mtolua_delete(self); 00809 } 00810 return 0; 00811 #ifndef TOLUA_RELEASE 00812 tolua_lerror: 00813 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00814 return 0; 00815 #endif 00816 } 00817 #endif //#ifndef TOLUA_DISABLE 00818 00819 /* method: new of class ReleaseControlMessage */ 00820 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ReleaseControlMessage_new00 00821 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ReleaseControlMessage_new00(lua_State* tolua_S) 00822 { 00823 #ifndef TOLUA_RELEASE 00824 tolua_Error tolua_err; 00825 if ( 00826 !tolua_isusertable(tolua_S,1,"fawkes::SkillerInterface::ReleaseControlMessage",0,&tolua_err) || 00827 !tolua_isnoobj(tolua_S,2,&tolua_err) 00828 ) 00829 goto tolua_lerror; 00830 else 00831 #endif 00832 { 00833 { 00834 fawkes::SkillerInterface::ReleaseControlMessage* tolua_ret = (fawkes::SkillerInterface::ReleaseControlMessage*) Mtolua_new((fawkes::SkillerInterface::ReleaseControlMessage)()); 00835 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerInterface::ReleaseControlMessage"); 00836 } 00837 } 00838 return 1; 00839 #ifndef TOLUA_RELEASE 00840 tolua_lerror: 00841 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00842 return 0; 00843 #endif 00844 } 00845 #endif //#ifndef TOLUA_DISABLE 00846 00847 /* method: new_local of class ReleaseControlMessage */ 00848 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ReleaseControlMessage_new00_local 00849 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ReleaseControlMessage_new00_local(lua_State* tolua_S) 00850 { 00851 #ifndef TOLUA_RELEASE 00852 tolua_Error tolua_err; 00853 if ( 00854 !tolua_isusertable(tolua_S,1,"fawkes::SkillerInterface::ReleaseControlMessage",0,&tolua_err) || 00855 !tolua_isnoobj(tolua_S,2,&tolua_err) 00856 ) 00857 goto tolua_lerror; 00858 else 00859 #endif 00860 { 00861 { 00862 fawkes::SkillerInterface::ReleaseControlMessage* tolua_ret = (fawkes::SkillerInterface::ReleaseControlMessage*) Mtolua_new((fawkes::SkillerInterface::ReleaseControlMessage)()); 00863 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SkillerInterface::ReleaseControlMessage"); 00864 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00865 } 00866 } 00867 return 1; 00868 #ifndef TOLUA_RELEASE 00869 tolua_lerror: 00870 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00871 return 0; 00872 #endif 00873 } 00874 #endif //#ifndef TOLUA_DISABLE 00875 00876 /* method: delete of class ReleaseControlMessage */ 00877 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ReleaseControlMessage_delete00 00878 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ReleaseControlMessage_delete00(lua_State* tolua_S) 00879 { 00880 #ifndef TOLUA_RELEASE 00881 tolua_Error tolua_err; 00882 if ( 00883 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface::ReleaseControlMessage",0,&tolua_err) || 00884 !tolua_isnoobj(tolua_S,2,&tolua_err) 00885 ) 00886 goto tolua_lerror; 00887 else 00888 #endif 00889 { 00890 fawkes::SkillerInterface::ReleaseControlMessage* self = (fawkes::SkillerInterface::ReleaseControlMessage*) tolua_tousertype(tolua_S,1,0); 00891 #ifndef TOLUA_RELEASE 00892 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00893 #endif 00894 Mtolua_delete(self); 00895 } 00896 return 0; 00897 #ifndef TOLUA_RELEASE 00898 tolua_lerror: 00899 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00900 return 0; 00901 #endif 00902 } 00903 #endif //#ifndef TOLUA_DISABLE 00904 00905 /* method: skill_string of class fawkes::SkillerInterface */ 00906 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_skill_string00 00907 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_skill_string00(lua_State* tolua_S) 00908 { 00909 #ifndef TOLUA_RELEASE 00910 tolua_Error tolua_err; 00911 if ( 00912 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 00913 !tolua_isnoobj(tolua_S,2,&tolua_err) 00914 ) 00915 goto tolua_lerror; 00916 else 00917 #endif 00918 { 00919 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 00920 #ifndef TOLUA_RELEASE 00921 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'skill_string'", NULL); 00922 #endif 00923 { 00924 char* tolua_ret = (char*) self->skill_string(); 00925 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00926 } 00927 } 00928 return 1; 00929 #ifndef TOLUA_RELEASE 00930 tolua_lerror: 00931 tolua_error(tolua_S,"#ferror in function 'skill_string'.",&tolua_err); 00932 return 0; 00933 #endif 00934 } 00935 #endif //#ifndef TOLUA_DISABLE 00936 00937 /* method: set_skill_string of class fawkes::SkillerInterface */ 00938 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_skill_string00 00939 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_skill_string00(lua_State* tolua_S) 00940 { 00941 #ifndef TOLUA_RELEASE 00942 tolua_Error tolua_err; 00943 if ( 00944 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 00945 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00946 !tolua_isnoobj(tolua_S,3,&tolua_err) 00947 ) 00948 goto tolua_lerror; 00949 else 00950 #endif 00951 { 00952 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 00953 const char* new_skill_string = ((const char*) tolua_tostring(tolua_S,2,0)); 00954 #ifndef TOLUA_RELEASE 00955 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_skill_string'", NULL); 00956 #endif 00957 { 00958 self->set_skill_string(new_skill_string); 00959 } 00960 } 00961 return 0; 00962 #ifndef TOLUA_RELEASE 00963 tolua_lerror: 00964 tolua_error(tolua_S,"#ferror in function 'set_skill_string'.",&tolua_err); 00965 return 0; 00966 #endif 00967 } 00968 #endif //#ifndef TOLUA_DISABLE 00969 00970 /* method: maxlenof_skill_string of class fawkes::SkillerInterface */ 00971 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_maxlenof_skill_string00 00972 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_maxlenof_skill_string00(lua_State* tolua_S) 00973 { 00974 #ifndef TOLUA_RELEASE 00975 tolua_Error tolua_err; 00976 if ( 00977 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 00978 !tolua_isnoobj(tolua_S,2,&tolua_err) 00979 ) 00980 goto tolua_lerror; 00981 else 00982 #endif 00983 { 00984 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 00985 #ifndef TOLUA_RELEASE 00986 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_skill_string'", NULL); 00987 #endif 00988 { 00989 int tolua_ret = (int) self->maxlenof_skill_string(); 00990 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00991 } 00992 } 00993 return 1; 00994 #ifndef TOLUA_RELEASE 00995 tolua_lerror: 00996 tolua_error(tolua_S,"#ferror in function 'maxlenof_skill_string'.",&tolua_err); 00997 return 0; 00998 #endif 00999 } 01000 #endif //#ifndef TOLUA_DISABLE 01001 01002 /* method: error of class fawkes::SkillerInterface */ 01003 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_error00 01004 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_error00(lua_State* tolua_S) 01005 { 01006 #ifndef TOLUA_RELEASE 01007 tolua_Error tolua_err; 01008 if ( 01009 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 01010 !tolua_isnoobj(tolua_S,2,&tolua_err) 01011 ) 01012 goto tolua_lerror; 01013 else 01014 #endif 01015 { 01016 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01017 #ifndef TOLUA_RELEASE 01018 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'error'", NULL); 01019 #endif 01020 { 01021 char* tolua_ret = (char*) self->error(); 01022 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01023 } 01024 } 01025 return 1; 01026 #ifndef TOLUA_RELEASE 01027 tolua_lerror: 01028 tolua_error(tolua_S,"#ferror in function 'error'.",&tolua_err); 01029 return 0; 01030 #endif 01031 } 01032 #endif //#ifndef TOLUA_DISABLE 01033 01034 /* method: set_error of class fawkes::SkillerInterface */ 01035 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_error00 01036 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_error00(lua_State* tolua_S) 01037 { 01038 #ifndef TOLUA_RELEASE 01039 tolua_Error tolua_err; 01040 if ( 01041 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 01042 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01043 !tolua_isnoobj(tolua_S,3,&tolua_err) 01044 ) 01045 goto tolua_lerror; 01046 else 01047 #endif 01048 { 01049 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01050 const char* new_error = ((const char*) tolua_tostring(tolua_S,2,0)); 01051 #ifndef TOLUA_RELEASE 01052 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_error'", NULL); 01053 #endif 01054 { 01055 self->set_error(new_error); 01056 } 01057 } 01058 return 0; 01059 #ifndef TOLUA_RELEASE 01060 tolua_lerror: 01061 tolua_error(tolua_S,"#ferror in function 'set_error'.",&tolua_err); 01062 return 0; 01063 #endif 01064 } 01065 #endif //#ifndef TOLUA_DISABLE 01066 01067 /* method: maxlenof_error of class fawkes::SkillerInterface */ 01068 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_maxlenof_error00 01069 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_maxlenof_error00(lua_State* tolua_S) 01070 { 01071 #ifndef TOLUA_RELEASE 01072 tolua_Error tolua_err; 01073 if ( 01074 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01075 !tolua_isnoobj(tolua_S,2,&tolua_err) 01076 ) 01077 goto tolua_lerror; 01078 else 01079 #endif 01080 { 01081 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01082 #ifndef TOLUA_RELEASE 01083 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_error'", NULL); 01084 #endif 01085 { 01086 int tolua_ret = (int) self->maxlenof_error(); 01087 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01088 } 01089 } 01090 return 1; 01091 #ifndef TOLUA_RELEASE 01092 tolua_lerror: 01093 tolua_error(tolua_S,"#ferror in function 'maxlenof_error'.",&tolua_err); 01094 return 0; 01095 #endif 01096 } 01097 #endif //#ifndef TOLUA_DISABLE 01098 01099 /* method: exclusive_controller of class fawkes::SkillerInterface */ 01100 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_exclusive_controller00 01101 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_exclusive_controller00(lua_State* tolua_S) 01102 { 01103 #ifndef TOLUA_RELEASE 01104 tolua_Error tolua_err; 01105 if ( 01106 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 01107 !tolua_isnoobj(tolua_S,2,&tolua_err) 01108 ) 01109 goto tolua_lerror; 01110 else 01111 #endif 01112 { 01113 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01114 #ifndef TOLUA_RELEASE 01115 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'exclusive_controller'", NULL); 01116 #endif 01117 { 01118 unsigned int tolua_ret = (unsigned int) self->exclusive_controller(); 01119 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01120 } 01121 } 01122 return 1; 01123 #ifndef TOLUA_RELEASE 01124 tolua_lerror: 01125 tolua_error(tolua_S,"#ferror in function 'exclusive_controller'.",&tolua_err); 01126 return 0; 01127 #endif 01128 } 01129 #endif //#ifndef TOLUA_DISABLE 01130 01131 /* method: set_exclusive_controller of class fawkes::SkillerInterface */ 01132 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_exclusive_controller00 01133 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_exclusive_controller00(lua_State* tolua_S) 01134 { 01135 #ifndef TOLUA_RELEASE 01136 tolua_Error tolua_err; 01137 if ( 01138 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 01139 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01140 !tolua_isnoobj(tolua_S,3,&tolua_err) 01141 ) 01142 goto tolua_lerror; 01143 else 01144 #endif 01145 { 01146 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01147 unsigned const int new_exclusive_controller = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 01148 #ifndef TOLUA_RELEASE 01149 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_exclusive_controller'", NULL); 01150 #endif 01151 { 01152 self->set_exclusive_controller(new_exclusive_controller); 01153 } 01154 } 01155 return 0; 01156 #ifndef TOLUA_RELEASE 01157 tolua_lerror: 01158 tolua_error(tolua_S,"#ferror in function 'set_exclusive_controller'.",&tolua_err); 01159 return 0; 01160 #endif 01161 } 01162 #endif //#ifndef TOLUA_DISABLE 01163 01164 /* method: maxlenof_exclusive_controller of class fawkes::SkillerInterface */ 01165 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_maxlenof_exclusive_controller00 01166 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_maxlenof_exclusive_controller00(lua_State* tolua_S) 01167 { 01168 #ifndef TOLUA_RELEASE 01169 tolua_Error tolua_err; 01170 if ( 01171 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01172 !tolua_isnoobj(tolua_S,2,&tolua_err) 01173 ) 01174 goto tolua_lerror; 01175 else 01176 #endif 01177 { 01178 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01179 #ifndef TOLUA_RELEASE 01180 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_exclusive_controller'", NULL); 01181 #endif 01182 { 01183 int tolua_ret = (int) self->maxlenof_exclusive_controller(); 01184 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01185 } 01186 } 01187 return 1; 01188 #ifndef TOLUA_RELEASE 01189 tolua_lerror: 01190 tolua_error(tolua_S,"#ferror in function 'maxlenof_exclusive_controller'.",&tolua_err); 01191 return 0; 01192 #endif 01193 } 01194 #endif //#ifndef TOLUA_DISABLE 01195 01196 /* method: status of class fawkes::SkillerInterface */ 01197 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_status00 01198 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_status00(lua_State* tolua_S) 01199 { 01200 #ifndef TOLUA_RELEASE 01201 tolua_Error tolua_err; 01202 if ( 01203 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 01204 !tolua_isnoobj(tolua_S,2,&tolua_err) 01205 ) 01206 goto tolua_lerror; 01207 else 01208 #endif 01209 { 01210 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01211 #ifndef TOLUA_RELEASE 01212 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'status'", NULL); 01213 #endif 01214 { 01215 fawkes::SkillerInterface::SkillStatusEnum tolua_ret = (fawkes::SkillerInterface::SkillStatusEnum) self->status(); 01216 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01217 } 01218 } 01219 return 1; 01220 #ifndef TOLUA_RELEASE 01221 tolua_lerror: 01222 tolua_error(tolua_S,"#ferror in function 'status'.",&tolua_err); 01223 return 0; 01224 #endif 01225 } 01226 #endif //#ifndef TOLUA_DISABLE 01227 01228 /* method: set_status of class fawkes::SkillerInterface */ 01229 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_status00 01230 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_status00(lua_State* tolua_S) 01231 { 01232 #ifndef TOLUA_RELEASE 01233 tolua_Error tolua_err; 01234 if ( 01235 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 01236 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01237 !tolua_isnoobj(tolua_S,3,&tolua_err) 01238 ) 01239 goto tolua_lerror; 01240 else 01241 #endif 01242 { 01243 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01244 const fawkes::SkillerInterface::SkillStatusEnum new_status = ((const fawkes::SkillerInterface::SkillStatusEnum) (int) tolua_tonumber(tolua_S,2,0)); 01245 #ifndef TOLUA_RELEASE 01246 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_status'", NULL); 01247 #endif 01248 { 01249 self->set_status(new_status); 01250 } 01251 } 01252 return 0; 01253 #ifndef TOLUA_RELEASE 01254 tolua_lerror: 01255 tolua_error(tolua_S,"#ferror in function 'set_status'.",&tolua_err); 01256 return 0; 01257 #endif 01258 } 01259 #endif //#ifndef TOLUA_DISABLE 01260 01261 /* method: maxlenof_status of class fawkes::SkillerInterface */ 01262 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_maxlenof_status00 01263 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_maxlenof_status00(lua_State* tolua_S) 01264 { 01265 #ifndef TOLUA_RELEASE 01266 tolua_Error tolua_err; 01267 if ( 01268 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01269 !tolua_isnoobj(tolua_S,2,&tolua_err) 01270 ) 01271 goto tolua_lerror; 01272 else 01273 #endif 01274 { 01275 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01276 #ifndef TOLUA_RELEASE 01277 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_status'", NULL); 01278 #endif 01279 { 01280 int tolua_ret = (int) self->maxlenof_status(); 01281 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01282 } 01283 } 01284 return 1; 01285 #ifndef TOLUA_RELEASE 01286 tolua_lerror: 01287 tolua_error(tolua_S,"#ferror in function 'maxlenof_status'.",&tolua_err); 01288 return 0; 01289 #endif 01290 } 01291 #endif //#ifndef TOLUA_DISABLE 01292 01293 /* method: is_continuous of class fawkes::SkillerInterface */ 01294 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_is_continuous00 01295 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_is_continuous00(lua_State* tolua_S) 01296 { 01297 #ifndef TOLUA_RELEASE 01298 tolua_Error tolua_err; 01299 if ( 01300 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 01301 !tolua_isnoobj(tolua_S,2,&tolua_err) 01302 ) 01303 goto tolua_lerror; 01304 else 01305 #endif 01306 { 01307 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01308 #ifndef TOLUA_RELEASE 01309 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_continuous'", NULL); 01310 #endif 01311 { 01312 bool tolua_ret = (bool) self->is_continuous(); 01313 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01314 } 01315 } 01316 return 1; 01317 #ifndef TOLUA_RELEASE 01318 tolua_lerror: 01319 tolua_error(tolua_S,"#ferror in function 'is_continuous'.",&tolua_err); 01320 return 0; 01321 #endif 01322 } 01323 #endif //#ifndef TOLUA_DISABLE 01324 01325 /* method: set_continuous of class fawkes::SkillerInterface */ 01326 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_continuous00 01327 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_continuous00(lua_State* tolua_S) 01328 { 01329 #ifndef TOLUA_RELEASE 01330 tolua_Error tolua_err; 01331 if ( 01332 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 01333 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 01334 !tolua_isnoobj(tolua_S,3,&tolua_err) 01335 ) 01336 goto tolua_lerror; 01337 else 01338 #endif 01339 { 01340 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01341 const bool new_continuous = ((const bool) tolua_toboolean(tolua_S,2,0)); 01342 #ifndef TOLUA_RELEASE 01343 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_continuous'", NULL); 01344 #endif 01345 { 01346 self->set_continuous(new_continuous); 01347 } 01348 } 01349 return 0; 01350 #ifndef TOLUA_RELEASE 01351 tolua_lerror: 01352 tolua_error(tolua_S,"#ferror in function 'set_continuous'.",&tolua_err); 01353 return 0; 01354 #endif 01355 } 01356 #endif //#ifndef TOLUA_DISABLE 01357 01358 /* method: maxlenof_continuous of class fawkes::SkillerInterface */ 01359 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_maxlenof_continuous00 01360 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_maxlenof_continuous00(lua_State* tolua_S) 01361 { 01362 #ifndef TOLUA_RELEASE 01363 tolua_Error tolua_err; 01364 if ( 01365 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01366 !tolua_isnoobj(tolua_S,2,&tolua_err) 01367 ) 01368 goto tolua_lerror; 01369 else 01370 #endif 01371 { 01372 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01373 #ifndef TOLUA_RELEASE 01374 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_continuous'", NULL); 01375 #endif 01376 { 01377 int tolua_ret = (int) self->maxlenof_continuous(); 01378 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01379 } 01380 } 01381 return 1; 01382 #ifndef TOLUA_RELEASE 01383 tolua_lerror: 01384 tolua_error(tolua_S,"#ferror in function 'maxlenof_continuous'.",&tolua_err); 01385 return 0; 01386 #endif 01387 } 01388 #endif //#ifndef TOLUA_DISABLE 01389 01390 /* method: oftype of class fawkes::SkillerInterface */ 01391 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_oftype00 01392 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_oftype00(lua_State* tolua_S) 01393 { 01394 #ifndef TOLUA_RELEASE 01395 tolua_Error tolua_err; 01396 if ( 01397 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01398 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01399 !tolua_isnoobj(tolua_S,3,&tolua_err) 01400 ) 01401 goto tolua_lerror; 01402 else 01403 #endif 01404 { 01405 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01406 const char* interface_type = ((const char*) tolua_tostring(tolua_S,2,0)); 01407 #ifndef TOLUA_RELEASE 01408 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL); 01409 #endif 01410 { 01411 bool tolua_ret = (bool) self->oftype(interface_type); 01412 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01413 } 01414 } 01415 return 1; 01416 #ifndef TOLUA_RELEASE 01417 tolua_lerror: 01418 tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err); 01419 return 0; 01420 #endif 01421 } 01422 #endif //#ifndef TOLUA_DISABLE 01423 01424 /* method: datachunk of class fawkes::SkillerInterface */ 01425 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_datachunk00 01426 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_datachunk00(lua_State* tolua_S) 01427 { 01428 #ifndef TOLUA_RELEASE 01429 tolua_Error tolua_err; 01430 if ( 01431 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01432 !tolua_isnoobj(tolua_S,2,&tolua_err) 01433 ) 01434 goto tolua_lerror; 01435 else 01436 #endif 01437 { 01438 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01439 #ifndef TOLUA_RELEASE 01440 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL); 01441 #endif 01442 { 01443 const void* tolua_ret = (const void*) self->datachunk(); 01444 tolua_pushuserdata(tolua_S,(void*)tolua_ret); 01445 } 01446 } 01447 return 1; 01448 #ifndef TOLUA_RELEASE 01449 tolua_lerror: 01450 tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err); 01451 return 0; 01452 #endif 01453 } 01454 #endif //#ifndef TOLUA_DISABLE 01455 01456 /* method: datasize of class fawkes::SkillerInterface */ 01457 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_datasize00 01458 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_datasize00(lua_State* tolua_S) 01459 { 01460 #ifndef TOLUA_RELEASE 01461 tolua_Error tolua_err; 01462 if ( 01463 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01464 !tolua_isnoobj(tolua_S,2,&tolua_err) 01465 ) 01466 goto tolua_lerror; 01467 else 01468 #endif 01469 { 01470 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01471 #ifndef TOLUA_RELEASE 01472 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL); 01473 #endif 01474 { 01475 unsigned int tolua_ret = (unsigned int) self->datasize(); 01476 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01477 } 01478 } 01479 return 1; 01480 #ifndef TOLUA_RELEASE 01481 tolua_lerror: 01482 tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err); 01483 return 0; 01484 #endif 01485 } 01486 #endif //#ifndef TOLUA_DISABLE 01487 01488 /* method: type of class fawkes::SkillerInterface */ 01489 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_type00 01490 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_type00(lua_State* tolua_S) 01491 { 01492 #ifndef TOLUA_RELEASE 01493 tolua_Error tolua_err; 01494 if ( 01495 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01496 !tolua_isnoobj(tolua_S,2,&tolua_err) 01497 ) 01498 goto tolua_lerror; 01499 else 01500 #endif 01501 { 01502 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01503 #ifndef TOLUA_RELEASE 01504 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL); 01505 #endif 01506 { 01507 const char* tolua_ret = (const char*) self->type(); 01508 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01509 } 01510 } 01511 return 1; 01512 #ifndef TOLUA_RELEASE 01513 tolua_lerror: 01514 tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err); 01515 return 0; 01516 #endif 01517 } 01518 #endif //#ifndef TOLUA_DISABLE 01519 01520 /* method: id of class fawkes::SkillerInterface */ 01521 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_id00 01522 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_id00(lua_State* tolua_S) 01523 { 01524 #ifndef TOLUA_RELEASE 01525 tolua_Error tolua_err; 01526 if ( 01527 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01528 !tolua_isnoobj(tolua_S,2,&tolua_err) 01529 ) 01530 goto tolua_lerror; 01531 else 01532 #endif 01533 { 01534 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01535 #ifndef TOLUA_RELEASE 01536 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL); 01537 #endif 01538 { 01539 const char* tolua_ret = (const char*) self->id(); 01540 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01541 } 01542 } 01543 return 1; 01544 #ifndef TOLUA_RELEASE 01545 tolua_lerror: 01546 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err); 01547 return 0; 01548 #endif 01549 } 01550 #endif //#ifndef TOLUA_DISABLE 01551 01552 /* method: uid of class fawkes::SkillerInterface */ 01553 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_uid00 01554 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_uid00(lua_State* tolua_S) 01555 { 01556 #ifndef TOLUA_RELEASE 01557 tolua_Error tolua_err; 01558 if ( 01559 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01560 !tolua_isnoobj(tolua_S,2,&tolua_err) 01561 ) 01562 goto tolua_lerror; 01563 else 01564 #endif 01565 { 01566 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01567 #ifndef TOLUA_RELEASE 01568 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL); 01569 #endif 01570 { 01571 const char* tolua_ret = (const char*) self->uid(); 01572 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01573 } 01574 } 01575 return 1; 01576 #ifndef TOLUA_RELEASE 01577 tolua_lerror: 01578 tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err); 01579 return 0; 01580 #endif 01581 } 01582 #endif //#ifndef TOLUA_DISABLE 01583 01584 /* method: serial of class fawkes::SkillerInterface */ 01585 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_serial00 01586 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_serial00(lua_State* tolua_S) 01587 { 01588 #ifndef TOLUA_RELEASE 01589 tolua_Error tolua_err; 01590 if ( 01591 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01592 !tolua_isnoobj(tolua_S,2,&tolua_err) 01593 ) 01594 goto tolua_lerror; 01595 else 01596 #endif 01597 { 01598 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01599 #ifndef TOLUA_RELEASE 01600 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL); 01601 #endif 01602 { 01603 unsigned int tolua_ret = (unsigned int) self->serial(); 01604 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01605 } 01606 } 01607 return 1; 01608 #ifndef TOLUA_RELEASE 01609 tolua_lerror: 01610 tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err); 01611 return 0; 01612 #endif 01613 } 01614 #endif //#ifndef TOLUA_DISABLE 01615 01616 /* method: mem_serial of class fawkes::SkillerInterface */ 01617 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_mem_serial00 01618 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_mem_serial00(lua_State* tolua_S) 01619 { 01620 #ifndef TOLUA_RELEASE 01621 tolua_Error tolua_err; 01622 if ( 01623 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01624 !tolua_isnoobj(tolua_S,2,&tolua_err) 01625 ) 01626 goto tolua_lerror; 01627 else 01628 #endif 01629 { 01630 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01631 #ifndef TOLUA_RELEASE 01632 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL); 01633 #endif 01634 { 01635 unsigned int tolua_ret = (unsigned int) self->mem_serial(); 01636 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01637 } 01638 } 01639 return 1; 01640 #ifndef TOLUA_RELEASE 01641 tolua_lerror: 01642 tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err); 01643 return 0; 01644 #endif 01645 } 01646 #endif //#ifndef TOLUA_DISABLE 01647 01648 /* method: operator== of class fawkes::SkillerInterface */ 01649 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface__eq00 01650 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface__eq00(lua_State* tolua_S) 01651 { 01652 #ifndef TOLUA_RELEASE 01653 tolua_Error tolua_err; 01654 if ( 01655 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01656 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) || 01657 !tolua_isnoobj(tolua_S,3,&tolua_err) 01658 ) 01659 goto tolua_lerror; 01660 else 01661 #endif 01662 { 01663 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01664 Interface* comp = ((Interface*) tolua_tousertype(tolua_S,2,0)); 01665 #ifndef TOLUA_RELEASE 01666 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL); 01667 #endif 01668 { 01669 bool tolua_ret = (bool) self->operator==(*comp); 01670 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01671 } 01672 } 01673 return 1; 01674 #ifndef TOLUA_RELEASE 01675 tolua_lerror: 01676 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err); 01677 return 0; 01678 #endif 01679 } 01680 #endif //#ifndef TOLUA_DISABLE 01681 01682 /* method: hash of class fawkes::SkillerInterface */ 01683 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_hash00 01684 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_hash00(lua_State* tolua_S) 01685 { 01686 #ifndef TOLUA_RELEASE 01687 tolua_Error tolua_err; 01688 if ( 01689 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01690 !tolua_isnoobj(tolua_S,2,&tolua_err) 01691 ) 01692 goto tolua_lerror; 01693 else 01694 #endif 01695 { 01696 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01697 #ifndef TOLUA_RELEASE 01698 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL); 01699 #endif 01700 { 01701 unsigned const char* tolua_ret = ( unsigned const char*) self->hash(); 01702 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01703 } 01704 } 01705 return 1; 01706 #ifndef TOLUA_RELEASE 01707 tolua_lerror: 01708 tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err); 01709 return 0; 01710 #endif 01711 } 01712 #endif //#ifndef TOLUA_DISABLE 01713 01714 /* method: hash_size of class fawkes::SkillerInterface */ 01715 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_hash_size00 01716 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_hash_size00(lua_State* tolua_S) 01717 { 01718 #ifndef TOLUA_RELEASE 01719 tolua_Error tolua_err; 01720 if ( 01721 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01722 !tolua_isnoobj(tolua_S,2,&tolua_err) 01723 ) 01724 goto tolua_lerror; 01725 else 01726 #endif 01727 { 01728 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01729 #ifndef TOLUA_RELEASE 01730 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL); 01731 #endif 01732 { 01733 int tolua_ret = (int) self->hash_size(); 01734 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01735 } 01736 } 01737 return 1; 01738 #ifndef TOLUA_RELEASE 01739 tolua_lerror: 01740 tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err); 01741 return 0; 01742 #endif 01743 } 01744 #endif //#ifndef TOLUA_DISABLE 01745 01746 /* method: hash_printable of class fawkes::SkillerInterface */ 01747 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_hash_printable00 01748 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_hash_printable00(lua_State* tolua_S) 01749 { 01750 #ifndef TOLUA_RELEASE 01751 tolua_Error tolua_err; 01752 if ( 01753 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01754 !tolua_isnoobj(tolua_S,2,&tolua_err) 01755 ) 01756 goto tolua_lerror; 01757 else 01758 #endif 01759 { 01760 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01761 #ifndef TOLUA_RELEASE 01762 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL); 01763 #endif 01764 { 01765 const char* tolua_ret = (const char*) self->hash_printable(); 01766 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01767 } 01768 } 01769 return 1; 01770 #ifndef TOLUA_RELEASE 01771 tolua_lerror: 01772 tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err); 01773 return 0; 01774 #endif 01775 } 01776 #endif //#ifndef TOLUA_DISABLE 01777 01778 /* method: is_writer of class fawkes::SkillerInterface */ 01779 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_is_writer00 01780 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_is_writer00(lua_State* tolua_S) 01781 { 01782 #ifndef TOLUA_RELEASE 01783 tolua_Error tolua_err; 01784 if ( 01785 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01786 !tolua_isnoobj(tolua_S,2,&tolua_err) 01787 ) 01788 goto tolua_lerror; 01789 else 01790 #endif 01791 { 01792 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01793 #ifndef TOLUA_RELEASE 01794 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL); 01795 #endif 01796 { 01797 bool tolua_ret = (bool) self->is_writer(); 01798 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01799 } 01800 } 01801 return 1; 01802 #ifndef TOLUA_RELEASE 01803 tolua_lerror: 01804 tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err); 01805 return 0; 01806 #endif 01807 } 01808 #endif //#ifndef TOLUA_DISABLE 01809 01810 /* method: set_from_chunk of class fawkes::SkillerInterface */ 01811 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_from_chunk00 01812 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_from_chunk00(lua_State* tolua_S) 01813 { 01814 #ifndef TOLUA_RELEASE 01815 tolua_Error tolua_err; 01816 if ( 01817 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 01818 !tolua_isuserdata(tolua_S,2,0,&tolua_err) || 01819 !tolua_isnoobj(tolua_S,3,&tolua_err) 01820 ) 01821 goto tolua_lerror; 01822 else 01823 #endif 01824 { 01825 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01826 void* chunk = ((void*) tolua_touserdata(tolua_S,2,0)); 01827 #ifndef TOLUA_RELEASE 01828 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL); 01829 #endif 01830 { 01831 self->set_from_chunk(chunk); 01832 } 01833 } 01834 return 0; 01835 #ifndef TOLUA_RELEASE 01836 tolua_lerror: 01837 tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err); 01838 return 0; 01839 #endif 01840 } 01841 #endif //#ifndef TOLUA_DISABLE 01842 01843 /* method: create_message of class fawkes::SkillerInterface */ 01844 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_create_message00 01845 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_create_message00(lua_State* tolua_S) 01846 { 01847 #ifndef TOLUA_RELEASE 01848 tolua_Error tolua_err; 01849 if ( 01850 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01851 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01852 !tolua_isnoobj(tolua_S,3,&tolua_err) 01853 ) 01854 goto tolua_lerror; 01855 else 01856 #endif 01857 { 01858 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01859 const char* type = ((const char*) tolua_tostring(tolua_S,2,0)); 01860 #ifndef TOLUA_RELEASE 01861 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL); 01862 #endif 01863 { 01864 Message* tolua_ret = (Message*) self->create_message(type); 01865 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 01866 } 01867 } 01868 return 1; 01869 #ifndef TOLUA_RELEASE 01870 tolua_lerror: 01871 tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err); 01872 return 0; 01873 #endif 01874 } 01875 #endif //#ifndef TOLUA_DISABLE 01876 01877 /* method: read of class fawkes::SkillerInterface */ 01878 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_read00 01879 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_read00(lua_State* tolua_S) 01880 { 01881 #ifndef TOLUA_RELEASE 01882 tolua_Error tolua_err; 01883 if ( 01884 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 01885 !tolua_isnoobj(tolua_S,2,&tolua_err) 01886 ) 01887 goto tolua_lerror; 01888 else 01889 #endif 01890 { 01891 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01892 #ifndef TOLUA_RELEASE 01893 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL); 01894 #endif 01895 { 01896 self->read(); 01897 } 01898 } 01899 return 0; 01900 #ifndef TOLUA_RELEASE 01901 tolua_lerror: 01902 tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err); 01903 return 0; 01904 #endif 01905 } 01906 #endif //#ifndef TOLUA_DISABLE 01907 01908 /* method: write of class fawkes::SkillerInterface */ 01909 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_write00 01910 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_write00(lua_State* tolua_S) 01911 { 01912 #ifndef TOLUA_RELEASE 01913 tolua_Error tolua_err; 01914 if ( 01915 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 01916 !tolua_isnoobj(tolua_S,2,&tolua_err) 01917 ) 01918 goto tolua_lerror; 01919 else 01920 #endif 01921 { 01922 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01923 #ifndef TOLUA_RELEASE 01924 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL); 01925 #endif 01926 { 01927 self->write(); 01928 } 01929 } 01930 return 0; 01931 #ifndef TOLUA_RELEASE 01932 tolua_lerror: 01933 tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err); 01934 return 0; 01935 #endif 01936 } 01937 #endif //#ifndef TOLUA_DISABLE 01938 01939 /* method: has_writer of class fawkes::SkillerInterface */ 01940 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_has_writer00 01941 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_has_writer00(lua_State* tolua_S) 01942 { 01943 #ifndef TOLUA_RELEASE 01944 tolua_Error tolua_err; 01945 if ( 01946 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01947 !tolua_isnoobj(tolua_S,2,&tolua_err) 01948 ) 01949 goto tolua_lerror; 01950 else 01951 #endif 01952 { 01953 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01954 #ifndef TOLUA_RELEASE 01955 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL); 01956 #endif 01957 { 01958 bool tolua_ret = (bool) self->has_writer(); 01959 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01960 } 01961 } 01962 return 1; 01963 #ifndef TOLUA_RELEASE 01964 tolua_lerror: 01965 tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err); 01966 return 0; 01967 #endif 01968 } 01969 #endif //#ifndef TOLUA_DISABLE 01970 01971 /* method: num_readers of class fawkes::SkillerInterface */ 01972 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_num_readers00 01973 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_num_readers00(lua_State* tolua_S) 01974 { 01975 #ifndef TOLUA_RELEASE 01976 tolua_Error tolua_err; 01977 if ( 01978 !tolua_isusertype(tolua_S,1,"const fawkes::SkillerInterface",0,&tolua_err) || 01979 !tolua_isnoobj(tolua_S,2,&tolua_err) 01980 ) 01981 goto tolua_lerror; 01982 else 01983 #endif 01984 { 01985 const fawkes::SkillerInterface* self = (const fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 01986 #ifndef TOLUA_RELEASE 01987 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL); 01988 #endif 01989 { 01990 unsigned int tolua_ret = (unsigned int) self->num_readers(); 01991 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01992 } 01993 } 01994 return 1; 01995 #ifndef TOLUA_RELEASE 01996 tolua_lerror: 01997 tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err); 01998 return 0; 01999 #endif 02000 } 02001 #endif //#ifndef TOLUA_DISABLE 02002 02003 /* method: msgq_enqueue_copy of class fawkes::SkillerInterface */ 02004 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_enqueue_copy00 02005 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_enqueue_copy00(lua_State* tolua_S) 02006 { 02007 #ifndef TOLUA_RELEASE 02008 tolua_Error tolua_err; 02009 if ( 02010 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 02011 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 02012 !tolua_isnoobj(tolua_S,3,&tolua_err) 02013 ) 02014 goto tolua_lerror; 02015 else 02016 #endif 02017 { 02018 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 02019 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 02020 #ifndef TOLUA_RELEASE 02021 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL); 02022 #endif 02023 { 02024 unsigned int tolua_ret = (unsigned int) self->msgq_enqueue_copy(message); 02025 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02026 } 02027 } 02028 return 1; 02029 #ifndef TOLUA_RELEASE 02030 tolua_lerror: 02031 tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err); 02032 return 0; 02033 #endif 02034 } 02035 #endif //#ifndef TOLUA_DISABLE 02036 02037 /* method: msgq_remove of class fawkes::SkillerInterface */ 02038 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_remove00 02039 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_remove00(lua_State* tolua_S) 02040 { 02041 #ifndef TOLUA_RELEASE 02042 tolua_Error tolua_err; 02043 if ( 02044 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 02045 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 02046 !tolua_isnoobj(tolua_S,3,&tolua_err) 02047 ) 02048 goto tolua_lerror; 02049 else 02050 #endif 02051 { 02052 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 02053 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 02054 #ifndef TOLUA_RELEASE 02055 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 02056 #endif 02057 { 02058 self->msgq_remove(message); 02059 } 02060 } 02061 return 0; 02062 #ifndef TOLUA_RELEASE 02063 tolua_lerror: 02064 tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err); 02065 return 0; 02066 #endif 02067 } 02068 #endif //#ifndef TOLUA_DISABLE 02069 02070 /* method: msgq_remove of class fawkes::SkillerInterface */ 02071 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_remove01 02072 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_remove01(lua_State* tolua_S) 02073 { 02074 tolua_Error tolua_err; 02075 if ( 02076 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 02077 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 02078 !tolua_isnoobj(tolua_S,3,&tolua_err) 02079 ) 02080 goto tolua_lerror; 02081 else 02082 { 02083 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 02084 unsigned int message_id = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 02085 #ifndef TOLUA_RELEASE 02086 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 02087 #endif 02088 { 02089 self->msgq_remove(message_id); 02090 } 02091 } 02092 return 0; 02093 tolua_lerror: 02094 return tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_remove00(tolua_S); 02095 } 02096 #endif //#ifndef TOLUA_DISABLE 02097 02098 /* method: msgq_size of class fawkes::SkillerInterface */ 02099 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_size00 02100 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_size00(lua_State* tolua_S) 02101 { 02102 #ifndef TOLUA_RELEASE 02103 tolua_Error tolua_err; 02104 if ( 02105 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 02106 !tolua_isnoobj(tolua_S,2,&tolua_err) 02107 ) 02108 goto tolua_lerror; 02109 else 02110 #endif 02111 { 02112 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 02113 #ifndef TOLUA_RELEASE 02114 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL); 02115 #endif 02116 { 02117 unsigned int tolua_ret = (unsigned int) self->msgq_size(); 02118 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 02119 } 02120 } 02121 return 1; 02122 #ifndef TOLUA_RELEASE 02123 tolua_lerror: 02124 tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err); 02125 return 0; 02126 #endif 02127 } 02128 #endif //#ifndef TOLUA_DISABLE 02129 02130 /* method: msgq_flush of class fawkes::SkillerInterface */ 02131 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_flush00 02132 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_flush00(lua_State* tolua_S) 02133 { 02134 #ifndef TOLUA_RELEASE 02135 tolua_Error tolua_err; 02136 if ( 02137 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 02138 !tolua_isnoobj(tolua_S,2,&tolua_err) 02139 ) 02140 goto tolua_lerror; 02141 else 02142 #endif 02143 { 02144 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 02145 #ifndef TOLUA_RELEASE 02146 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL); 02147 #endif 02148 { 02149 self->msgq_flush(); 02150 } 02151 } 02152 return 0; 02153 #ifndef TOLUA_RELEASE 02154 tolua_lerror: 02155 tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err); 02156 return 0; 02157 #endif 02158 } 02159 #endif //#ifndef TOLUA_DISABLE 02160 02161 /* method: msgq_lock of class fawkes::SkillerInterface */ 02162 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_lock00 02163 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_lock00(lua_State* tolua_S) 02164 { 02165 #ifndef TOLUA_RELEASE 02166 tolua_Error tolua_err; 02167 if ( 02168 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 02169 !tolua_isnoobj(tolua_S,2,&tolua_err) 02170 ) 02171 goto tolua_lerror; 02172 else 02173 #endif 02174 { 02175 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 02176 #ifndef TOLUA_RELEASE 02177 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL); 02178 #endif 02179 { 02180 self->msgq_lock(); 02181 } 02182 } 02183 return 0; 02184 #ifndef TOLUA_RELEASE 02185 tolua_lerror: 02186 tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err); 02187 return 0; 02188 #endif 02189 } 02190 #endif //#ifndef TOLUA_DISABLE 02191 02192 /* method: msgq_try_lock of class fawkes::SkillerInterface */ 02193 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_try_lock00 02194 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_try_lock00(lua_State* tolua_S) 02195 { 02196 #ifndef TOLUA_RELEASE 02197 tolua_Error tolua_err; 02198 if ( 02199 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 02200 !tolua_isnoobj(tolua_S,2,&tolua_err) 02201 ) 02202 goto tolua_lerror; 02203 else 02204 #endif 02205 { 02206 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 02207 #ifndef TOLUA_RELEASE 02208 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL); 02209 #endif 02210 { 02211 bool tolua_ret = (bool) self->msgq_try_lock(); 02212 tolua_pushboolean(tolua_S,(bool)tolua_ret); 02213 } 02214 } 02215 return 1; 02216 #ifndef TOLUA_RELEASE 02217 tolua_lerror: 02218 tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err); 02219 return 0; 02220 #endif 02221 } 02222 #endif //#ifndef TOLUA_DISABLE 02223 02224 /* method: msgq_unlock of class fawkes::SkillerInterface */ 02225 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_unlock00 02226 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_unlock00(lua_State* tolua_S) 02227 { 02228 #ifndef TOLUA_RELEASE 02229 tolua_Error tolua_err; 02230 if ( 02231 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 02232 !tolua_isnoobj(tolua_S,2,&tolua_err) 02233 ) 02234 goto tolua_lerror; 02235 else 02236 #endif 02237 { 02238 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 02239 #ifndef TOLUA_RELEASE 02240 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL); 02241 #endif 02242 { 02243 self->msgq_unlock(); 02244 } 02245 } 02246 return 0; 02247 #ifndef TOLUA_RELEASE 02248 tolua_lerror: 02249 tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err); 02250 return 0; 02251 #endif 02252 } 02253 #endif //#ifndef TOLUA_DISABLE 02254 02255 /* method: msgq_pop of class fawkes::SkillerInterface */ 02256 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_pop00 02257 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_pop00(lua_State* tolua_S) 02258 { 02259 #ifndef TOLUA_RELEASE 02260 tolua_Error tolua_err; 02261 if ( 02262 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 02263 !tolua_isnoobj(tolua_S,2,&tolua_err) 02264 ) 02265 goto tolua_lerror; 02266 else 02267 #endif 02268 { 02269 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 02270 #ifndef TOLUA_RELEASE 02271 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL); 02272 #endif 02273 { 02274 self->msgq_pop(); 02275 } 02276 } 02277 return 0; 02278 #ifndef TOLUA_RELEASE 02279 tolua_lerror: 02280 tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err); 02281 return 0; 02282 #endif 02283 } 02284 #endif //#ifndef TOLUA_DISABLE 02285 02286 /* method: msgq_first of class fawkes::SkillerInterface */ 02287 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_first00 02288 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_first00(lua_State* tolua_S) 02289 { 02290 #ifndef TOLUA_RELEASE 02291 tolua_Error tolua_err; 02292 if ( 02293 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 02294 !tolua_isnoobj(tolua_S,2,&tolua_err) 02295 ) 02296 goto tolua_lerror; 02297 else 02298 #endif 02299 { 02300 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 02301 #ifndef TOLUA_RELEASE 02302 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL); 02303 #endif 02304 { 02305 Message* tolua_ret = (Message*) self->msgq_first(); 02306 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 02307 } 02308 } 02309 return 1; 02310 #ifndef TOLUA_RELEASE 02311 tolua_lerror: 02312 tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err); 02313 return 0; 02314 #endif 02315 } 02316 #endif //#ifndef TOLUA_DISABLE 02317 02318 /* method: msgq_empty of class fawkes::SkillerInterface */ 02319 #ifndef TOLUA_DISABLE_tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_empty00 02320 static int tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_empty00(lua_State* tolua_S) 02321 { 02322 #ifndef TOLUA_RELEASE 02323 tolua_Error tolua_err; 02324 if ( 02325 !tolua_isusertype(tolua_S,1,"fawkes::SkillerInterface",0,&tolua_err) || 02326 !tolua_isnoobj(tolua_S,2,&tolua_err) 02327 ) 02328 goto tolua_lerror; 02329 else 02330 #endif 02331 { 02332 fawkes::SkillerInterface* self = (fawkes::SkillerInterface*) tolua_tousertype(tolua_S,1,0); 02333 #ifndef TOLUA_RELEASE 02334 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL); 02335 #endif 02336 { 02337 bool tolua_ret = (bool) self->msgq_empty(); 02338 tolua_pushboolean(tolua_S,(bool)tolua_ret); 02339 } 02340 } 02341 return 1; 02342 #ifndef TOLUA_RELEASE 02343 tolua_lerror: 02344 tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err); 02345 return 0; 02346 #endif 02347 } 02348 #endif //#ifndef TOLUA_DISABLE 02349 02350 /* Open function */ 02351 TOLUA_API int tolua_interfaces_SkillerInterface_open (lua_State* tolua_S) 02352 { 02353 tolua_open(tolua_S); 02354 tolua_reg_types(tolua_S); 02355 tolua_module(tolua_S,NULL,0); 02356 tolua_beginmodule(tolua_S,NULL); 02357 tolua_module(tolua_S,"fawkes",0); 02358 tolua_beginmodule(tolua_S,"fawkes"); 02359 tolua_cclass(tolua_S,"SkillerInterface","fawkes::SkillerInterface","Interface",NULL); 02360 tolua_beginmodule(tolua_S,"SkillerInterface"); 02361 tolua_constant(tolua_S,"S_INACTIVE",fawkes::SkillerInterface::S_INACTIVE); 02362 tolua_constant(tolua_S,"S_FINAL",fawkes::SkillerInterface::S_FINAL); 02363 tolua_constant(tolua_S,"S_RUNNING",fawkes::SkillerInterface::S_RUNNING); 02364 tolua_constant(tolua_S,"S_FAILED",fawkes::SkillerInterface::S_FAILED); 02365 #ifdef __cplusplus 02366 tolua_cclass(tolua_S,"ExecSkillMessage","fawkes::SkillerInterface::ExecSkillMessage","Message",tolua_collect_fawkes__SkillerInterface__ExecSkillMessage); 02367 #else 02368 tolua_cclass(tolua_S,"ExecSkillMessage","fawkes::SkillerInterface::ExecSkillMessage","Message",NULL); 02369 #endif 02370 tolua_beginmodule(tolua_S,"ExecSkillMessage"); 02371 tolua_function(tolua_S,"new",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_new00); 02372 tolua_function(tolua_S,"new_local",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_new00_local); 02373 tolua_function(tolua_S,".call",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_new00_local); 02374 tolua_function(tolua_S,"new",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_new01); 02375 tolua_function(tolua_S,"new_local",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_new01_local); 02376 tolua_function(tolua_S,".call",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_new01_local); 02377 tolua_function(tolua_S,"delete",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_delete00); 02378 tolua_function(tolua_S,"skill_string",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_skill_string00); 02379 tolua_function(tolua_S,"set_skill_string",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_set_skill_string00); 02380 tolua_function(tolua_S,"maxlenof_skill_string",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillMessage_maxlenof_skill_string00); 02381 tolua_endmodule(tolua_S); 02382 #ifdef __cplusplus 02383 tolua_cclass(tolua_S,"ExecSkillContinuousMessage","fawkes::SkillerInterface::ExecSkillContinuousMessage","Message",tolua_collect_fawkes__SkillerInterface__ExecSkillContinuousMessage); 02384 #else 02385 tolua_cclass(tolua_S,"ExecSkillContinuousMessage","fawkes::SkillerInterface::ExecSkillContinuousMessage","Message",NULL); 02386 #endif 02387 tolua_beginmodule(tolua_S,"ExecSkillContinuousMessage"); 02388 tolua_function(tolua_S,"new",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_new00); 02389 tolua_function(tolua_S,"new_local",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_new00_local); 02390 tolua_function(tolua_S,".call",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_new00_local); 02391 tolua_function(tolua_S,"new",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_new01); 02392 tolua_function(tolua_S,"new_local",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_new01_local); 02393 tolua_function(tolua_S,".call",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_new01_local); 02394 tolua_function(tolua_S,"delete",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_delete00); 02395 tolua_function(tolua_S,"skill_string",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_skill_string00); 02396 tolua_function(tolua_S,"set_skill_string",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_set_skill_string00); 02397 tolua_function(tolua_S,"maxlenof_skill_string",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ExecSkillContinuousMessage_maxlenof_skill_string00); 02398 tolua_endmodule(tolua_S); 02399 #ifdef __cplusplus 02400 tolua_cclass(tolua_S,"RestartInterpreterMessage","fawkes::SkillerInterface::RestartInterpreterMessage","Message",tolua_collect_fawkes__SkillerInterface__RestartInterpreterMessage); 02401 #else 02402 tolua_cclass(tolua_S,"RestartInterpreterMessage","fawkes::SkillerInterface::RestartInterpreterMessage","Message",NULL); 02403 #endif 02404 tolua_beginmodule(tolua_S,"RestartInterpreterMessage"); 02405 tolua_function(tolua_S,"new",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_RestartInterpreterMessage_new00); 02406 tolua_function(tolua_S,"new_local",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_RestartInterpreterMessage_new00_local); 02407 tolua_function(tolua_S,".call",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_RestartInterpreterMessage_new00_local); 02408 tolua_function(tolua_S,"delete",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_RestartInterpreterMessage_delete00); 02409 tolua_endmodule(tolua_S); 02410 #ifdef __cplusplus 02411 tolua_cclass(tolua_S,"StopExecMessage","fawkes::SkillerInterface::StopExecMessage","Message",tolua_collect_fawkes__SkillerInterface__StopExecMessage); 02412 #else 02413 tolua_cclass(tolua_S,"StopExecMessage","fawkes::SkillerInterface::StopExecMessage","Message",NULL); 02414 #endif 02415 tolua_beginmodule(tolua_S,"StopExecMessage"); 02416 tolua_function(tolua_S,"new",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_StopExecMessage_new00); 02417 tolua_function(tolua_S,"new_local",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_StopExecMessage_new00_local); 02418 tolua_function(tolua_S,".call",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_StopExecMessage_new00_local); 02419 tolua_function(tolua_S,"delete",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_StopExecMessage_delete00); 02420 tolua_endmodule(tolua_S); 02421 #ifdef __cplusplus 02422 tolua_cclass(tolua_S,"AcquireControlMessage","fawkes::SkillerInterface::AcquireControlMessage","Message",tolua_collect_fawkes__SkillerInterface__AcquireControlMessage); 02423 #else 02424 tolua_cclass(tolua_S,"AcquireControlMessage","fawkes::SkillerInterface::AcquireControlMessage","Message",NULL); 02425 #endif 02426 tolua_beginmodule(tolua_S,"AcquireControlMessage"); 02427 tolua_function(tolua_S,"new",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_AcquireControlMessage_new00); 02428 tolua_function(tolua_S,"new_local",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_AcquireControlMessage_new00_local); 02429 tolua_function(tolua_S,".call",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_AcquireControlMessage_new00_local); 02430 tolua_function(tolua_S,"delete",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_AcquireControlMessage_delete00); 02431 tolua_endmodule(tolua_S); 02432 #ifdef __cplusplus 02433 tolua_cclass(tolua_S,"ReleaseControlMessage","fawkes::SkillerInterface::ReleaseControlMessage","Message",tolua_collect_fawkes__SkillerInterface__ReleaseControlMessage); 02434 #else 02435 tolua_cclass(tolua_S,"ReleaseControlMessage","fawkes::SkillerInterface::ReleaseControlMessage","Message",NULL); 02436 #endif 02437 tolua_beginmodule(tolua_S,"ReleaseControlMessage"); 02438 tolua_function(tolua_S,"new",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ReleaseControlMessage_new00); 02439 tolua_function(tolua_S,"new_local",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ReleaseControlMessage_new00_local); 02440 tolua_function(tolua_S,".call",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ReleaseControlMessage_new00_local); 02441 tolua_function(tolua_S,"delete",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_ReleaseControlMessage_delete00); 02442 tolua_endmodule(tolua_S); 02443 tolua_function(tolua_S,"skill_string",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_skill_string00); 02444 tolua_function(tolua_S,"set_skill_string",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_skill_string00); 02445 tolua_function(tolua_S,"maxlenof_skill_string",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_maxlenof_skill_string00); 02446 tolua_function(tolua_S,"error",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_error00); 02447 tolua_function(tolua_S,"set_error",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_error00); 02448 tolua_function(tolua_S,"maxlenof_error",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_maxlenof_error00); 02449 tolua_function(tolua_S,"exclusive_controller",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_exclusive_controller00); 02450 tolua_function(tolua_S,"set_exclusive_controller",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_exclusive_controller00); 02451 tolua_function(tolua_S,"maxlenof_exclusive_controller",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_maxlenof_exclusive_controller00); 02452 tolua_function(tolua_S,"status",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_status00); 02453 tolua_function(tolua_S,"set_status",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_status00); 02454 tolua_function(tolua_S,"maxlenof_status",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_maxlenof_status00); 02455 tolua_function(tolua_S,"is_continuous",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_is_continuous00); 02456 tolua_function(tolua_S,"set_continuous",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_continuous00); 02457 tolua_function(tolua_S,"maxlenof_continuous",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_maxlenof_continuous00); 02458 tolua_function(tolua_S,"oftype",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_oftype00); 02459 tolua_function(tolua_S,"datachunk",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_datachunk00); 02460 tolua_function(tolua_S,"datasize",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_datasize00); 02461 tolua_function(tolua_S,"type",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_type00); 02462 tolua_function(tolua_S,"id",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_id00); 02463 tolua_function(tolua_S,"uid",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_uid00); 02464 tolua_function(tolua_S,"serial",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_serial00); 02465 tolua_function(tolua_S,"mem_serial",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_mem_serial00); 02466 tolua_function(tolua_S,".eq",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface__eq00); 02467 tolua_function(tolua_S,"hash",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_hash00); 02468 tolua_function(tolua_S,"hash_size",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_hash_size00); 02469 tolua_function(tolua_S,"hash_printable",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_hash_printable00); 02470 tolua_function(tolua_S,"is_writer",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_is_writer00); 02471 tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_set_from_chunk00); 02472 tolua_function(tolua_S,"create_message",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_create_message00); 02473 tolua_function(tolua_S,"read",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_read00); 02474 tolua_function(tolua_S,"write",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_write00); 02475 tolua_function(tolua_S,"has_writer",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_has_writer00); 02476 tolua_function(tolua_S,"num_readers",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_num_readers00); 02477 tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_enqueue_copy00); 02478 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_remove00); 02479 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_remove01); 02480 tolua_function(tolua_S,"msgq_size",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_size00); 02481 tolua_function(tolua_S,"msgq_flush",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_flush00); 02482 tolua_function(tolua_S,"msgq_lock",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_lock00); 02483 tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_try_lock00); 02484 tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_unlock00); 02485 tolua_function(tolua_S,"msgq_pop",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_pop00); 02486 tolua_function(tolua_S,"msgq_first",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_first00); 02487 tolua_function(tolua_S,"msgq_empty",tolua_interfaces_SkillerInterface_fawkes_SkillerInterface_msgq_empty00); 02488 tolua_endmodule(tolua_S); 02489 tolua_endmodule(tolua_S); 02490 tolua_endmodule(tolua_S); 02491 return 1; 02492 } 02493 02494 02495 extern "C" { 02496 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501 02497 TOLUA_API int luaopen_interfaces_SkillerInterface (lua_State* tolua_S) { 02498 return tolua_interfaces_SkillerInterface_open(tolua_S); 02499 }; 02500 #endif 02501 } 02502 02503