00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #ifndef __cplusplus
00020 #include "stdlib.h"
00021 #endif
00022 #include "string.h"
00023
00024 #include "tolua++.h"
00025
00026
00027 TOLUA_API int tolua_interfaces_SkillerInterface_open (lua_State* tolua_S);
00028
00029 #include <interfaces/SkillerInterface.h>
00030 using namespace fawkes;
00031
00032
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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