Fawkes API Fawkes Development Version
|
00001 /* 00002 ** Lua binding: interfaces_SpeechRecognitionInterface 00003 ** Generated automatically by tolua++-1.0.92 00004 */ 00005 /* This program is free software; you can redistribute it and/or modify 00006 * it under the terms of the GNU General Public License as published by 00007 * the Free Software Foundation; either version 2 of the License, or 00008 * (at your option) any later version. A runtime exception applies to 00009 * this software (see LICENSE.GPL_WRE file mentioned below for details). 00010 * 00011 * This program is distributed in the hope that it will be useful, 00012 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00014 * GNU Library General Public License for more details. 00015 * 00016 * Read the full text in the LICENSE.GPL_WRE file in the doc directory. 00017 */ 00018 00019 #ifndef __cplusplus 00020 #include "stdlib.h" 00021 #endif 00022 #include "string.h" 00023 00024 #include "tolua++.h" 00025 00026 /* Exported function */ 00027 TOLUA_API int tolua_interfaces_SpeechRecognitionInterface_open (lua_State* tolua_S); 00028 00029 #include <interfaces/SpeechRecognitionInterface.h> 00030 using namespace fawkes; 00031 00032 /* function to release collected object via destructor */ 00033 #ifdef __cplusplus 00034 00035 static int tolua_collect_fawkes__SpeechRecognitionInterface__SetEnabledMessage (lua_State* tolua_S) 00036 { 00037 fawkes::SpeechRecognitionInterface::SetEnabledMessage* self = (fawkes::SpeechRecognitionInterface::SetEnabledMessage*) tolua_tousertype(tolua_S,1,0); 00038 Mtolua_delete(self); 00039 return 0; 00040 } 00041 00042 static int tolua_collect_fawkes__SpeechRecognitionInterface__ResetMessage (lua_State* tolua_S) 00043 { 00044 fawkes::SpeechRecognitionInterface::ResetMessage* self = (fawkes::SpeechRecognitionInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0); 00045 Mtolua_delete(self); 00046 return 0; 00047 } 00048 #endif 00049 00050 00051 /* function to register type */ 00052 static void tolua_reg_types (lua_State* tolua_S) 00053 { 00054 tolua_usertype(tolua_S,"Message"); 00055 tolua_usertype(tolua_S,"fawkes::SpeechRecognitionInterface"); 00056 tolua_usertype(tolua_S,"fawkes::SpeechRecognitionInterface::ResetMessage"); 00057 tolua_usertype(tolua_S,"fawkes::SpeechRecognitionInterface::SetEnabledMessage"); 00058 tolua_usertype(tolua_S,"Interface"); 00059 } 00060 00061 /* method: new of class ResetMessage */ 00062 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_new00 00063 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_new00(lua_State* tolua_S) 00064 { 00065 #ifndef TOLUA_RELEASE 00066 tolua_Error tolua_err; 00067 if ( 00068 !tolua_isusertable(tolua_S,1,"fawkes::SpeechRecognitionInterface::ResetMessage",0,&tolua_err) || 00069 !tolua_isnoobj(tolua_S,2,&tolua_err) 00070 ) 00071 goto tolua_lerror; 00072 else 00073 #endif 00074 { 00075 { 00076 fawkes::SpeechRecognitionInterface::ResetMessage* tolua_ret = (fawkes::SpeechRecognitionInterface::ResetMessage*) Mtolua_new((fawkes::SpeechRecognitionInterface::ResetMessage)()); 00077 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SpeechRecognitionInterface::ResetMessage"); 00078 } 00079 } 00080 return 1; 00081 #ifndef TOLUA_RELEASE 00082 tolua_lerror: 00083 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00084 return 0; 00085 #endif 00086 } 00087 #endif //#ifndef TOLUA_DISABLE 00088 00089 /* method: new_local of class ResetMessage */ 00090 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_new00_local 00091 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_new00_local(lua_State* tolua_S) 00092 { 00093 #ifndef TOLUA_RELEASE 00094 tolua_Error tolua_err; 00095 if ( 00096 !tolua_isusertable(tolua_S,1,"fawkes::SpeechRecognitionInterface::ResetMessage",0,&tolua_err) || 00097 !tolua_isnoobj(tolua_S,2,&tolua_err) 00098 ) 00099 goto tolua_lerror; 00100 else 00101 #endif 00102 { 00103 { 00104 fawkes::SpeechRecognitionInterface::ResetMessage* tolua_ret = (fawkes::SpeechRecognitionInterface::ResetMessage*) Mtolua_new((fawkes::SpeechRecognitionInterface::ResetMessage)()); 00105 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SpeechRecognitionInterface::ResetMessage"); 00106 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00107 } 00108 } 00109 return 1; 00110 #ifndef TOLUA_RELEASE 00111 tolua_lerror: 00112 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00113 return 0; 00114 #endif 00115 } 00116 #endif //#ifndef TOLUA_DISABLE 00117 00118 /* method: delete of class ResetMessage */ 00119 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_delete00 00120 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_delete00(lua_State* tolua_S) 00121 { 00122 #ifndef TOLUA_RELEASE 00123 tolua_Error tolua_err; 00124 if ( 00125 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface::ResetMessage",0,&tolua_err) || 00126 !tolua_isnoobj(tolua_S,2,&tolua_err) 00127 ) 00128 goto tolua_lerror; 00129 else 00130 #endif 00131 { 00132 fawkes::SpeechRecognitionInterface::ResetMessage* self = (fawkes::SpeechRecognitionInterface::ResetMessage*) tolua_tousertype(tolua_S,1,0); 00133 #ifndef TOLUA_RELEASE 00134 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00135 #endif 00136 Mtolua_delete(self); 00137 } 00138 return 0; 00139 #ifndef TOLUA_RELEASE 00140 tolua_lerror: 00141 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00142 return 0; 00143 #endif 00144 } 00145 #endif //#ifndef TOLUA_DISABLE 00146 00147 /* method: new of class SetEnabledMessage */ 00148 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00 00149 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00(lua_State* tolua_S) 00150 { 00151 #ifndef TOLUA_RELEASE 00152 tolua_Error tolua_err; 00153 if ( 00154 !tolua_isusertable(tolua_S,1,"fawkes::SpeechRecognitionInterface::SetEnabledMessage",0,&tolua_err) || 00155 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 00156 !tolua_isnoobj(tolua_S,3,&tolua_err) 00157 ) 00158 goto tolua_lerror; 00159 else 00160 #endif 00161 { 00162 bool ini_enabled = ((bool) tolua_toboolean(tolua_S,2,0)); 00163 { 00164 fawkes::SpeechRecognitionInterface::SetEnabledMessage* tolua_ret = (fawkes::SpeechRecognitionInterface::SetEnabledMessage*) Mtolua_new((fawkes::SpeechRecognitionInterface::SetEnabledMessage)(ini_enabled)); 00165 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SpeechRecognitionInterface::SetEnabledMessage"); 00166 } 00167 } 00168 return 1; 00169 #ifndef TOLUA_RELEASE 00170 tolua_lerror: 00171 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00172 return 0; 00173 #endif 00174 } 00175 #endif //#ifndef TOLUA_DISABLE 00176 00177 /* method: new_local of class SetEnabledMessage */ 00178 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00_local 00179 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00_local(lua_State* tolua_S) 00180 { 00181 #ifndef TOLUA_RELEASE 00182 tolua_Error tolua_err; 00183 if ( 00184 !tolua_isusertable(tolua_S,1,"fawkes::SpeechRecognitionInterface::SetEnabledMessage",0,&tolua_err) || 00185 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 00186 !tolua_isnoobj(tolua_S,3,&tolua_err) 00187 ) 00188 goto tolua_lerror; 00189 else 00190 #endif 00191 { 00192 bool ini_enabled = ((bool) tolua_toboolean(tolua_S,2,0)); 00193 { 00194 fawkes::SpeechRecognitionInterface::SetEnabledMessage* tolua_ret = (fawkes::SpeechRecognitionInterface::SetEnabledMessage*) Mtolua_new((fawkes::SpeechRecognitionInterface::SetEnabledMessage)(ini_enabled)); 00195 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SpeechRecognitionInterface::SetEnabledMessage"); 00196 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00197 } 00198 } 00199 return 1; 00200 #ifndef TOLUA_RELEASE 00201 tolua_lerror: 00202 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err); 00203 return 0; 00204 #endif 00205 } 00206 #endif //#ifndef TOLUA_DISABLE 00207 00208 /* method: new of class SetEnabledMessage */ 00209 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new01 00210 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new01(lua_State* tolua_S) 00211 { 00212 tolua_Error tolua_err; 00213 if ( 00214 !tolua_isusertable(tolua_S,1,"fawkes::SpeechRecognitionInterface::SetEnabledMessage",0,&tolua_err) || 00215 !tolua_isnoobj(tolua_S,2,&tolua_err) 00216 ) 00217 goto tolua_lerror; 00218 else 00219 { 00220 { 00221 fawkes::SpeechRecognitionInterface::SetEnabledMessage* tolua_ret = (fawkes::SpeechRecognitionInterface::SetEnabledMessage*) Mtolua_new((fawkes::SpeechRecognitionInterface::SetEnabledMessage)()); 00222 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SpeechRecognitionInterface::SetEnabledMessage"); 00223 } 00224 } 00225 return 1; 00226 tolua_lerror: 00227 return tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00(tolua_S); 00228 } 00229 #endif //#ifndef TOLUA_DISABLE 00230 00231 /* method: new_local of class SetEnabledMessage */ 00232 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new01_local 00233 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new01_local(lua_State* tolua_S) 00234 { 00235 tolua_Error tolua_err; 00236 if ( 00237 !tolua_isusertable(tolua_S,1,"fawkes::SpeechRecognitionInterface::SetEnabledMessage",0,&tolua_err) || 00238 !tolua_isnoobj(tolua_S,2,&tolua_err) 00239 ) 00240 goto tolua_lerror; 00241 else 00242 { 00243 { 00244 fawkes::SpeechRecognitionInterface::SetEnabledMessage* tolua_ret = (fawkes::SpeechRecognitionInterface::SetEnabledMessage*) Mtolua_new((fawkes::SpeechRecognitionInterface::SetEnabledMessage)()); 00245 tolua_pushusertype(tolua_S,(void*)tolua_ret,"fawkes::SpeechRecognitionInterface::SetEnabledMessage"); 00246 tolua_register_gc(tolua_S,lua_gettop(tolua_S)); 00247 } 00248 } 00249 return 1; 00250 tolua_lerror: 00251 return tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00_local(tolua_S); 00252 } 00253 #endif //#ifndef TOLUA_DISABLE 00254 00255 /* method: delete of class SetEnabledMessage */ 00256 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_delete00 00257 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_delete00(lua_State* tolua_S) 00258 { 00259 #ifndef TOLUA_RELEASE 00260 tolua_Error tolua_err; 00261 if ( 00262 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface::SetEnabledMessage",0,&tolua_err) || 00263 !tolua_isnoobj(tolua_S,2,&tolua_err) 00264 ) 00265 goto tolua_lerror; 00266 else 00267 #endif 00268 { 00269 fawkes::SpeechRecognitionInterface::SetEnabledMessage* self = (fawkes::SpeechRecognitionInterface::SetEnabledMessage*) tolua_tousertype(tolua_S,1,0); 00270 #ifndef TOLUA_RELEASE 00271 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL); 00272 #endif 00273 Mtolua_delete(self); 00274 } 00275 return 0; 00276 #ifndef TOLUA_RELEASE 00277 tolua_lerror: 00278 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err); 00279 return 0; 00280 #endif 00281 } 00282 #endif //#ifndef TOLUA_DISABLE 00283 00284 /* method: is_enabled of class SetEnabledMessage */ 00285 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_is_enabled00 00286 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_is_enabled00(lua_State* tolua_S) 00287 { 00288 #ifndef TOLUA_RELEASE 00289 tolua_Error tolua_err; 00290 if ( 00291 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface::SetEnabledMessage",0,&tolua_err) || 00292 !tolua_isnoobj(tolua_S,2,&tolua_err) 00293 ) 00294 goto tolua_lerror; 00295 else 00296 #endif 00297 { 00298 fawkes::SpeechRecognitionInterface::SetEnabledMessage* self = (fawkes::SpeechRecognitionInterface::SetEnabledMessage*) tolua_tousertype(tolua_S,1,0); 00299 #ifndef TOLUA_RELEASE 00300 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_enabled'", NULL); 00301 #endif 00302 { 00303 bool tolua_ret = (bool) self->is_enabled(); 00304 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00305 } 00306 } 00307 return 1; 00308 #ifndef TOLUA_RELEASE 00309 tolua_lerror: 00310 tolua_error(tolua_S,"#ferror in function 'is_enabled'.",&tolua_err); 00311 return 0; 00312 #endif 00313 } 00314 #endif //#ifndef TOLUA_DISABLE 00315 00316 /* method: set_enabled of class SetEnabledMessage */ 00317 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_set_enabled00 00318 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_set_enabled00(lua_State* tolua_S) 00319 { 00320 #ifndef TOLUA_RELEASE 00321 tolua_Error tolua_err; 00322 if ( 00323 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface::SetEnabledMessage",0,&tolua_err) || 00324 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 00325 !tolua_isnoobj(tolua_S,3,&tolua_err) 00326 ) 00327 goto tolua_lerror; 00328 else 00329 #endif 00330 { 00331 fawkes::SpeechRecognitionInterface::SetEnabledMessage* self = (fawkes::SpeechRecognitionInterface::SetEnabledMessage*) tolua_tousertype(tolua_S,1,0); 00332 const bool new_enabled = ((const bool) tolua_toboolean(tolua_S,2,0)); 00333 #ifndef TOLUA_RELEASE 00334 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_enabled'", NULL); 00335 #endif 00336 { 00337 self->set_enabled(new_enabled); 00338 } 00339 } 00340 return 0; 00341 #ifndef TOLUA_RELEASE 00342 tolua_lerror: 00343 tolua_error(tolua_S,"#ferror in function 'set_enabled'.",&tolua_err); 00344 return 0; 00345 #endif 00346 } 00347 #endif //#ifndef TOLUA_DISABLE 00348 00349 /* method: maxlenof_enabled of class SetEnabledMessage */ 00350 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_maxlenof_enabled00 00351 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_maxlenof_enabled00(lua_State* tolua_S) 00352 { 00353 #ifndef TOLUA_RELEASE 00354 tolua_Error tolua_err; 00355 if ( 00356 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface::SetEnabledMessage",0,&tolua_err) || 00357 !tolua_isnoobj(tolua_S,2,&tolua_err) 00358 ) 00359 goto tolua_lerror; 00360 else 00361 #endif 00362 { 00363 const fawkes::SpeechRecognitionInterface::SetEnabledMessage* self = (const fawkes::SpeechRecognitionInterface::SetEnabledMessage*) tolua_tousertype(tolua_S,1,0); 00364 #ifndef TOLUA_RELEASE 00365 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_enabled'", NULL); 00366 #endif 00367 { 00368 int tolua_ret = (int) self->maxlenof_enabled(); 00369 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00370 } 00371 } 00372 return 1; 00373 #ifndef TOLUA_RELEASE 00374 tolua_lerror: 00375 tolua_error(tolua_S,"#ferror in function 'maxlenof_enabled'.",&tolua_err); 00376 return 0; 00377 #endif 00378 } 00379 #endif //#ifndef TOLUA_DISABLE 00380 00381 /* method: text of class fawkes::SpeechRecognitionInterface */ 00382 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_text00 00383 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_text00(lua_State* tolua_S) 00384 { 00385 #ifndef TOLUA_RELEASE 00386 tolua_Error tolua_err; 00387 if ( 00388 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00389 !tolua_isnoobj(tolua_S,2,&tolua_err) 00390 ) 00391 goto tolua_lerror; 00392 else 00393 #endif 00394 { 00395 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00396 #ifndef TOLUA_RELEASE 00397 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'text'", NULL); 00398 #endif 00399 { 00400 char* tolua_ret = (char*) self->text(); 00401 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00402 } 00403 } 00404 return 1; 00405 #ifndef TOLUA_RELEASE 00406 tolua_lerror: 00407 tolua_error(tolua_S,"#ferror in function 'text'.",&tolua_err); 00408 return 0; 00409 #endif 00410 } 00411 #endif //#ifndef TOLUA_DISABLE 00412 00413 /* method: set_text of class fawkes::SpeechRecognitionInterface */ 00414 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_text00 00415 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_text00(lua_State* tolua_S) 00416 { 00417 #ifndef TOLUA_RELEASE 00418 tolua_Error tolua_err; 00419 if ( 00420 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00421 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00422 !tolua_isnoobj(tolua_S,3,&tolua_err) 00423 ) 00424 goto tolua_lerror; 00425 else 00426 #endif 00427 { 00428 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00429 const char* new_text = ((const char*) tolua_tostring(tolua_S,2,0)); 00430 #ifndef TOLUA_RELEASE 00431 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_text'", NULL); 00432 #endif 00433 { 00434 self->set_text(new_text); 00435 } 00436 } 00437 return 0; 00438 #ifndef TOLUA_RELEASE 00439 tolua_lerror: 00440 tolua_error(tolua_S,"#ferror in function 'set_text'.",&tolua_err); 00441 return 0; 00442 #endif 00443 } 00444 #endif //#ifndef TOLUA_DISABLE 00445 00446 /* method: maxlenof_text of class fawkes::SpeechRecognitionInterface */ 00447 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_text00 00448 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_text00(lua_State* tolua_S) 00449 { 00450 #ifndef TOLUA_RELEASE 00451 tolua_Error tolua_err; 00452 if ( 00453 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00454 !tolua_isnoobj(tolua_S,2,&tolua_err) 00455 ) 00456 goto tolua_lerror; 00457 else 00458 #endif 00459 { 00460 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00461 #ifndef TOLUA_RELEASE 00462 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_text'", NULL); 00463 #endif 00464 { 00465 int tolua_ret = (int) self->maxlenof_text(); 00466 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00467 } 00468 } 00469 return 1; 00470 #ifndef TOLUA_RELEASE 00471 tolua_lerror: 00472 tolua_error(tolua_S,"#ferror in function 'maxlenof_text'.",&tolua_err); 00473 return 0; 00474 #endif 00475 } 00476 #endif //#ifndef TOLUA_DISABLE 00477 00478 /* method: counter of class fawkes::SpeechRecognitionInterface */ 00479 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_counter00 00480 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_counter00(lua_State* tolua_S) 00481 { 00482 #ifndef TOLUA_RELEASE 00483 tolua_Error tolua_err; 00484 if ( 00485 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00486 !tolua_isnoobj(tolua_S,2,&tolua_err) 00487 ) 00488 goto tolua_lerror; 00489 else 00490 #endif 00491 { 00492 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00493 #ifndef TOLUA_RELEASE 00494 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'counter'", NULL); 00495 #endif 00496 { 00497 unsigned int tolua_ret = (unsigned int) self->counter(); 00498 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00499 } 00500 } 00501 return 1; 00502 #ifndef TOLUA_RELEASE 00503 tolua_lerror: 00504 tolua_error(tolua_S,"#ferror in function 'counter'.",&tolua_err); 00505 return 0; 00506 #endif 00507 } 00508 #endif //#ifndef TOLUA_DISABLE 00509 00510 /* method: set_counter of class fawkes::SpeechRecognitionInterface */ 00511 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_counter00 00512 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_counter00(lua_State* tolua_S) 00513 { 00514 #ifndef TOLUA_RELEASE 00515 tolua_Error tolua_err; 00516 if ( 00517 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00518 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 00519 !tolua_isnoobj(tolua_S,3,&tolua_err) 00520 ) 00521 goto tolua_lerror; 00522 else 00523 #endif 00524 { 00525 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00526 unsigned const int new_counter = ((unsigned const int) tolua_tonumber(tolua_S,2,0)); 00527 #ifndef TOLUA_RELEASE 00528 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_counter'", NULL); 00529 #endif 00530 { 00531 self->set_counter(new_counter); 00532 } 00533 } 00534 return 0; 00535 #ifndef TOLUA_RELEASE 00536 tolua_lerror: 00537 tolua_error(tolua_S,"#ferror in function 'set_counter'.",&tolua_err); 00538 return 0; 00539 #endif 00540 } 00541 #endif //#ifndef TOLUA_DISABLE 00542 00543 /* method: maxlenof_counter of class fawkes::SpeechRecognitionInterface */ 00544 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_counter00 00545 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_counter00(lua_State* tolua_S) 00546 { 00547 #ifndef TOLUA_RELEASE 00548 tolua_Error tolua_err; 00549 if ( 00550 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00551 !tolua_isnoobj(tolua_S,2,&tolua_err) 00552 ) 00553 goto tolua_lerror; 00554 else 00555 #endif 00556 { 00557 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00558 #ifndef TOLUA_RELEASE 00559 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_counter'", NULL); 00560 #endif 00561 { 00562 int tolua_ret = (int) self->maxlenof_counter(); 00563 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00564 } 00565 } 00566 return 1; 00567 #ifndef TOLUA_RELEASE 00568 tolua_lerror: 00569 tolua_error(tolua_S,"#ferror in function 'maxlenof_counter'.",&tolua_err); 00570 return 0; 00571 #endif 00572 } 00573 #endif //#ifndef TOLUA_DISABLE 00574 00575 /* method: is_processing of class fawkes::SpeechRecognitionInterface */ 00576 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_processing00 00577 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_processing00(lua_State* tolua_S) 00578 { 00579 #ifndef TOLUA_RELEASE 00580 tolua_Error tolua_err; 00581 if ( 00582 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00583 !tolua_isnoobj(tolua_S,2,&tolua_err) 00584 ) 00585 goto tolua_lerror; 00586 else 00587 #endif 00588 { 00589 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00590 #ifndef TOLUA_RELEASE 00591 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_processing'", NULL); 00592 #endif 00593 { 00594 bool tolua_ret = (bool) self->is_processing(); 00595 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00596 } 00597 } 00598 return 1; 00599 #ifndef TOLUA_RELEASE 00600 tolua_lerror: 00601 tolua_error(tolua_S,"#ferror in function 'is_processing'.",&tolua_err); 00602 return 0; 00603 #endif 00604 } 00605 #endif //#ifndef TOLUA_DISABLE 00606 00607 /* method: set_processing of class fawkes::SpeechRecognitionInterface */ 00608 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_processing00 00609 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_processing00(lua_State* tolua_S) 00610 { 00611 #ifndef TOLUA_RELEASE 00612 tolua_Error tolua_err; 00613 if ( 00614 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00615 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 00616 !tolua_isnoobj(tolua_S,3,&tolua_err) 00617 ) 00618 goto tolua_lerror; 00619 else 00620 #endif 00621 { 00622 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00623 const bool new_processing = ((const bool) tolua_toboolean(tolua_S,2,0)); 00624 #ifndef TOLUA_RELEASE 00625 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_processing'", NULL); 00626 #endif 00627 { 00628 self->set_processing(new_processing); 00629 } 00630 } 00631 return 0; 00632 #ifndef TOLUA_RELEASE 00633 tolua_lerror: 00634 tolua_error(tolua_S,"#ferror in function 'set_processing'.",&tolua_err); 00635 return 0; 00636 #endif 00637 } 00638 #endif //#ifndef TOLUA_DISABLE 00639 00640 /* method: maxlenof_processing of class fawkes::SpeechRecognitionInterface */ 00641 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_processing00 00642 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_processing00(lua_State* tolua_S) 00643 { 00644 #ifndef TOLUA_RELEASE 00645 tolua_Error tolua_err; 00646 if ( 00647 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00648 !tolua_isnoobj(tolua_S,2,&tolua_err) 00649 ) 00650 goto tolua_lerror; 00651 else 00652 #endif 00653 { 00654 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00655 #ifndef TOLUA_RELEASE 00656 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_processing'", NULL); 00657 #endif 00658 { 00659 int tolua_ret = (int) self->maxlenof_processing(); 00660 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00661 } 00662 } 00663 return 1; 00664 #ifndef TOLUA_RELEASE 00665 tolua_lerror: 00666 tolua_error(tolua_S,"#ferror in function 'maxlenof_processing'.",&tolua_err); 00667 return 0; 00668 #endif 00669 } 00670 #endif //#ifndef TOLUA_DISABLE 00671 00672 /* method: is_enabled of class fawkes::SpeechRecognitionInterface */ 00673 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_enabled00 00674 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_enabled00(lua_State* tolua_S) 00675 { 00676 #ifndef TOLUA_RELEASE 00677 tolua_Error tolua_err; 00678 if ( 00679 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00680 !tolua_isnoobj(tolua_S,2,&tolua_err) 00681 ) 00682 goto tolua_lerror; 00683 else 00684 #endif 00685 { 00686 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00687 #ifndef TOLUA_RELEASE 00688 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_enabled'", NULL); 00689 #endif 00690 { 00691 bool tolua_ret = (bool) self->is_enabled(); 00692 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00693 } 00694 } 00695 return 1; 00696 #ifndef TOLUA_RELEASE 00697 tolua_lerror: 00698 tolua_error(tolua_S,"#ferror in function 'is_enabled'.",&tolua_err); 00699 return 0; 00700 #endif 00701 } 00702 #endif //#ifndef TOLUA_DISABLE 00703 00704 /* method: set_enabled of class fawkes::SpeechRecognitionInterface */ 00705 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_enabled00 00706 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_enabled00(lua_State* tolua_S) 00707 { 00708 #ifndef TOLUA_RELEASE 00709 tolua_Error tolua_err; 00710 if ( 00711 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00712 !tolua_isboolean(tolua_S,2,0,&tolua_err) || 00713 !tolua_isnoobj(tolua_S,3,&tolua_err) 00714 ) 00715 goto tolua_lerror; 00716 else 00717 #endif 00718 { 00719 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00720 const bool new_enabled = ((const bool) tolua_toboolean(tolua_S,2,0)); 00721 #ifndef TOLUA_RELEASE 00722 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_enabled'", NULL); 00723 #endif 00724 { 00725 self->set_enabled(new_enabled); 00726 } 00727 } 00728 return 0; 00729 #ifndef TOLUA_RELEASE 00730 tolua_lerror: 00731 tolua_error(tolua_S,"#ferror in function 'set_enabled'.",&tolua_err); 00732 return 0; 00733 #endif 00734 } 00735 #endif //#ifndef TOLUA_DISABLE 00736 00737 /* method: maxlenof_enabled of class fawkes::SpeechRecognitionInterface */ 00738 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_enabled00 00739 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_enabled00(lua_State* tolua_S) 00740 { 00741 #ifndef TOLUA_RELEASE 00742 tolua_Error tolua_err; 00743 if ( 00744 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00745 !tolua_isnoobj(tolua_S,2,&tolua_err) 00746 ) 00747 goto tolua_lerror; 00748 else 00749 #endif 00750 { 00751 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00752 #ifndef TOLUA_RELEASE 00753 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'maxlenof_enabled'", NULL); 00754 #endif 00755 { 00756 int tolua_ret = (int) self->maxlenof_enabled(); 00757 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00758 } 00759 } 00760 return 1; 00761 #ifndef TOLUA_RELEASE 00762 tolua_lerror: 00763 tolua_error(tolua_S,"#ferror in function 'maxlenof_enabled'.",&tolua_err); 00764 return 0; 00765 #endif 00766 } 00767 #endif //#ifndef TOLUA_DISABLE 00768 00769 /* method: oftype of class fawkes::SpeechRecognitionInterface */ 00770 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_oftype00 00771 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_oftype00(lua_State* tolua_S) 00772 { 00773 #ifndef TOLUA_RELEASE 00774 tolua_Error tolua_err; 00775 if ( 00776 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00777 !tolua_isstring(tolua_S,2,0,&tolua_err) || 00778 !tolua_isnoobj(tolua_S,3,&tolua_err) 00779 ) 00780 goto tolua_lerror; 00781 else 00782 #endif 00783 { 00784 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00785 const char* interface_type = ((const char*) tolua_tostring(tolua_S,2,0)); 00786 #ifndef TOLUA_RELEASE 00787 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'oftype'", NULL); 00788 #endif 00789 { 00790 bool tolua_ret = (bool) self->oftype(interface_type); 00791 tolua_pushboolean(tolua_S,(bool)tolua_ret); 00792 } 00793 } 00794 return 1; 00795 #ifndef TOLUA_RELEASE 00796 tolua_lerror: 00797 tolua_error(tolua_S,"#ferror in function 'oftype'.",&tolua_err); 00798 return 0; 00799 #endif 00800 } 00801 #endif //#ifndef TOLUA_DISABLE 00802 00803 /* method: datachunk of class fawkes::SpeechRecognitionInterface */ 00804 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_datachunk00 00805 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_datachunk00(lua_State* tolua_S) 00806 { 00807 #ifndef TOLUA_RELEASE 00808 tolua_Error tolua_err; 00809 if ( 00810 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00811 !tolua_isnoobj(tolua_S,2,&tolua_err) 00812 ) 00813 goto tolua_lerror; 00814 else 00815 #endif 00816 { 00817 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00818 #ifndef TOLUA_RELEASE 00819 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datachunk'", NULL); 00820 #endif 00821 { 00822 const void* tolua_ret = (const void*) self->datachunk(); 00823 tolua_pushuserdata(tolua_S,(void*)tolua_ret); 00824 } 00825 } 00826 return 1; 00827 #ifndef TOLUA_RELEASE 00828 tolua_lerror: 00829 tolua_error(tolua_S,"#ferror in function 'datachunk'.",&tolua_err); 00830 return 0; 00831 #endif 00832 } 00833 #endif //#ifndef TOLUA_DISABLE 00834 00835 /* method: datasize of class fawkes::SpeechRecognitionInterface */ 00836 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_datasize00 00837 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_datasize00(lua_State* tolua_S) 00838 { 00839 #ifndef TOLUA_RELEASE 00840 tolua_Error tolua_err; 00841 if ( 00842 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00843 !tolua_isnoobj(tolua_S,2,&tolua_err) 00844 ) 00845 goto tolua_lerror; 00846 else 00847 #endif 00848 { 00849 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00850 #ifndef TOLUA_RELEASE 00851 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'datasize'", NULL); 00852 #endif 00853 { 00854 unsigned int tolua_ret = (unsigned int) self->datasize(); 00855 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00856 } 00857 } 00858 return 1; 00859 #ifndef TOLUA_RELEASE 00860 tolua_lerror: 00861 tolua_error(tolua_S,"#ferror in function 'datasize'.",&tolua_err); 00862 return 0; 00863 #endif 00864 } 00865 #endif //#ifndef TOLUA_DISABLE 00866 00867 /* method: type of class fawkes::SpeechRecognitionInterface */ 00868 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_type00 00869 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_type00(lua_State* tolua_S) 00870 { 00871 #ifndef TOLUA_RELEASE 00872 tolua_Error tolua_err; 00873 if ( 00874 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00875 !tolua_isnoobj(tolua_S,2,&tolua_err) 00876 ) 00877 goto tolua_lerror; 00878 else 00879 #endif 00880 { 00881 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00882 #ifndef TOLUA_RELEASE 00883 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'type'", NULL); 00884 #endif 00885 { 00886 const char* tolua_ret = (const char*) self->type(); 00887 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00888 } 00889 } 00890 return 1; 00891 #ifndef TOLUA_RELEASE 00892 tolua_lerror: 00893 tolua_error(tolua_S,"#ferror in function 'type'.",&tolua_err); 00894 return 0; 00895 #endif 00896 } 00897 #endif //#ifndef TOLUA_DISABLE 00898 00899 /* method: id of class fawkes::SpeechRecognitionInterface */ 00900 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_id00 00901 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_id00(lua_State* tolua_S) 00902 { 00903 #ifndef TOLUA_RELEASE 00904 tolua_Error tolua_err; 00905 if ( 00906 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00907 !tolua_isnoobj(tolua_S,2,&tolua_err) 00908 ) 00909 goto tolua_lerror; 00910 else 00911 #endif 00912 { 00913 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00914 #ifndef TOLUA_RELEASE 00915 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'id'", NULL); 00916 #endif 00917 { 00918 const char* tolua_ret = (const char*) self->id(); 00919 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00920 } 00921 } 00922 return 1; 00923 #ifndef TOLUA_RELEASE 00924 tolua_lerror: 00925 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err); 00926 return 0; 00927 #endif 00928 } 00929 #endif //#ifndef TOLUA_DISABLE 00930 00931 /* method: uid of class fawkes::SpeechRecognitionInterface */ 00932 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_uid00 00933 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_uid00(lua_State* tolua_S) 00934 { 00935 #ifndef TOLUA_RELEASE 00936 tolua_Error tolua_err; 00937 if ( 00938 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00939 !tolua_isnoobj(tolua_S,2,&tolua_err) 00940 ) 00941 goto tolua_lerror; 00942 else 00943 #endif 00944 { 00945 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00946 #ifndef TOLUA_RELEASE 00947 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'uid'", NULL); 00948 #endif 00949 { 00950 const char* tolua_ret = (const char*) self->uid(); 00951 tolua_pushstring(tolua_S,(const char*)tolua_ret); 00952 } 00953 } 00954 return 1; 00955 #ifndef TOLUA_RELEASE 00956 tolua_lerror: 00957 tolua_error(tolua_S,"#ferror in function 'uid'.",&tolua_err); 00958 return 0; 00959 #endif 00960 } 00961 #endif //#ifndef TOLUA_DISABLE 00962 00963 /* method: serial of class fawkes::SpeechRecognitionInterface */ 00964 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_serial00 00965 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_serial00(lua_State* tolua_S) 00966 { 00967 #ifndef TOLUA_RELEASE 00968 tolua_Error tolua_err; 00969 if ( 00970 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 00971 !tolua_isnoobj(tolua_S,2,&tolua_err) 00972 ) 00973 goto tolua_lerror; 00974 else 00975 #endif 00976 { 00977 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 00978 #ifndef TOLUA_RELEASE 00979 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'serial'", NULL); 00980 #endif 00981 { 00982 unsigned int tolua_ret = (unsigned int) self->serial(); 00983 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 00984 } 00985 } 00986 return 1; 00987 #ifndef TOLUA_RELEASE 00988 tolua_lerror: 00989 tolua_error(tolua_S,"#ferror in function 'serial'.",&tolua_err); 00990 return 0; 00991 #endif 00992 } 00993 #endif //#ifndef TOLUA_DISABLE 00994 00995 /* method: mem_serial of class fawkes::SpeechRecognitionInterface */ 00996 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_mem_serial00 00997 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_mem_serial00(lua_State* tolua_S) 00998 { 00999 #ifndef TOLUA_RELEASE 01000 tolua_Error tolua_err; 01001 if ( 01002 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01003 !tolua_isnoobj(tolua_S,2,&tolua_err) 01004 ) 01005 goto tolua_lerror; 01006 else 01007 #endif 01008 { 01009 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01010 #ifndef TOLUA_RELEASE 01011 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'mem_serial'", NULL); 01012 #endif 01013 { 01014 unsigned int tolua_ret = (unsigned int) self->mem_serial(); 01015 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01016 } 01017 } 01018 return 1; 01019 #ifndef TOLUA_RELEASE 01020 tolua_lerror: 01021 tolua_error(tolua_S,"#ferror in function 'mem_serial'.",&tolua_err); 01022 return 0; 01023 #endif 01024 } 01025 #endif //#ifndef TOLUA_DISABLE 01026 01027 /* method: operator== of class fawkes::SpeechRecognitionInterface */ 01028 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface__eq00 01029 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface__eq00(lua_State* tolua_S) 01030 { 01031 #ifndef TOLUA_RELEASE 01032 tolua_Error tolua_err; 01033 if ( 01034 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01035 (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Interface",0,&tolua_err)) || 01036 !tolua_isnoobj(tolua_S,3,&tolua_err) 01037 ) 01038 goto tolua_lerror; 01039 else 01040 #endif 01041 { 01042 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01043 Interface* comp = ((Interface*) tolua_tousertype(tolua_S,2,0)); 01044 #ifndef TOLUA_RELEASE 01045 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL); 01046 #endif 01047 { 01048 bool tolua_ret = (bool) self->operator==(*comp); 01049 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01050 } 01051 } 01052 return 1; 01053 #ifndef TOLUA_RELEASE 01054 tolua_lerror: 01055 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err); 01056 return 0; 01057 #endif 01058 } 01059 #endif //#ifndef TOLUA_DISABLE 01060 01061 /* method: hash of class fawkes::SpeechRecognitionInterface */ 01062 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash00 01063 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash00(lua_State* tolua_S) 01064 { 01065 #ifndef TOLUA_RELEASE 01066 tolua_Error tolua_err; 01067 if ( 01068 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01069 !tolua_isnoobj(tolua_S,2,&tolua_err) 01070 ) 01071 goto tolua_lerror; 01072 else 01073 #endif 01074 { 01075 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01076 #ifndef TOLUA_RELEASE 01077 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash'", NULL); 01078 #endif 01079 { 01080 unsigned const char* tolua_ret = ( unsigned const char*) self->hash(); 01081 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01082 } 01083 } 01084 return 1; 01085 #ifndef TOLUA_RELEASE 01086 tolua_lerror: 01087 tolua_error(tolua_S,"#ferror in function 'hash'.",&tolua_err); 01088 return 0; 01089 #endif 01090 } 01091 #endif //#ifndef TOLUA_DISABLE 01092 01093 /* method: hash_size of class fawkes::SpeechRecognitionInterface */ 01094 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash_size00 01095 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash_size00(lua_State* tolua_S) 01096 { 01097 #ifndef TOLUA_RELEASE 01098 tolua_Error tolua_err; 01099 if ( 01100 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01101 !tolua_isnoobj(tolua_S,2,&tolua_err) 01102 ) 01103 goto tolua_lerror; 01104 else 01105 #endif 01106 { 01107 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01108 #ifndef TOLUA_RELEASE 01109 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_size'", NULL); 01110 #endif 01111 { 01112 int tolua_ret = (int) self->hash_size(); 01113 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01114 } 01115 } 01116 return 1; 01117 #ifndef TOLUA_RELEASE 01118 tolua_lerror: 01119 tolua_error(tolua_S,"#ferror in function 'hash_size'.",&tolua_err); 01120 return 0; 01121 #endif 01122 } 01123 #endif //#ifndef TOLUA_DISABLE 01124 01125 /* method: hash_printable of class fawkes::SpeechRecognitionInterface */ 01126 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash_printable00 01127 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash_printable00(lua_State* tolua_S) 01128 { 01129 #ifndef TOLUA_RELEASE 01130 tolua_Error tolua_err; 01131 if ( 01132 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01133 !tolua_isnoobj(tolua_S,2,&tolua_err) 01134 ) 01135 goto tolua_lerror; 01136 else 01137 #endif 01138 { 01139 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01140 #ifndef TOLUA_RELEASE 01141 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hash_printable'", NULL); 01142 #endif 01143 { 01144 const char* tolua_ret = (const char*) self->hash_printable(); 01145 tolua_pushstring(tolua_S,(const char*)tolua_ret); 01146 } 01147 } 01148 return 1; 01149 #ifndef TOLUA_RELEASE 01150 tolua_lerror: 01151 tolua_error(tolua_S,"#ferror in function 'hash_printable'.",&tolua_err); 01152 return 0; 01153 #endif 01154 } 01155 #endif //#ifndef TOLUA_DISABLE 01156 01157 /* method: is_writer of class fawkes::SpeechRecognitionInterface */ 01158 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_writer00 01159 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_writer00(lua_State* tolua_S) 01160 { 01161 #ifndef TOLUA_RELEASE 01162 tolua_Error tolua_err; 01163 if ( 01164 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01165 !tolua_isnoobj(tolua_S,2,&tolua_err) 01166 ) 01167 goto tolua_lerror; 01168 else 01169 #endif 01170 { 01171 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01172 #ifndef TOLUA_RELEASE 01173 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_writer'", NULL); 01174 #endif 01175 { 01176 bool tolua_ret = (bool) self->is_writer(); 01177 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01178 } 01179 } 01180 return 1; 01181 #ifndef TOLUA_RELEASE 01182 tolua_lerror: 01183 tolua_error(tolua_S,"#ferror in function 'is_writer'.",&tolua_err); 01184 return 0; 01185 #endif 01186 } 01187 #endif //#ifndef TOLUA_DISABLE 01188 01189 /* method: set_from_chunk of class fawkes::SpeechRecognitionInterface */ 01190 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_from_chunk00 01191 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_from_chunk00(lua_State* tolua_S) 01192 { 01193 #ifndef TOLUA_RELEASE 01194 tolua_Error tolua_err; 01195 if ( 01196 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01197 !tolua_isuserdata(tolua_S,2,0,&tolua_err) || 01198 !tolua_isnoobj(tolua_S,3,&tolua_err) 01199 ) 01200 goto tolua_lerror; 01201 else 01202 #endif 01203 { 01204 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01205 void* chunk = ((void*) tolua_touserdata(tolua_S,2,0)); 01206 #ifndef TOLUA_RELEASE 01207 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set_from_chunk'", NULL); 01208 #endif 01209 { 01210 self->set_from_chunk(chunk); 01211 } 01212 } 01213 return 0; 01214 #ifndef TOLUA_RELEASE 01215 tolua_lerror: 01216 tolua_error(tolua_S,"#ferror in function 'set_from_chunk'.",&tolua_err); 01217 return 0; 01218 #endif 01219 } 01220 #endif //#ifndef TOLUA_DISABLE 01221 01222 /* method: create_message of class fawkes::SpeechRecognitionInterface */ 01223 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_create_message00 01224 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_create_message00(lua_State* tolua_S) 01225 { 01226 #ifndef TOLUA_RELEASE 01227 tolua_Error tolua_err; 01228 if ( 01229 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01230 !tolua_isstring(tolua_S,2,0,&tolua_err) || 01231 !tolua_isnoobj(tolua_S,3,&tolua_err) 01232 ) 01233 goto tolua_lerror; 01234 else 01235 #endif 01236 { 01237 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01238 const char* type = ((const char*) tolua_tostring(tolua_S,2,0)); 01239 #ifndef TOLUA_RELEASE 01240 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create_message'", NULL); 01241 #endif 01242 { 01243 Message* tolua_ret = (Message*) self->create_message(type); 01244 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 01245 } 01246 } 01247 return 1; 01248 #ifndef TOLUA_RELEASE 01249 tolua_lerror: 01250 tolua_error(tolua_S,"#ferror in function 'create_message'.",&tolua_err); 01251 return 0; 01252 #endif 01253 } 01254 #endif //#ifndef TOLUA_DISABLE 01255 01256 /* method: read of class fawkes::SpeechRecognitionInterface */ 01257 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_read00 01258 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_read00(lua_State* tolua_S) 01259 { 01260 #ifndef TOLUA_RELEASE 01261 tolua_Error tolua_err; 01262 if ( 01263 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01264 !tolua_isnoobj(tolua_S,2,&tolua_err) 01265 ) 01266 goto tolua_lerror; 01267 else 01268 #endif 01269 { 01270 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01271 #ifndef TOLUA_RELEASE 01272 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL); 01273 #endif 01274 { 01275 self->read(); 01276 } 01277 } 01278 return 0; 01279 #ifndef TOLUA_RELEASE 01280 tolua_lerror: 01281 tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err); 01282 return 0; 01283 #endif 01284 } 01285 #endif //#ifndef TOLUA_DISABLE 01286 01287 /* method: write of class fawkes::SpeechRecognitionInterface */ 01288 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_write00 01289 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_write00(lua_State* tolua_S) 01290 { 01291 #ifndef TOLUA_RELEASE 01292 tolua_Error tolua_err; 01293 if ( 01294 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01295 !tolua_isnoobj(tolua_S,2,&tolua_err) 01296 ) 01297 goto tolua_lerror; 01298 else 01299 #endif 01300 { 01301 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01302 #ifndef TOLUA_RELEASE 01303 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL); 01304 #endif 01305 { 01306 self->write(); 01307 } 01308 } 01309 return 0; 01310 #ifndef TOLUA_RELEASE 01311 tolua_lerror: 01312 tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err); 01313 return 0; 01314 #endif 01315 } 01316 #endif //#ifndef TOLUA_DISABLE 01317 01318 /* method: has_writer of class fawkes::SpeechRecognitionInterface */ 01319 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_has_writer00 01320 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_has_writer00(lua_State* tolua_S) 01321 { 01322 #ifndef TOLUA_RELEASE 01323 tolua_Error tolua_err; 01324 if ( 01325 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01326 !tolua_isnoobj(tolua_S,2,&tolua_err) 01327 ) 01328 goto tolua_lerror; 01329 else 01330 #endif 01331 { 01332 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01333 #ifndef TOLUA_RELEASE 01334 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'has_writer'", NULL); 01335 #endif 01336 { 01337 bool tolua_ret = (bool) self->has_writer(); 01338 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01339 } 01340 } 01341 return 1; 01342 #ifndef TOLUA_RELEASE 01343 tolua_lerror: 01344 tolua_error(tolua_S,"#ferror in function 'has_writer'.",&tolua_err); 01345 return 0; 01346 #endif 01347 } 01348 #endif //#ifndef TOLUA_DISABLE 01349 01350 /* method: num_readers of class fawkes::SpeechRecognitionInterface */ 01351 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_num_readers00 01352 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_num_readers00(lua_State* tolua_S) 01353 { 01354 #ifndef TOLUA_RELEASE 01355 tolua_Error tolua_err; 01356 if ( 01357 !tolua_isusertype(tolua_S,1,"const fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01358 !tolua_isnoobj(tolua_S,2,&tolua_err) 01359 ) 01360 goto tolua_lerror; 01361 else 01362 #endif 01363 { 01364 const fawkes::SpeechRecognitionInterface* self = (const fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01365 #ifndef TOLUA_RELEASE 01366 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'num_readers'", NULL); 01367 #endif 01368 { 01369 unsigned int tolua_ret = (unsigned int) self->num_readers(); 01370 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01371 } 01372 } 01373 return 1; 01374 #ifndef TOLUA_RELEASE 01375 tolua_lerror: 01376 tolua_error(tolua_S,"#ferror in function 'num_readers'.",&tolua_err); 01377 return 0; 01378 #endif 01379 } 01380 #endif //#ifndef TOLUA_DISABLE 01381 01382 /* method: msgq_enqueue_copy of class fawkes::SpeechRecognitionInterface */ 01383 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_enqueue_copy00 01384 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_enqueue_copy00(lua_State* tolua_S) 01385 { 01386 #ifndef TOLUA_RELEASE 01387 tolua_Error tolua_err; 01388 if ( 01389 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01390 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 01391 !tolua_isnoobj(tolua_S,3,&tolua_err) 01392 ) 01393 goto tolua_lerror; 01394 else 01395 #endif 01396 { 01397 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01398 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 01399 #ifndef TOLUA_RELEASE 01400 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_enqueue_copy'", NULL); 01401 #endif 01402 { 01403 unsigned int tolua_ret = (unsigned int) self->msgq_enqueue_copy(message); 01404 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01405 } 01406 } 01407 return 1; 01408 #ifndef TOLUA_RELEASE 01409 tolua_lerror: 01410 tolua_error(tolua_S,"#ferror in function 'msgq_enqueue_copy'.",&tolua_err); 01411 return 0; 01412 #endif 01413 } 01414 #endif //#ifndef TOLUA_DISABLE 01415 01416 /* method: msgq_remove of class fawkes::SpeechRecognitionInterface */ 01417 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_remove00 01418 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_remove00(lua_State* tolua_S) 01419 { 01420 #ifndef TOLUA_RELEASE 01421 tolua_Error tolua_err; 01422 if ( 01423 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01424 !tolua_isusertype(tolua_S,2,"Message",0,&tolua_err) || 01425 !tolua_isnoobj(tolua_S,3,&tolua_err) 01426 ) 01427 goto tolua_lerror; 01428 else 01429 #endif 01430 { 01431 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01432 Message* message = ((Message*) tolua_tousertype(tolua_S,2,0)); 01433 #ifndef TOLUA_RELEASE 01434 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 01435 #endif 01436 { 01437 self->msgq_remove(message); 01438 } 01439 } 01440 return 0; 01441 #ifndef TOLUA_RELEASE 01442 tolua_lerror: 01443 tolua_error(tolua_S,"#ferror in function 'msgq_remove'.",&tolua_err); 01444 return 0; 01445 #endif 01446 } 01447 #endif //#ifndef TOLUA_DISABLE 01448 01449 /* method: msgq_remove of class fawkes::SpeechRecognitionInterface */ 01450 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_remove01 01451 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_remove01(lua_State* tolua_S) 01452 { 01453 tolua_Error tolua_err; 01454 if ( 01455 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01456 !tolua_isnumber(tolua_S,2,0,&tolua_err) || 01457 !tolua_isnoobj(tolua_S,3,&tolua_err) 01458 ) 01459 goto tolua_lerror; 01460 else 01461 { 01462 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01463 unsigned int message_id = ((unsigned int) tolua_tonumber(tolua_S,2,0)); 01464 #ifndef TOLUA_RELEASE 01465 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_remove'", NULL); 01466 #endif 01467 { 01468 self->msgq_remove(message_id); 01469 } 01470 } 01471 return 0; 01472 tolua_lerror: 01473 return tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_remove00(tolua_S); 01474 } 01475 #endif //#ifndef TOLUA_DISABLE 01476 01477 /* method: msgq_size of class fawkes::SpeechRecognitionInterface */ 01478 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_size00 01479 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_size00(lua_State* tolua_S) 01480 { 01481 #ifndef TOLUA_RELEASE 01482 tolua_Error tolua_err; 01483 if ( 01484 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01485 !tolua_isnoobj(tolua_S,2,&tolua_err) 01486 ) 01487 goto tolua_lerror; 01488 else 01489 #endif 01490 { 01491 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01492 #ifndef TOLUA_RELEASE 01493 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_size'", NULL); 01494 #endif 01495 { 01496 unsigned int tolua_ret = (unsigned int) self->msgq_size(); 01497 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret); 01498 } 01499 } 01500 return 1; 01501 #ifndef TOLUA_RELEASE 01502 tolua_lerror: 01503 tolua_error(tolua_S,"#ferror in function 'msgq_size'.",&tolua_err); 01504 return 0; 01505 #endif 01506 } 01507 #endif //#ifndef TOLUA_DISABLE 01508 01509 /* method: msgq_flush of class fawkes::SpeechRecognitionInterface */ 01510 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_flush00 01511 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_flush00(lua_State* tolua_S) 01512 { 01513 #ifndef TOLUA_RELEASE 01514 tolua_Error tolua_err; 01515 if ( 01516 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01517 !tolua_isnoobj(tolua_S,2,&tolua_err) 01518 ) 01519 goto tolua_lerror; 01520 else 01521 #endif 01522 { 01523 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01524 #ifndef TOLUA_RELEASE 01525 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_flush'", NULL); 01526 #endif 01527 { 01528 self->msgq_flush(); 01529 } 01530 } 01531 return 0; 01532 #ifndef TOLUA_RELEASE 01533 tolua_lerror: 01534 tolua_error(tolua_S,"#ferror in function 'msgq_flush'.",&tolua_err); 01535 return 0; 01536 #endif 01537 } 01538 #endif //#ifndef TOLUA_DISABLE 01539 01540 /* method: msgq_lock of class fawkes::SpeechRecognitionInterface */ 01541 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_lock00 01542 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_lock00(lua_State* tolua_S) 01543 { 01544 #ifndef TOLUA_RELEASE 01545 tolua_Error tolua_err; 01546 if ( 01547 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01548 !tolua_isnoobj(tolua_S,2,&tolua_err) 01549 ) 01550 goto tolua_lerror; 01551 else 01552 #endif 01553 { 01554 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01555 #ifndef TOLUA_RELEASE 01556 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_lock'", NULL); 01557 #endif 01558 { 01559 self->msgq_lock(); 01560 } 01561 } 01562 return 0; 01563 #ifndef TOLUA_RELEASE 01564 tolua_lerror: 01565 tolua_error(tolua_S,"#ferror in function 'msgq_lock'.",&tolua_err); 01566 return 0; 01567 #endif 01568 } 01569 #endif //#ifndef TOLUA_DISABLE 01570 01571 /* method: msgq_try_lock of class fawkes::SpeechRecognitionInterface */ 01572 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_try_lock00 01573 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_try_lock00(lua_State* tolua_S) 01574 { 01575 #ifndef TOLUA_RELEASE 01576 tolua_Error tolua_err; 01577 if ( 01578 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01579 !tolua_isnoobj(tolua_S,2,&tolua_err) 01580 ) 01581 goto tolua_lerror; 01582 else 01583 #endif 01584 { 01585 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01586 #ifndef TOLUA_RELEASE 01587 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_try_lock'", NULL); 01588 #endif 01589 { 01590 bool tolua_ret = (bool) self->msgq_try_lock(); 01591 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01592 } 01593 } 01594 return 1; 01595 #ifndef TOLUA_RELEASE 01596 tolua_lerror: 01597 tolua_error(tolua_S,"#ferror in function 'msgq_try_lock'.",&tolua_err); 01598 return 0; 01599 #endif 01600 } 01601 #endif //#ifndef TOLUA_DISABLE 01602 01603 /* method: msgq_unlock of class fawkes::SpeechRecognitionInterface */ 01604 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_unlock00 01605 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_unlock00(lua_State* tolua_S) 01606 { 01607 #ifndef TOLUA_RELEASE 01608 tolua_Error tolua_err; 01609 if ( 01610 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01611 !tolua_isnoobj(tolua_S,2,&tolua_err) 01612 ) 01613 goto tolua_lerror; 01614 else 01615 #endif 01616 { 01617 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01618 #ifndef TOLUA_RELEASE 01619 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_unlock'", NULL); 01620 #endif 01621 { 01622 self->msgq_unlock(); 01623 } 01624 } 01625 return 0; 01626 #ifndef TOLUA_RELEASE 01627 tolua_lerror: 01628 tolua_error(tolua_S,"#ferror in function 'msgq_unlock'.",&tolua_err); 01629 return 0; 01630 #endif 01631 } 01632 #endif //#ifndef TOLUA_DISABLE 01633 01634 /* method: msgq_pop of class fawkes::SpeechRecognitionInterface */ 01635 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_pop00 01636 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_pop00(lua_State* tolua_S) 01637 { 01638 #ifndef TOLUA_RELEASE 01639 tolua_Error tolua_err; 01640 if ( 01641 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01642 !tolua_isnoobj(tolua_S,2,&tolua_err) 01643 ) 01644 goto tolua_lerror; 01645 else 01646 #endif 01647 { 01648 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01649 #ifndef TOLUA_RELEASE 01650 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_pop'", NULL); 01651 #endif 01652 { 01653 self->msgq_pop(); 01654 } 01655 } 01656 return 0; 01657 #ifndef TOLUA_RELEASE 01658 tolua_lerror: 01659 tolua_error(tolua_S,"#ferror in function 'msgq_pop'.",&tolua_err); 01660 return 0; 01661 #endif 01662 } 01663 #endif //#ifndef TOLUA_DISABLE 01664 01665 /* method: msgq_first of class fawkes::SpeechRecognitionInterface */ 01666 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_first00 01667 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_first00(lua_State* tolua_S) 01668 { 01669 #ifndef TOLUA_RELEASE 01670 tolua_Error tolua_err; 01671 if ( 01672 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01673 !tolua_isnoobj(tolua_S,2,&tolua_err) 01674 ) 01675 goto tolua_lerror; 01676 else 01677 #endif 01678 { 01679 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01680 #ifndef TOLUA_RELEASE 01681 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_first'", NULL); 01682 #endif 01683 { 01684 Message* tolua_ret = (Message*) self->msgq_first(); 01685 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Message"); 01686 } 01687 } 01688 return 1; 01689 #ifndef TOLUA_RELEASE 01690 tolua_lerror: 01691 tolua_error(tolua_S,"#ferror in function 'msgq_first'.",&tolua_err); 01692 return 0; 01693 #endif 01694 } 01695 #endif //#ifndef TOLUA_DISABLE 01696 01697 /* method: msgq_empty of class fawkes::SpeechRecognitionInterface */ 01698 #ifndef TOLUA_DISABLE_tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_empty00 01699 static int tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_empty00(lua_State* tolua_S) 01700 { 01701 #ifndef TOLUA_RELEASE 01702 tolua_Error tolua_err; 01703 if ( 01704 !tolua_isusertype(tolua_S,1,"fawkes::SpeechRecognitionInterface",0,&tolua_err) || 01705 !tolua_isnoobj(tolua_S,2,&tolua_err) 01706 ) 01707 goto tolua_lerror; 01708 else 01709 #endif 01710 { 01711 fawkes::SpeechRecognitionInterface* self = (fawkes::SpeechRecognitionInterface*) tolua_tousertype(tolua_S,1,0); 01712 #ifndef TOLUA_RELEASE 01713 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'msgq_empty'", NULL); 01714 #endif 01715 { 01716 bool tolua_ret = (bool) self->msgq_empty(); 01717 tolua_pushboolean(tolua_S,(bool)tolua_ret); 01718 } 01719 } 01720 return 1; 01721 #ifndef TOLUA_RELEASE 01722 tolua_lerror: 01723 tolua_error(tolua_S,"#ferror in function 'msgq_empty'.",&tolua_err); 01724 return 0; 01725 #endif 01726 } 01727 #endif //#ifndef TOLUA_DISABLE 01728 01729 /* Open function */ 01730 TOLUA_API int tolua_interfaces_SpeechRecognitionInterface_open (lua_State* tolua_S) 01731 { 01732 tolua_open(tolua_S); 01733 tolua_reg_types(tolua_S); 01734 tolua_module(tolua_S,NULL,0); 01735 tolua_beginmodule(tolua_S,NULL); 01736 tolua_module(tolua_S,"fawkes",0); 01737 tolua_beginmodule(tolua_S,"fawkes"); 01738 tolua_cclass(tolua_S,"SpeechRecognitionInterface","fawkes::SpeechRecognitionInterface","Interface",NULL); 01739 tolua_beginmodule(tolua_S,"SpeechRecognitionInterface"); 01740 #ifdef __cplusplus 01741 tolua_cclass(tolua_S,"ResetMessage","fawkes::SpeechRecognitionInterface::ResetMessage","Message",tolua_collect_fawkes__SpeechRecognitionInterface__ResetMessage); 01742 #else 01743 tolua_cclass(tolua_S,"ResetMessage","fawkes::SpeechRecognitionInterface::ResetMessage","Message",NULL); 01744 #endif 01745 tolua_beginmodule(tolua_S,"ResetMessage"); 01746 tolua_function(tolua_S,"new",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_new00); 01747 tolua_function(tolua_S,"new_local",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_new00_local); 01748 tolua_function(tolua_S,".call",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_new00_local); 01749 tolua_function(tolua_S,"delete",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_ResetMessage_delete00); 01750 tolua_endmodule(tolua_S); 01751 #ifdef __cplusplus 01752 tolua_cclass(tolua_S,"SetEnabledMessage","fawkes::SpeechRecognitionInterface::SetEnabledMessage","Message",tolua_collect_fawkes__SpeechRecognitionInterface__SetEnabledMessage); 01753 #else 01754 tolua_cclass(tolua_S,"SetEnabledMessage","fawkes::SpeechRecognitionInterface::SetEnabledMessage","Message",NULL); 01755 #endif 01756 tolua_beginmodule(tolua_S,"SetEnabledMessage"); 01757 tolua_function(tolua_S,"new",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00); 01758 tolua_function(tolua_S,"new_local",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00_local); 01759 tolua_function(tolua_S,".call",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new00_local); 01760 tolua_function(tolua_S,"new",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new01); 01761 tolua_function(tolua_S,"new_local",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new01_local); 01762 tolua_function(tolua_S,".call",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_new01_local); 01763 tolua_function(tolua_S,"delete",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_delete00); 01764 tolua_function(tolua_S,"is_enabled",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_is_enabled00); 01765 tolua_function(tolua_S,"set_enabled",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_set_enabled00); 01766 tolua_function(tolua_S,"maxlenof_enabled",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_SetEnabledMessage_maxlenof_enabled00); 01767 tolua_endmodule(tolua_S); 01768 tolua_function(tolua_S,"text",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_text00); 01769 tolua_function(tolua_S,"set_text",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_text00); 01770 tolua_function(tolua_S,"maxlenof_text",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_text00); 01771 tolua_function(tolua_S,"counter",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_counter00); 01772 tolua_function(tolua_S,"set_counter",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_counter00); 01773 tolua_function(tolua_S,"maxlenof_counter",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_counter00); 01774 tolua_function(tolua_S,"is_processing",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_processing00); 01775 tolua_function(tolua_S,"set_processing",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_processing00); 01776 tolua_function(tolua_S,"maxlenof_processing",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_processing00); 01777 tolua_function(tolua_S,"is_enabled",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_enabled00); 01778 tolua_function(tolua_S,"set_enabled",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_enabled00); 01779 tolua_function(tolua_S,"maxlenof_enabled",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_maxlenof_enabled00); 01780 tolua_function(tolua_S,"oftype",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_oftype00); 01781 tolua_function(tolua_S,"datachunk",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_datachunk00); 01782 tolua_function(tolua_S,"datasize",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_datasize00); 01783 tolua_function(tolua_S,"type",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_type00); 01784 tolua_function(tolua_S,"id",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_id00); 01785 tolua_function(tolua_S,"uid",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_uid00); 01786 tolua_function(tolua_S,"serial",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_serial00); 01787 tolua_function(tolua_S,"mem_serial",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_mem_serial00); 01788 tolua_function(tolua_S,".eq",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface__eq00); 01789 tolua_function(tolua_S,"hash",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash00); 01790 tolua_function(tolua_S,"hash_size",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash_size00); 01791 tolua_function(tolua_S,"hash_printable",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_hash_printable00); 01792 tolua_function(tolua_S,"is_writer",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_is_writer00); 01793 tolua_function(tolua_S,"set_from_chunk",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_set_from_chunk00); 01794 tolua_function(tolua_S,"create_message",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_create_message00); 01795 tolua_function(tolua_S,"read",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_read00); 01796 tolua_function(tolua_S,"write",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_write00); 01797 tolua_function(tolua_S,"has_writer",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_has_writer00); 01798 tolua_function(tolua_S,"num_readers",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_num_readers00); 01799 tolua_function(tolua_S,"msgq_enqueue_copy",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_enqueue_copy00); 01800 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_remove00); 01801 tolua_function(tolua_S,"msgq_remove",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_remove01); 01802 tolua_function(tolua_S,"msgq_size",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_size00); 01803 tolua_function(tolua_S,"msgq_flush",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_flush00); 01804 tolua_function(tolua_S,"msgq_lock",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_lock00); 01805 tolua_function(tolua_S,"msgq_try_lock",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_try_lock00); 01806 tolua_function(tolua_S,"msgq_unlock",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_unlock00); 01807 tolua_function(tolua_S,"msgq_pop",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_pop00); 01808 tolua_function(tolua_S,"msgq_first",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_first00); 01809 tolua_function(tolua_S,"msgq_empty",tolua_interfaces_SpeechRecognitionInterface_fawkes_SpeechRecognitionInterface_msgq_empty00); 01810 tolua_endmodule(tolua_S); 01811 tolua_endmodule(tolua_S); 01812 tolua_endmodule(tolua_S); 01813 return 1; 01814 } 01815 01816 01817 extern "C" { 01818 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501 01819 TOLUA_API int luaopen_interfaces_SpeechRecognitionInterface (lua_State* tolua_S) { 01820 return tolua_interfaces_SpeechRecognitionInterface_open(tolua_S); 01821 }; 01822 #endif 01823 } 01824 01825