---

clanbindings.cpp

Go to the documentation of this file.

/*
** Lua binding: clanLua
** Generated automatically by tolua 3.2 on Fri Jan 14 02:35:30 2000.
*/

/* Exported function */
int  tolua_clanLua_open (void);
void tolua_clanLua_close (void);

/* Automatic initialization for C++ code */
#ifdef __cplusplus
 static int dummy = tolua_clanLua_open ();
#endif

#include "tolua/tolua.h"

#include "../API/core.h"
#include "../API/Display/Display/display.h"
#include "../API/Display/Display/surface.h"
#include "../API/Display/Display/surfaceprovider.h"
#include "../API/Display/SurfaceProviders/canvas.h"
#include "../API/Display/Display/target.h"
#include "../API/Display/Input/mouse.h"
#include "../API/Display/Input/keyboard.h"
#include "../API/Display/Input/key.h"

#define TRUE    1
#define FALSE   0

/* tag variables */
static int tolua_tag_CL_Display;
static int tolua_tag_CL_Palette;
static int tolua_tag_CL_DisplayCard;
static int tolua_tag_CL_VidMode;
static int tolua_tag_const_CL_ClipRect;
static int tolua_tag_CL_ClipRect;
static int tolua_tag_CL_System;
static int tolua_tag_CL_Mouse;
static int tolua_tag_CL_InputDevice;
static int tolua_tag_CL_Keyboard;
static int tolua_tag_CL_Surface;
static int tolua_tag_CL_ResourceManager;
static int tolua_tag_CL_SurfaceProvider;
static int tolua_tag_const_CL_Surface;
static int tolua_tag_CL_Target;
static int tolua_tag_const_CL_Target;
static int tolua_tag_CL_Canvas;

/* function to register type and initialize tag */
static void toluaI_init_tag (void)
{
 tolua_usertype("CL_Display");
 tolua_usertype("CL_DisplayCard");
 tolua_usertype("CL_Mouse");
 tolua_usertype("CL_SurfaceProvider");
 tolua_usertype("CL_Palette");
 tolua_usertype("CL_Canvas");
 tolua_usertype("CL_Keyboard");
 tolua_usertype("CL_Surface");
 tolua_usertype("CL_Target");
 tolua_usertype("CL_ClipRect");
 tolua_usertype("CL_System");
 tolua_usertype("CL_InputDevice");
 tolua_usertype("CL_ResourceManager");
 tolua_usertype("CL_VidMode");
 tolua_settag("CL_ClipRect",&tolua_tag_CL_ClipRect);
 tolua_settag("const CL_ClipRect",&tolua_tag_const_CL_ClipRect);
 tolua_settag("CL_Display",&tolua_tag_CL_Display);
 tolua_settag("CL_Mouse",&tolua_tag_CL_Mouse);
 tolua_settag("CL_Target",&tolua_tag_CL_Target);
 tolua_settag("CL_VidMode",&tolua_tag_CL_VidMode);
 tolua_settag("const CL_Surface",&tolua_tag_const_CL_Surface);
 tolua_settag("CL_System",&tolua_tag_CL_System);
 tolua_settag("CL_InputDevice",&tolua_tag_CL_InputDevice);
 tolua_settag("CL_Canvas",&tolua_tag_CL_Canvas);
 tolua_settag("CL_Palette",&tolua_tag_CL_Palette);
 tolua_settag("CL_Surface",&tolua_tag_CL_Surface);
 tolua_settag("CL_SurfaceProvider",&tolua_tag_CL_SurfaceProvider);
 tolua_settag("CL_DisplayCard",&tolua_tag_CL_DisplayCard);
 tolua_settag("CL_Keyboard",&tolua_tag_CL_Keyboard);
 tolua_settag("CL_ResourceManager",&tolua_tag_CL_ResourceManager);
 tolua_settag("const CL_Target",&tolua_tag_const_CL_Target);
}

/* method: delete of class  CL_Display */
static void toluaI_CL_Display_delete0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Display,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Display* self = (CL_Display*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'delete'");
  delete self;
 }
 return;
error:
 tolua_error("#ferror in function 'delete'.");
}

/* method: flip_display of class  CL_Display */
static void toluaI_CL_Display_flip_display0(void)
{
 if (
     !tolua_istype(2,tolua_tag_number,1) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  int sync = ((int)  tolua_getnumber(2,0));
  {
   CL_Display::flip_display(sync);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'flip_display'.");
}

/* method: clear_display of class  CL_Display */
static void toluaI_CL_Display_clear_display0(void)
{
 if (
     !tolua_istype(2,tolua_tag_number,1) ||
     !tolua_istype(3,tolua_tag_number,1) ||
     !tolua_istype(4,tolua_tag_number,1) ||
     !tolua_istype(5,tolua_tag_number,1) ||
     !tolua_isnoobj(6)
 )
  goto error;
 else
 {
  float red = ((float)  tolua_getnumber(2,0));
  float green = ((float)  tolua_getnumber(3,0));
  float blue = ((float)  tolua_getnumber(4,0));
  float alpha = ((float)  tolua_getnumber(5,1));
  {
   CL_Display::clear_display(red,green,blue,alpha);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'clear_display'.");
}

/* method: set_palette of class  CL_Display */
static void toluaI_CL_Display_set_palette0(void)
{
 if (
     !tolua_istype(2,tolua_tag_CL_Palette,0) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  CL_Palette* palette = ((CL_Palette*)  tolua_getusertype(2,0));
  {
   CL_Display::set_palette(palette);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'set_palette'.");
}

/* method: get_palette of class  CL_Display */
static void toluaI_CL_Display_get_palette0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   CL_Palette* toluaI_ret = CL_Display::get_palette();
   tolua_pushusertype((void*)toluaI_ret,tolua_tag_CL_Palette);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_palette'.");
}

/* method: select_card of class  CL_Display */
static void toluaI_CL_Display_select_card0(void)
{
 if (
     !tolua_istype(2,tolua_tag_CL_DisplayCard,0) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  CL_DisplayCard* card = ((CL_DisplayCard*)  tolua_getusertype(2,0));
  {
   CL_Display::select_card(card);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'select_card'.");
}

/* method: get_current_card of class  CL_Display */
static void toluaI_CL_Display_get_current_card0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   CL_DisplayCard* toluaI_ret = CL_Display::get_current_card();
   tolua_pushusertype((void*)toluaI_ret,tolua_tag_CL_DisplayCard);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_current_card'.");
}

/* method: set_videomode of class  CL_Display */
static void toluaI_CL_Display_set_videomode0(void)
{
 if (
     !tolua_istype(2,tolua_tag_CL_VidMode,0) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  CL_VidMode* mode = ((CL_VidMode*)  tolua_getusertype(2,0));
  {
   CL_Display::set_videomode(mode);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'set_videomode'.");
}

/* method: set_videomode of class  CL_Display */
static void toluaI_CL_Display_set_videomode1(void)
{
 if (
     !tolua_istype(2,tolua_tag_number,0) ||
     !tolua_istype(3,tolua_tag_number,0) ||
     !tolua_istype(4,tolua_tag_number,0) ||
     !tolua_isnoobj(5)
 )
  goto error;
 else
 {
  int width = ((int)  tolua_getnumber(2,0));
  int height = ((int)  tolua_getnumber(3,0));
  int bpp = ((int)  tolua_getnumber(4,0));
  {
   CL_Display::set_videomode(width,height,bpp);
  }
 }
 return;
error:
 toluaI_CL_Display_set_videomode0();
}

/* method: get_width of class  CL_Display */
static void toluaI_CL_Display_get_width0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   int toluaI_ret = CL_Display::get_width();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_width'.");
}

/* method: get_height of class  CL_Display */
static void toluaI_CL_Display_get_height0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   int toluaI_ret = CL_Display::get_height();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_height'.");
}

/* method: get_bpp of class  CL_Display */
static void toluaI_CL_Display_get_bpp0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   int toluaI_ret = CL_Display::get_bpp();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_bpp'.");
}

/* method: push_clip_rect of class  CL_Display */
static void toluaI_CL_Display_push_clip_rect0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   CL_Display::push_clip_rect();
  }
 }
 return;
error:
 tolua_error("#ferror in function 'push_clip_rect'.");
}

/* method: push_clip_rect of class  CL_Display */
static void toluaI_CL_Display_push_clip_rect1(void)
{
 if (
     !tolua_istype(2,tolua_tag_const_CL_ClipRect,0) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  const CL_ClipRect* rect = ((const CL_ClipRect*)  tolua_getusertype(2,0));
  {
   CL_Display::push_clip_rect(*rect);
  }
 }
 return;
error:
 toluaI_CL_Display_push_clip_rect0();
}

/* method: get_clip_rect of class  CL_Display */
static void toluaI_CL_Display_get_clip_rect0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   CL_ClipRect toluaI_ret = CL_Display::get_clip_rect();
   {
#ifdef __cplusplus
    void* toluaI_clone = new CL_ClipRect(toluaI_ret);
#else
    void* toluaI_clone = tolua_copy((void*)&toluaI_ret,sizeof(CL_ClipRect));
#endif
    tolua_pushusertype(tolua_doclone(toluaI_clone,tolua_tag_CL_ClipRect),tolua_tag_CL_ClipRect);
   }
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_clip_rect'.");
}

/* method: set_clip_rect of class  CL_Display */
static void toluaI_CL_Display_set_clip_rect0(void)
{
 if (
     !tolua_istype(2,tolua_tag_const_CL_ClipRect,0) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  const CL_ClipRect* rect = ((const CL_ClipRect*)  tolua_getusertype(2,0));
  {
   CL_Display::set_clip_rect(*rect);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'set_clip_rect'.");
}

/* method: pop_clip_rect of class  CL_Display */
static void toluaI_CL_Display_pop_clip_rect0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   CL_Display::pop_clip_rect();
  }
 }
 return;
error:
 tolua_error("#ferror in function 'pop_clip_rect'.");
}

/* method: fill_rect of class  CL_Display */
static void toluaI_CL_Display_fill_rect0(void)
{
 if (
     !tolua_istype(2,tolua_tag_number,0) ||
     !tolua_istype(3,tolua_tag_number,0) ||
     !tolua_istype(4,tolua_tag_number,0) ||
     !tolua_istype(5,tolua_tag_number,0) ||
     !tolua_istype(6,tolua_tag_number,0) ||
     !tolua_istype(7,tolua_tag_number,0) ||
     !tolua_istype(8,tolua_tag_number,0) ||
     !tolua_istype(9,tolua_tag_number,0) ||
     !tolua_isnoobj(10)
 )
  goto error;
 else
 {
  int x1 = ((int)  tolua_getnumber(2,0));
  int y1 = ((int)  tolua_getnumber(3,0));
  int x2 = ((int)  tolua_getnumber(4,0));
  int y2 = ((int)  tolua_getnumber(5,0));
  float r = ((float)  tolua_getnumber(6,0));
  float g = ((float)  tolua_getnumber(7,0));
  float b = ((float)  tolua_getnumber(8,0));
  float a = ((float)  tolua_getnumber(9,0));
  {
   CL_Display::fill_rect(x1,y1,x2,y2,r,g,b,a);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'fill_rect'.");
}

/* method: draw_line of class  CL_Display */
static void toluaI_CL_Display_draw_line0(void)
{
 if (
     !tolua_istype(2,tolua_tag_number,0) ||
     !tolua_istype(3,tolua_tag_number,0) ||
     !tolua_istype(4,tolua_tag_number,0) ||
     !tolua_istype(5,tolua_tag_number,0) ||
     !tolua_istype(6,tolua_tag_number,0) ||
     !tolua_istype(7,tolua_tag_number,0) ||
     !tolua_istype(8,tolua_tag_number,0) ||
     !tolua_istype(9,tolua_tag_number,0) ||
     !tolua_isnoobj(10)
 )
  goto error;
 else
 {
  int x1 = ((int)  tolua_getnumber(2,0));
  int y1 = ((int)  tolua_getnumber(3,0));
  int x2 = ((int)  tolua_getnumber(4,0));
  int y2 = ((int)  tolua_getnumber(5,0));
  float r = ((float)  tolua_getnumber(6,0));
  float g = ((float)  tolua_getnumber(7,0));
  float b = ((float)  tolua_getnumber(8,0));
  float a = ((float)  tolua_getnumber(9,0));
  {
   CL_Display::draw_line(x1,y1,x2,y2,r,g,b,a);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'draw_line'.");
}

/* method: sync_buffers of class  CL_Display */
static void toluaI_CL_Display_sync_buffers0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   CL_Display::sync_buffers();
  }
 }
 return;
error:
 tolua_error("#ferror in function 'sync_buffers'.");
}

/* method: keep_alive of class  CL_System */
static void toluaI_CL_System_keep_alive0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   CL_System::keep_alive();
  }
 }
 return;
error:
 tolua_error("#ferror in function 'keep_alive'.");
}

/* method: sleep of class  CL_System */
static void toluaI_CL_System_sleep0(void)
{
 if (
     !tolua_istype(2,tolua_tag_number,0) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  int millis = ((int)  tolua_getnumber(2,0));
  {
   CL_System::sleep(millis);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'sleep'.");
}

/* method: get_time of class  CL_System */
static void toluaI_CL_System_get_time0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   unsigned int toluaI_ret = CL_System::get_time();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_time'.");
}

/* method: delete of class  CL_Mouse */
static void toluaI_CL_Mouse_delete0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Mouse,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Mouse* self = (CL_Mouse*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'delete'");
  delete self;
 }
 return;
error:
 tolua_error("#ferror in function 'delete'.");
}

/* method: get_x of class  CL_Mouse */
static void toluaI_CL_Mouse_get_x0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   int toluaI_ret = CL_Mouse::get_x();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_x'.");
}

/* method: get_y of class  CL_Mouse */
static void toluaI_CL_Mouse_get_y0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   int toluaI_ret = CL_Mouse::get_y();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_y'.");
}

/* method: left_pressed of class  CL_Mouse */
static void toluaI_CL_Mouse_left_pressed0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   bool toluaI_ret = CL_Mouse::left_pressed();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'left_pressed'.");
}

/* method: middle_pressed of class  CL_Mouse */
static void toluaI_CL_Mouse_middle_pressed0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   int toluaI_ret = CL_Mouse::middle_pressed();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'middle_pressed'.");
}

/* method: right_pressed of class  CL_Mouse */
static void toluaI_CL_Mouse_right_pressed0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   int toluaI_ret = CL_Mouse::right_pressed();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'right_pressed'.");
}

/* method: delete of class  CL_Keyboard */
static void toluaI_CL_Keyboard_delete0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Keyboard,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Keyboard* self = (CL_Keyboard*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'delete'");
  delete self;
 }
 return;
error:
 tolua_error("#ferror in function 'delete'.");
}

/* method: get_keycode of class  CL_Keyboard */
static void toluaI_CL_Keyboard_get_keycode0(void)
{
 if (
     !tolua_istype(2,tolua_tag_number,0) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  int button_no = ((int)  tolua_getnumber(2,0));
  {
   int toluaI_ret = CL_Keyboard::get_keycode(button_no);
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_keycode'.");
}

/* method: load of class  CL_Surface */
static void toluaI_CL_Surface_load0(void)
{
 if (
     !tolua_istype(2,tolua_tag_string,0) ||
     !tolua_istype(3,tolua_tag_CL_ResourceManager,0) ||
     !tolua_isnoobj(4)
 )
  goto error;
 else
 {
  const char* resource_id = ((const char*)  tolua_getstring(2,0));
  CL_ResourceManager* manager = ((CL_ResourceManager*)  tolua_getusertype(3,0));
  {
   CL_Surface* toluaI_ret = CL_Surface::load(resource_id,manager);
   tolua_pushusertype((void*)toluaI_ret,tolua_tag_CL_Surface);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'load'.");
}

/* method: create of class  CL_Surface */
static void toluaI_CL_Surface_create0(void)
{
 if (
     !tolua_istype(2,tolua_tag_CL_SurfaceProvider,0) ||
     !tolua_istype(3,tolua_tag_number,0) ||
     !tolua_isnoobj(4)
 )
  goto error;
 else
 {
  CL_SurfaceProvider* provider = ((CL_SurfaceProvider*)  tolua_getusertype(2,0));
  int delete_provider = ((int)  tolua_getnumber(3,0));
  {
   CL_Surface* toluaI_ret = CL_Surface::create(provider,delete_provider);
   tolua_pushusertype((void*)toluaI_ret,tolua_tag_CL_Surface);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'create'.");
}

/* method: delete of class  CL_Surface */
static void toluaI_CL_Surface_delete0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Surface,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Surface* self = (CL_Surface*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'delete'");
  delete self;
 }
 return;
error:
 tolua_error("#ferror in function 'delete'.");
}

/* method: reload of class  CL_Surface */
static void toluaI_CL_Surface_reload0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Surface,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Surface* self = (CL_Surface*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'reload'");
  {
   self->reload();
  }
 }
 return;
error:
 tolua_error("#ferror in function 'reload'.");
}

/* method: get_provider of class  CL_Surface */
static void toluaI_CL_Surface_get_provider0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Surface,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  const CL_Surface* self = (const CL_Surface*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_provider'");
  {
   CL_SurfaceProvider* toluaI_ret = self->get_provider();
   tolua_pushusertype((void*)toluaI_ret,tolua_tag_CL_SurfaceProvider);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_provider'.");
}

/* method: put_screen of class  CL_Surface */
static void toluaI_CL_Surface_put_screen0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Surface,0) ||
     !tolua_istype(2,tolua_tag_number,0) ||
     !tolua_istype(3,tolua_tag_number,0) ||
     !tolua_istype(4,tolua_tag_number,1) ||
     !tolua_istype(5,tolua_tag_CL_DisplayCard,1) ||
     !tolua_isnoobj(6)
 )
  goto error;
 else
 {
  CL_Surface* self = (CL_Surface*)  tolua_getusertype(1,0);
  int x = ((int)  tolua_getnumber(2,0));
  int y = ((int)  tolua_getnumber(3,0));
  int spr_no = ((int)  tolua_getnumber(4,0));
  CL_DisplayCard* card = ((CL_DisplayCard*)  tolua_getusertype(5,NULL));
  if (!self) tolua_error("invalid 'self' in function 'put_screen'");
  {
   self->put_screen(x,y,spr_no,card);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'put_screen'.");
}

/* method: put_screen of class  CL_Surface */
static void toluaI_CL_Surface_put_screen1(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Surface,0) ||
     !tolua_istype(2,tolua_tag_number,0) ||
     !tolua_istype(3,tolua_tag_number,0) ||
     !tolua_istype(4,tolua_tag_number,0) ||
     !tolua_istype(5,tolua_tag_number,0) ||
     !tolua_istype(6,tolua_tag_number,1) ||
     !tolua_istype(7,tolua_tag_CL_DisplayCard,1) ||
     !tolua_isnoobj(8)
 )
  goto error;
 else
 {
  CL_Surface* self = (CL_Surface*)  tolua_getusertype(1,0);
  int x = ((int)  tolua_getnumber(2,0));
  int y = ((int)  tolua_getnumber(3,0));
  float scale_x = ((float)  tolua_getnumber(4,0));
  float scale_y = ((float)  tolua_getnumber(5,0));
  int spr_no = ((int)  tolua_getnumber(6,0));
  CL_DisplayCard* card = ((CL_DisplayCard*)  tolua_getusertype(7,NULL));
  if (!self) tolua_error("invalid 'self' in function 'put_screen'");
  {
   self->put_screen(x,y,scale_x,scale_y,spr_no,card);
  }
 }
 return;
error:
 toluaI_CL_Surface_put_screen0();
}

/* method: put_screen of class  CL_Surface */
static void toluaI_CL_Surface_put_screen2(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Surface,0) ||
     !tolua_istype(2,tolua_tag_number,0) ||
     !tolua_istype(3,tolua_tag_number,0) ||
     !tolua_istype(4,tolua_tag_number,0) ||
     !tolua_istype(5,tolua_tag_number,0) ||
     !tolua_istype(6,tolua_tag_number,1) ||
     !tolua_istype(7,tolua_tag_CL_DisplayCard,1) ||
     !tolua_isnoobj(8)
 )
  goto error;
 else
 {
  CL_Surface* self = (CL_Surface*)  tolua_getusertype(1,0);
  int x = ((int)  tolua_getnumber(2,0));
  int y = ((int)  tolua_getnumber(3,0));
  int size_x = ((int)  tolua_getnumber(4,0));
  int size_y = ((int)  tolua_getnumber(5,0));
  int spr_no = ((int)  tolua_getnumber(6,0));
  CL_DisplayCard* card = ((CL_DisplayCard*)  tolua_getusertype(7,NULL));
  if (!self) tolua_error("invalid 'self' in function 'put_screen'");
  {
   self->put_screen(x,y,size_x,size_y,spr_no,card);
  }
 }
 return;
error:
 toluaI_CL_Surface_put_screen1();
}

/* method: put_target of class  CL_Surface */
static void toluaI_CL_Surface_put_target0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Surface,0) ||
     !tolua_istype(2,tolua_tag_number,0) ||
     !tolua_istype(3,tolua_tag_number,0) ||
     !tolua_istype(4,tolua_tag_number,0) ||
     !tolua_istype(5,tolua_tag_CL_Target,0) ||
     !tolua_isnoobj(6)
 )
  goto error;
 else
 {
  CL_Surface* self = (CL_Surface*)  tolua_getusertype(1,0);
  int x = ((int)  tolua_getnumber(2,0));
  int y = ((int)  tolua_getnumber(3,0));
  int spr_no = ((int)  tolua_getnumber(4,0));
  CL_Target* target = ((CL_Target*)  tolua_getusertype(5,0));
  if (!self) tolua_error("invalid 'self' in function 'put_target'");
  {
   self->put_target(x,y,spr_no,target);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'put_target'.");
}

/* method: get_width of class  CL_Surface */
static void toluaI_CL_Surface_get_width0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Surface,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  const CL_Surface* self = (const CL_Surface*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_width'");
  {
   unsigned int toluaI_ret = self->get_width();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_width'.");
}

/* method: get_height of class  CL_Surface */
static void toluaI_CL_Surface_get_height0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Surface,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  const CL_Surface* self = (const CL_Surface*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_height'");
  {
   unsigned int toluaI_ret = self->get_height();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_height'.");
}

/* method: get_num_frames of class  CL_Surface */
static void toluaI_CL_Surface_get_num_frames0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Surface,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  const CL_Surface* self = (const CL_Surface*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_num_frames'");
  {
   unsigned int toluaI_ret = self->get_num_frames();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_num_frames'.");
}

/* method: is_video of class  CL_Surface */
static void toluaI_CL_Surface_is_video0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Surface,0) ||
     !tolua_istype(2,tolua_tag_CL_DisplayCard,1) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  const CL_Surface* self = (const CL_Surface*)  tolua_getusertype(1,0);
  CL_DisplayCard* card = ((CL_DisplayCard*)  tolua_getusertype(2,NULL));
  if (!self) tolua_error("invalid 'self' in function 'is_video'");
  {
   int toluaI_ret = self->is_video(card);
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'is_video'.");
}

/* method: is_loaded of class  CL_Surface */
static void toluaI_CL_Surface_is_loaded0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Surface,0) ||
     !tolua_istype(2,tolua_tag_CL_DisplayCard,1) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  const CL_Surface* self = (const CL_Surface*)  tolua_getusertype(1,0);
  CL_DisplayCard* card = ((CL_DisplayCard*)  tolua_getusertype(2,NULL));
  if (!self) tolua_error("invalid 'self' in function 'is_loaded'");
  {
   int toluaI_ret = self->is_loaded(card);
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'is_loaded'.");
}

/* method: convert_video of class  CL_Surface */
static void toluaI_CL_Surface_convert_video0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Surface,0) ||
     !tolua_istype(2,tolua_tag_CL_DisplayCard,1) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  CL_Surface* self = (CL_Surface*)  tolua_getusertype(1,0);
  CL_DisplayCard* card = ((CL_DisplayCard*)  tolua_getusertype(2,NULL));
  if (!self) tolua_error("invalid 'self' in function 'convert_video'");
  {
   int toluaI_ret = self->convert_video(card);
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'convert_video'.");
}

/* method: convert_system of class  CL_Surface */
static void toluaI_CL_Surface_convert_system0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Surface,0) ||
     !tolua_istype(2,tolua_tag_CL_DisplayCard,1) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  CL_Surface* self = (CL_Surface*)  tolua_getusertype(1,0);
  CL_DisplayCard* card = ((CL_DisplayCard*)  tolua_getusertype(2,NULL));
  if (!self) tolua_error("invalid 'self' in function 'convert_system'");
  {
   int toluaI_ret = self->convert_system(card);
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'convert_system'.");
}

/* method: flush of class  CL_Surface */
static void toluaI_CL_Surface_flush0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Surface,0) ||
     !tolua_istype(2,tolua_tag_CL_DisplayCard,1) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  CL_Surface* self = (CL_Surface*)  tolua_getusertype(1,0);
  CL_DisplayCard* card = ((CL_DisplayCard*)  tolua_getusertype(2,NULL));
  if (!self) tolua_error("invalid 'self' in function 'flush'");
  {
   self->flush(card);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'flush'.");
}

/* method: delete of class  CL_Target */
static void toluaI_CL_Target_delete0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Target* self = (CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'delete'");
  delete self;
 }
 return;
error:
 tolua_error("#ferror in function 'delete'.");
}

/* method: is_video of class  CL_Target */
static void toluaI_CL_Target_is_video0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Target* self = (CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'is_video'");
  {
   int toluaI_ret = self->is_video();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'is_video'.");
}

/* method: lock of class  CL_Target */
static void toluaI_CL_Target_lock0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Target* self = (CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'lock'");
  {
   self->lock();
  }
 }
 return;
error:
 tolua_error("#ferror in function 'lock'.");
}

/* method: unlock of class  CL_Target */
static void toluaI_CL_Target_unlock0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Target* self = (CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'unlock'");
  {
   self->unlock();
  }
 }
 return;
error:
 tolua_error("#ferror in function 'unlock'.");
}

/* method: get_data of class  CL_Target */
static void toluaI_CL_Target_get_data0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  const CL_Target* self = (const CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_data'");
  {
   void* toluaI_ret = self->get_data();
   tolua_pushuserdata(toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_data'.");
}

/* method: get_num_frames of class  CL_Target */
static void toluaI_CL_Target_get_num_frames0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  const CL_Target* self = (const CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_num_frames'");
  {
   unsigned int toluaI_ret = self->get_num_frames();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_num_frames'.");
}

/* method: get_width of class  CL_Target */
static void toluaI_CL_Target_get_width0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  const CL_Target* self = (const CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_width'");
  {
   unsigned int toluaI_ret = self->get_width();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_width'.");
}

/* method: get_height of class  CL_Target */
static void toluaI_CL_Target_get_height0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  const CL_Target* self = (const CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_height'");
  {
   unsigned int toluaI_ret = self->get_height();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_height'.");
}

/* method: get_pitch of class  CL_Target */
static void toluaI_CL_Target_get_pitch0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  const CL_Target* self = (const CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_pitch'");
  {
   unsigned int toluaI_ret = self->get_pitch();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_pitch'.");
}

/* method: get_depth of class  CL_Target */
static void toluaI_CL_Target_get_depth0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Target* self = (CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_depth'");
  {
   unsigned int toluaI_ret = self->get_depth();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_depth'.");
}

/* method: get_bytes_per_pixel of class  CL_Target */
static void toluaI_CL_Target_get_bytes_per_pixel0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Target* self = (CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_bytes_per_pixel'");
  {
   unsigned int toluaI_ret = self->get_bytes_per_pixel();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_bytes_per_pixel'.");
}

/* method: is_indexed of class  CL_Target */
static void toluaI_CL_Target_is_indexed0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  const CL_Target* self = (const CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'is_indexed'");
  {
   int toluaI_ret = self->is_indexed();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'is_indexed'.");
}

/* method: get_red_mask of class  CL_Target */
static void toluaI_CL_Target_get_red_mask0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  const CL_Target* self = (const CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_red_mask'");
  {
   unsigned int toluaI_ret = self->get_red_mask();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_red_mask'.");
}

/* method: get_green_mask of class  CL_Target */
static void toluaI_CL_Target_get_green_mask0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  const CL_Target* self = (const CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_green_mask'");
  {
   unsigned int toluaI_ret = self->get_green_mask();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_green_mask'.");
}

/* method: get_blue_mask of class  CL_Target */
static void toluaI_CL_Target_get_blue_mask0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  const CL_Target* self = (const CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_blue_mask'");
  {
   unsigned int toluaI_ret = self->get_blue_mask();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_blue_mask'.");
}

/* method: get_alpha_mask of class  CL_Target */
static void toluaI_CL_Target_get_alpha_mask0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  const CL_Target* self = (const CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_alpha_mask'");
  {
   unsigned int toluaI_ret = self->get_alpha_mask();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_alpha_mask'.");
}

/* method: get_palette of class  CL_Target */
static void toluaI_CL_Target_get_palette0(void)
{
 if (
     !tolua_istype(1,tolua_tag_const_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  const CL_Target* self = (const CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_palette'");
  {
   CL_Palette* toluaI_ret = self->get_palette();
   tolua_pushusertype((void*)toluaI_ret,tolua_tag_CL_Palette);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_palette'.");
}

/* method: push_clip_rect of class  CL_Target */
static void toluaI_CL_Target_push_clip_rect0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Target* self = (CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'push_clip_rect'");
  {
   self->push_clip_rect();
  }
 }
 return;
error:
 tolua_error("#ferror in function 'push_clip_rect'.");
}

/* method: push_clip_rect of class  CL_Target */
static void toluaI_CL_Target_push_clip_rect1(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Target,0) ||
     !tolua_istype(2,tolua_tag_const_CL_ClipRect,0) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  CL_Target* self = (CL_Target*)  tolua_getusertype(1,0);
  const CL_ClipRect* rect = ((const CL_ClipRect*)  tolua_getusertype(2,0));
  if (!self) tolua_error("invalid 'self' in function 'push_clip_rect'");
  {
   self->push_clip_rect(*rect);
  }
 }
 return;
error:
 toluaI_CL_Target_push_clip_rect0();
}

/* method: get_clip_rect of class  CL_Target */
static void toluaI_CL_Target_get_clip_rect0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Target* self = (CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_clip_rect'");
  {
   CL_ClipRect toluaI_ret = self->get_clip_rect();
   {
#ifdef __cplusplus
    void* toluaI_clone = new CL_ClipRect(toluaI_ret);
#else
    void* toluaI_clone = tolua_copy((void*)&toluaI_ret,sizeof(CL_ClipRect));
#endif
    tolua_pushusertype(tolua_doclone(toluaI_clone,tolua_tag_CL_ClipRect),tolua_tag_CL_ClipRect);
   }
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_clip_rect'.");
}

/* method: set_clip_rect of class  CL_Target */
static void toluaI_CL_Target_set_clip_rect0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Target,0) ||
     !tolua_istype(2,tolua_tag_const_CL_ClipRect,0) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  CL_Target* self = (CL_Target*)  tolua_getusertype(1,0);
  const CL_ClipRect* rect = ((const CL_ClipRect*)  tolua_getusertype(2,0));
  if (!self) tolua_error("invalid 'self' in function 'set_clip_rect'");
  {
   self->set_clip_rect(*rect);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'set_clip_rect'.");
}

/* method: pop_clip_rect of class  CL_Target */
static void toluaI_CL_Target_pop_clip_rect0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Target,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Target* self = (CL_Target*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'pop_clip_rect'");
  {
   self->pop_clip_rect();
  }
 }
 return;
error:
 tolua_error("#ferror in function 'pop_clip_rect'.");
}

/* method: fill_rect of class  CL_Target */
static void toluaI_CL_Target_fill_rect0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Target,0) ||
     !tolua_istype(2,tolua_tag_number,0) ||
     !tolua_istype(3,tolua_tag_number,0) ||
     !tolua_istype(4,tolua_tag_number,0) ||
     !tolua_istype(5,tolua_tag_number,0) ||
     !tolua_istype(6,tolua_tag_number,0) ||
     !tolua_istype(7,tolua_tag_number,0) ||
     !tolua_istype(8,tolua_tag_number,0) ||
     !tolua_istype(9,tolua_tag_number,0) ||
     !tolua_isnoobj(10)
 )
  goto error;
 else
 {
  CL_Target* self = (CL_Target*)  tolua_getusertype(1,0);
  int x1 = ((int)  tolua_getnumber(2,0));
  int y1 = ((int)  tolua_getnumber(3,0));
  int x2 = ((int)  tolua_getnumber(4,0));
  int y2 = ((int)  tolua_getnumber(5,0));
  float r = ((float)  tolua_getnumber(6,0));
  float g = ((float)  tolua_getnumber(7,0));
  float b = ((float)  tolua_getnumber(8,0));
  float a = ((float)  tolua_getnumber(9,0));
  if (!self) tolua_error("invalid 'self' in function 'fill_rect'");
  {
   self->fill_rect(x1,y1,x2,y2,r,g,b,a);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'fill_rect'.");
}

/* method: draw_line of class  CL_Target */
static void toluaI_CL_Target_draw_line0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Target,0) ||
     !tolua_istype(2,tolua_tag_number,0) ||
     !tolua_istype(3,tolua_tag_number,0) ||
     !tolua_istype(4,tolua_tag_number,0) ||
     !tolua_istype(5,tolua_tag_number,0) ||
     !tolua_istype(6,tolua_tag_number,0) ||
     !tolua_istype(7,tolua_tag_number,0) ||
     !tolua_istype(8,tolua_tag_number,0) ||
     !tolua_istype(9,tolua_tag_number,0) ||
     !tolua_isnoobj(10)
 )
  goto error;
 else
 {
  CL_Target* self = (CL_Target*)  tolua_getusertype(1,0);
  int x1 = ((int)  tolua_getnumber(2,0));
  int y1 = ((int)  tolua_getnumber(3,0));
  int x2 = ((int)  tolua_getnumber(4,0));
  int y2 = ((int)  tolua_getnumber(5,0));
  float r = ((float)  tolua_getnumber(6,0));
  float g = ((float)  tolua_getnumber(7,0));
  float b = ((float)  tolua_getnumber(8,0));
  float a = ((float)  tolua_getnumber(9,0));
  if (!self) tolua_error("invalid 'self' in function 'draw_line'");
  {
   self->draw_line(x1,y1,x2,y2,r,g,b,a);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'draw_line'.");
}

/* method: delete of class  CL_SurfaceProvider */
static void toluaI_CL_SurfaceProvider_delete0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_SurfaceProvider,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_SurfaceProvider* self = (CL_SurfaceProvider*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'delete'");
  delete self;
 }
 return;
error:
 tolua_error("#ferror in function 'delete'.");
}

/* method: get_translate_x of class  CL_SurfaceProvider */
static void toluaI_CL_SurfaceProvider_get_translate_x0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_SurfaceProvider,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_SurfaceProvider* self = (CL_SurfaceProvider*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_translate_x'");
  {
   int toluaI_ret = self->get_translate_x();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_translate_x'.");
}

/* method: get_translate_y of class  CL_SurfaceProvider */
static void toluaI_CL_SurfaceProvider_get_translate_y0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_SurfaceProvider,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_SurfaceProvider* self = (CL_SurfaceProvider*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_translate_y'");
  {
   int toluaI_ret = self->get_translate_y();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_translate_y'.");
}

/* method: uses_src_colorkey of class  CL_SurfaceProvider */
static void toluaI_CL_SurfaceProvider_uses_src_colorkey0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_SurfaceProvider,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_SurfaceProvider* self = (CL_SurfaceProvider*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'uses_src_colorkey'");
  {
   int toluaI_ret = self->uses_src_colorkey();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'uses_src_colorkey'.");
}

/* method: get_src_colorkey of class  CL_SurfaceProvider */
static void toluaI_CL_SurfaceProvider_get_src_colorkey0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_SurfaceProvider,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_SurfaceProvider* self = (CL_SurfaceProvider*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_src_colorkey'");
  {
   unsigned int toluaI_ret = self->get_src_colorkey();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_src_colorkey'.");
}

/* method: create of class  CL_Canvas */
static void toluaI_CL_Canvas_create0(void)
{
 if (
     !tolua_istype(2,tolua_tag_number,0) ||
     !tolua_istype(3,tolua_tag_number,0) ||
     !tolua_istype(4,tolua_tag_number,1) ||
     !tolua_istype(5,tolua_tag_number,1) ||
     !tolua_istype(6,tolua_tag_number,1) ||
     !tolua_istype(7,tolua_tag_number,1) ||
     !tolua_istype(8,tolua_tag_number,1) ||
     !tolua_istype(9,tolua_tag_number,1) ||
     !tolua_istype(10,tolua_tag_number,1) ||
     !tolua_isnoobj(11)
 )
  goto error;
 else
 {
  int width = ((int)  tolua_getnumber(2,0));
  int height = ((int)  tolua_getnumber(3,0));
  int no_sprs = ((int)  tolua_getnumber(4,1));
  int red_mask = ((int)  tolua_getnumber(5,0xff000000));
  int green_mask = ((int)  tolua_getnumber(6,0x00ff0000));
  int blue_mask = ((int)  tolua_getnumber(7,0x0000ff00));
  int alpha_mask = ((int)  tolua_getnumber(8,0x000000ff));
  int use_transcol = ((int)  tolua_getnumber(9,false));
  unsigned int transcol = ((unsigned int)  tolua_getnumber(10,0));
  {
   CL_Surface* toluaI_ret = CL_Canvas::create(width,height,no_sprs,red_mask,green_mask,blue_mask,alpha_mask,use_transcol,transcol);
   tolua_pushusertype((void*)toluaI_ret,tolua_tag_CL_Surface);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'create'.");
}

/* method: new of class  CL_Canvas */
static void toluaI_CL_Canvas_new0(void)
{
 if (
     !tolua_istype(2,tolua_tag_number,0) ||
     !tolua_istype(3,tolua_tag_number,0) ||
     !tolua_istype(4,tolua_tag_number,1) ||
     !tolua_istype(5,tolua_tag_number,1) ||
     !tolua_istype(6,tolua_tag_number,1) ||
     !tolua_istype(7,tolua_tag_number,1) ||
     !tolua_istype(8,tolua_tag_number,1) ||
     !tolua_istype(9,tolua_tag_number,1) ||
     !tolua_istype(10,tolua_tag_number,1) ||
     !tolua_isnoobj(11)
 )
  goto error;
 else
 {
  int width = ((int)  tolua_getnumber(2,0));
  int height = ((int)  tolua_getnumber(3,0));
  int no_sprs = ((int)  tolua_getnumber(4,1));
  int red_mask = ((int)  tolua_getnumber(5,0xff000000));
  int green_mask = ((int)  tolua_getnumber(6,0x00ff0000));
  int blue_mask = ((int)  tolua_getnumber(7,0x0000ff00));
  int alpha_mask = ((int)  tolua_getnumber(8,0x000000ff));
  int use_transcol = ((int)  tolua_getnumber(9,false));
  unsigned int transcol = ((unsigned int)  tolua_getnumber(10,0));
  {
   CL_Canvas* toluaI_ret = new CL_Canvas(width,height,no_sprs,red_mask,green_mask,blue_mask,alpha_mask,use_transcol,transcol);
   tolua_pushusertype((void*)toluaI_ret,tolua_tag_CL_Canvas);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'new'.");
}

/* method: delete of class  CL_Canvas */
static void toluaI_CL_Canvas_delete0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'delete'");
  delete self;
 }
 return;
error:
 tolua_error("#ferror in function 'delete'.");
}

/* method: get_width of class  CL_Canvas */
static void toluaI_CL_Canvas_get_width0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_width'");
  {
   unsigned int toluaI_ret = self->get_width();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_width'.");
}

/* method: get_height of class  CL_Canvas */
static void toluaI_CL_Canvas_get_height0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_height'");
  {
   unsigned int toluaI_ret = self->get_height();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_height'.");
}

/* method: get_num_frames of class  CL_Canvas */
static void toluaI_CL_Canvas_get_num_frames0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_num_frames'");
  {
   unsigned int toluaI_ret = self->get_num_frames();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_num_frames'.");
}

/* method: get_red_mask of class  CL_Canvas */
static void toluaI_CL_Canvas_get_red_mask0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_red_mask'");
  {
   unsigned int toluaI_ret = self->get_red_mask();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_red_mask'.");
}

/* method: get_green_mask of class  CL_Canvas */
static void toluaI_CL_Canvas_get_green_mask0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_green_mask'");
  {
   unsigned int toluaI_ret = self->get_green_mask();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_green_mask'.");
}

/* method: get_blue_mask of class  CL_Canvas */
static void toluaI_CL_Canvas_get_blue_mask0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_blue_mask'");
  {
   unsigned int toluaI_ret = self->get_blue_mask();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_blue_mask'.");
}

/* method: get_alpha_mask of class  CL_Canvas */
static void toluaI_CL_Canvas_get_alpha_mask0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_alpha_mask'");
  {
   unsigned int toluaI_ret = self->get_alpha_mask();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_alpha_mask'.");
}

/* method: get_pitch of class  CL_Canvas */
static void toluaI_CL_Canvas_get_pitch0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_pitch'");
  {
   unsigned int toluaI_ret = self->get_pitch();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_pitch'.");
}

/* method: is_indexed of class  CL_Canvas */
static void toluaI_CL_Canvas_is_indexed0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'is_indexed'");
  {
   int toluaI_ret = self->is_indexed();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'is_indexed'.");
}

/* method: set_palette of class  CL_Canvas */
static void toluaI_CL_Canvas_set_palette0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_istype(2,tolua_tag_CL_Palette,0) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  CL_Palette* palette = ((CL_Palette*)  tolua_getusertype(2,0));
  if (!self) tolua_error("invalid 'self' in function 'set_palette'");
  {
   self->set_palette(palette);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'set_palette'.");
}

/* method: get_palette of class  CL_Canvas */
static void toluaI_CL_Canvas_get_palette0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_palette'");
  {
   CL_Palette* toluaI_ret = self->get_palette();
   tolua_pushusertype((void*)toluaI_ret,tolua_tag_CL_Palette);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_palette'.");
}

/* method: set_src_colorkey of class  CL_Canvas */
static void toluaI_CL_Canvas_set_src_colorkey0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_istype(2,tolua_tag_number,0) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  unsigned int trans_col = ((unsigned int)  tolua_getnumber(2,0));
  if (!self) tolua_error("invalid 'self' in function 'set_src_colorkey'");
  {
   self->set_src_colorkey(trans_col);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'set_src_colorkey'.");
}

/* method: uses_src_colorkey of class  CL_Canvas */
static void toluaI_CL_Canvas_uses_src_colorkey0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'uses_src_colorkey'");
  {
   int toluaI_ret = self->uses_src_colorkey();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'uses_src_colorkey'.");
}

/* method: get_src_colorkey of class  CL_Canvas */
static void toluaI_CL_Canvas_get_src_colorkey0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_src_colorkey'");
  {
   unsigned int toluaI_ret = self->get_src_colorkey();
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_src_colorkey'.");
}

/* method: get_data of class  CL_Canvas */
static void toluaI_CL_Canvas_get_data0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'get_data'");
  {
   void* toluaI_ret = self->get_data();
   tolua_pushuserdata(toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'get_data'.");
}

/* method: lock of class  CL_Canvas */
static void toluaI_CL_Canvas_lock0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'lock'");
  {
   self->lock();
  }
 }
 return;
error:
 tolua_error("#ferror in function 'lock'.");
}

/* method: unlock of class  CL_Canvas */
static void toluaI_CL_Canvas_unlock0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_Canvas,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_Canvas* self = (CL_Canvas*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'unlock'");
  {
   self->unlock();
  }
 }
 return;
error:
 tolua_error("#ferror in function 'unlock'.");
}

/* get function: m_x1 of class  CL_ClipRect */
static void toluaI_get_CL_ClipRect_m_x1(void)
{
  CL_ClipRect* self = (CL_ClipRect*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in accessing variable 'm_x1'");
  tolua_pushnumber((double)self->m_x1);
}

/* set function: m_x1 of class  CL_ClipRect */
static void toluaI_set_CL_ClipRect_m_x1(void)
{
  CL_ClipRect* self = (CL_ClipRect*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in accessing variable 'm_x1'");
  if (!tolua_istype(2,tolua_tag_number,0))
   tolua_error("#vinvalid type in variable assignment.");
  self->m_x1 = ((int)  tolua_getnumber(2,0));
}

/* get function: m_y1 of class  CL_ClipRect */
static void toluaI_get_CL_ClipRect_m_y1(void)
{
  CL_ClipRect* self = (CL_ClipRect*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in accessing variable 'm_y1'");
  tolua_pushnumber((double)self->m_y1);
}

/* set function: m_y1 of class  CL_ClipRect */
static void toluaI_set_CL_ClipRect_m_y1(void)
{
  CL_ClipRect* self = (CL_ClipRect*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in accessing variable 'm_y1'");
  if (!tolua_istype(2,tolua_tag_number,0))
   tolua_error("#vinvalid type in variable assignment.");
  self->m_y1 = ((int)  tolua_getnumber(2,0));
}

/* get function: m_x2 of class  CL_ClipRect */
static void toluaI_get_CL_ClipRect_m_x2(void)
{
  CL_ClipRect* self = (CL_ClipRect*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in accessing variable 'm_x2'");
  tolua_pushnumber((double)self->m_x2);
}

/* set function: m_x2 of class  CL_ClipRect */
static void toluaI_set_CL_ClipRect_m_x2(void)
{
  CL_ClipRect* self = (CL_ClipRect*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in accessing variable 'm_x2'");
  if (!tolua_istype(2,tolua_tag_number,0))
   tolua_error("#vinvalid type in variable assignment.");
  self->m_x2 = ((int)  tolua_getnumber(2,0));
}

/* get function: m_y2 of class  CL_ClipRect */
static void toluaI_get_CL_ClipRect_m_y2(void)
{
  CL_ClipRect* self = (CL_ClipRect*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in accessing variable 'm_y2'");
  tolua_pushnumber((double)self->m_y2);
}

/* set function: m_y2 of class  CL_ClipRect */
static void toluaI_set_CL_ClipRect_m_y2(void)
{
  CL_ClipRect* self = (CL_ClipRect*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in accessing variable 'm_y2'");
  if (!tolua_istype(2,tolua_tag_number,0))
   tolua_error("#vinvalid type in variable assignment.");
  self->m_y2 = ((int)  tolua_getnumber(2,0));
}

/* method: new of class  CL_ClipRect */
static void toluaI_CL_ClipRect_new0(void)
{
 if (
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  {
   CL_ClipRect* toluaI_ret = new CL_ClipRect();
   tolua_pushusertype((void*)toluaI_ret,tolua_tag_CL_ClipRect);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'new'.");
}

/* method: new of class  CL_ClipRect */
static void toluaI_CL_ClipRect_new1(void)
{
 if (
     !tolua_istype(2,tolua_tag_const_CL_ClipRect,0) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  const CL_ClipRect* rect = ((const CL_ClipRect*)  tolua_getusertype(2,0));
  {
   CL_ClipRect* toluaI_ret = new CL_ClipRect(*rect);
   tolua_pushusertype((void*)toluaI_ret,tolua_tag_CL_ClipRect);
  }
 }
 return;
error:
 toluaI_CL_ClipRect_new0();
}

/* method: new of class  CL_ClipRect */
static void toluaI_CL_ClipRect_new2(void)
{
 if (
     !tolua_istype(2,tolua_tag_number,0) ||
     !tolua_istype(3,tolua_tag_number,0) ||
     !tolua_istype(4,tolua_tag_number,0) ||
     !tolua_istype(5,tolua_tag_number,0) ||
     !tolua_isnoobj(6)
 )
  goto error;
 else
 {
  int x1 = ((int)  tolua_getnumber(2,0));
  int y1 = ((int)  tolua_getnumber(3,0));
  int x2 = ((int)  tolua_getnumber(4,0));
  int y2 = ((int)  tolua_getnumber(5,0));
  {
   CL_ClipRect* toluaI_ret = new CL_ClipRect(x1,y1,x2,y2);
   tolua_pushusertype((void*)toluaI_ret,tolua_tag_CL_ClipRect);
  }
 }
 return;
error:
 toluaI_CL_ClipRect_new1();
}

/* method: delete of class  CL_ClipRect */
static void toluaI_CL_ClipRect_delete0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_ClipRect,0) ||
     !tolua_isnoobj(2)
 )
  goto error;
 else
 {
  CL_ClipRect* self = (CL_ClipRect*)  tolua_getusertype(1,0);
  if (!self) tolua_error("invalid 'self' in function 'delete'");
  delete self;
 }
 return;
error:
 tolua_error("#ferror in function 'delete'.");
}

/* method: test_clipped of class  CL_ClipRect */
static void toluaI_CL_ClipRect_test_clipped0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_ClipRect,0) ||
     !tolua_istype(2,tolua_tag_const_CL_ClipRect,0) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  CL_ClipRect* self = (CL_ClipRect*)  tolua_getusertype(1,0);
  const CL_ClipRect* rect = ((const CL_ClipRect*)  tolua_getusertype(2,0));
  if (!self) tolua_error("invalid 'self' in function 'test_clipped'");
  {
   int toluaI_ret = self->test_clipped(*rect);
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'test_clipped'.");
}

/* method: test_unclipped of class  CL_ClipRect */
static void toluaI_CL_ClipRect_test_unclipped0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_ClipRect,0) ||
     !tolua_istype(2,tolua_tag_const_CL_ClipRect,0) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  CL_ClipRect* self = (CL_ClipRect*)  tolua_getusertype(1,0);
  const CL_ClipRect* rect = ((const CL_ClipRect*)  tolua_getusertype(2,0));
  if (!self) tolua_error("invalid 'self' in function 'test_unclipped'");
  {
   int toluaI_ret = self->test_unclipped(*rect);
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'test_unclipped'.");
}

/* method: test_all_clipped of class  CL_ClipRect */
static void toluaI_CL_ClipRect_test_all_clipped0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_ClipRect,0) ||
     !tolua_istype(2,tolua_tag_const_CL_ClipRect,0) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  CL_ClipRect* self = (CL_ClipRect*)  tolua_getusertype(1,0);
  const CL_ClipRect* rect = ((const CL_ClipRect*)  tolua_getusertype(2,0));
  if (!self) tolua_error("invalid 'self' in function 'test_all_clipped'");
  {
   int toluaI_ret = self->test_all_clipped(*rect);
   tolua_pushnumber((double)toluaI_ret);
  }
 }
 return;
error:
 tolua_error("#ferror in function 'test_all_clipped'.");
}

/* method: clip of class  CL_ClipRect */
static void toluaI_CL_ClipRect_clip0(void)
{
 if (
     !tolua_istype(1,tolua_tag_CL_ClipRect,0) ||
     !tolua_istype(2,tolua_tag_const_CL_ClipRect,0) ||
     !tolua_isnoobj(3)
 )
  goto error;
 else
 {
  CL_ClipRect* self = (CL_ClipRect*)  tolua_getusertype(1,0);
  const CL_ClipRect* rect = ((const CL_ClipRect*)  tolua_getusertype(2,0));
  if (!self) tolua_error("invalid 'self' in function 'clip'");
  {
   CL_ClipRect toluaI_ret = self->clip(*rect);
   {
#ifdef __cplusplus
    void* toluaI_clone = new CL_ClipRect(toluaI_ret);
#else
    void* toluaI_clone = tolua_copy((void*)&toluaI_ret,sizeof(CL_ClipRect));
#endif
    tolua_pushusertype(tolua_doclone(toluaI_clone,tolua_tag_CL_ClipRect),tolua_tag_CL_ClipRect);
   }
  }
 }
 return;
error:
 tolua_error("#ferror in function 'clip'.");
}

/* Open function */
int tolua_clanLua_open (void)
{
 tolua_open();
 lua_beginblock();
 toluaI_init_tag();
 tolua_constant(NULL,"TRUE",TRUE);
 tolua_constant(NULL,"FALSE",FALSE);
 tolua_cclass("CL_Display","");
 tolua_function("CL_Display","delete",toluaI_CL_Display_delete0);
 tolua_function("CL_Display","flip_display",toluaI_CL_Display_flip_display0);
 tolua_function("CL_Display","clear_display",toluaI_CL_Display_clear_display0);
 tolua_function("CL_Display","set_palette",toluaI_CL_Display_set_palette0);
 tolua_function("CL_Display","get_palette",toluaI_CL_Display_get_palette0);
 tolua_function("CL_Display","select_card",toluaI_CL_Display_select_card0);
 tolua_function("CL_Display","get_current_card",toluaI_CL_Display_get_current_card0);
 tolua_function("CL_Display","set_videomode",toluaI_CL_Display_set_videomode0);
 tolua_function("CL_Display","set_videomode",toluaI_CL_Display_set_videomode1);
 tolua_function("CL_Display","get_width",toluaI_CL_Display_get_width0);
 tolua_function("CL_Display","get_height",toluaI_CL_Display_get_height0);
 tolua_function("CL_Display","get_bpp",toluaI_CL_Display_get_bpp0);
 tolua_function("CL_Display","push_clip_rect",toluaI_CL_Display_push_clip_rect0);
 tolua_function("CL_Display","push_clip_rect",toluaI_CL_Display_push_clip_rect1);
 tolua_function("CL_Display","get_clip_rect",toluaI_CL_Display_get_clip_rect0);
 tolua_function("CL_Display","set_clip_rect",toluaI_CL_Display_set_clip_rect0);
 tolua_function("CL_Display","pop_clip_rect",toluaI_CL_Display_pop_clip_rect0);
 tolua_function("CL_Display","fill_rect",toluaI_CL_Display_fill_rect0);
 tolua_function("CL_Display","draw_line",toluaI_CL_Display_draw_line0);
 tolua_function("CL_Display","sync_buffers",toluaI_CL_Display_sync_buffers0);
 tolua_cclass("CL_System","");
 tolua_function("CL_System","keep_alive",toluaI_CL_System_keep_alive0);
 tolua_function("CL_System","sleep",toluaI_CL_System_sleep0);
 tolua_function("CL_System","get_time",toluaI_CL_System_get_time0);
 tolua_cclass("CL_Mouse","CL_InputDevice");
 tolua_function("CL_Mouse","delete",toluaI_CL_Mouse_delete0);
 tolua_function("CL_Mouse","get_x",toluaI_CL_Mouse_get_x0);
 tolua_function("CL_Mouse","get_y",toluaI_CL_Mouse_get_y0);
 tolua_function("CL_Mouse","left_pressed",toluaI_CL_Mouse_left_pressed0);
 tolua_function("CL_Mouse","middle_pressed",toluaI_CL_Mouse_middle_pressed0);
 tolua_function("CL_Mouse","right_pressed",toluaI_CL_Mouse_right_pressed0);
 tolua_cclass("CL_Keyboard","CL_InputDevice");
 tolua_function("CL_Keyboard","delete",toluaI_CL_Keyboard_delete0);
 tolua_function("CL_Keyboard","get_keycode",toluaI_CL_Keyboard_get_keycode0);
 tolua_constant(NULL,"CL_KEY_A",CL_KEY_A);
 tolua_constant(NULL,"CL_KEY_B",CL_KEY_B);
 tolua_constant(NULL,"CL_KEY_C",CL_KEY_C);
 tolua_constant(NULL,"CL_KEY_D",CL_KEY_D);
 tolua_constant(NULL,"CL_KEY_E",CL_KEY_E);
 tolua_constant(NULL,"CL_KEY_F",CL_KEY_F);
 tolua_constant(NULL,"CL_KEY_G",CL_KEY_G);
 tolua_constant(NULL,"CL_KEY_H",CL_KEY_H);
 tolua_constant(NULL,"CL_KEY_I",CL_KEY_I);
 tolua_constant(NULL,"CL_KEY_J",CL_KEY_J);
 tolua_constant(NULL,"CL_KEY_K",CL_KEY_K);
 tolua_constant(NULL,"CL_KEY_L",CL_KEY_L);
 tolua_constant(NULL,"CL_KEY_M",CL_KEY_M);
 tolua_constant(NULL,"CL_KEY_N",CL_KEY_N);
 tolua_constant(NULL,"CL_KEY_O",CL_KEY_O);
 tolua_constant(NULL,"CL_KEY_P",CL_KEY_P);
 tolua_constant(NULL,"CL_KEY_Q",CL_KEY_Q);
 tolua_constant(NULL,"CL_KEY_R",CL_KEY_R);
 tolua_constant(NULL,"CL_KEY_S",CL_KEY_S);
 tolua_constant(NULL,"CL_KEY_T",CL_KEY_T);
 tolua_constant(NULL,"CL_KEY_U",CL_KEY_U);
 tolua_constant(NULL,"CL_KEY_V",CL_KEY_V);
 tolua_constant(NULL,"CL_KEY_W",CL_KEY_W);
 tolua_constant(NULL,"CL_KEY_X",CL_KEY_X);
 tolua_constant(NULL,"CL_KEY_Y",CL_KEY_Y);
 tolua_constant(NULL,"CL_KEY_Z",CL_KEY_Z);
 tolua_constant(NULL,"CL_KEY_0",CL_KEY_0);
 tolua_constant(NULL,"CL_KEY_1",CL_KEY_1);
 tolua_constant(NULL,"CL_KEY_2",CL_KEY_2);
 tolua_constant(NULL,"CL_KEY_3",CL_KEY_3);
 tolua_constant(NULL,"CL_KEY_4",CL_KEY_4);
 tolua_constant(NULL,"CL_KEY_5",CL_KEY_5);
 tolua_constant(NULL,"CL_KEY_6",CL_KEY_6);
 tolua_constant(NULL,"CL_KEY_7",CL_KEY_7);
 tolua_constant(NULL,"CL_KEY_8",CL_KEY_8);
 tolua_constant(NULL,"CL_KEY_9",CL_KEY_9);
 tolua_constant(NULL,"CL_KEY_F1",CL_KEY_F1);
 tolua_constant(NULL,"CL_KEY_F2",CL_KEY_F2);
 tolua_constant(NULL,"CL_KEY_F3",CL_KEY_F3);
 tolua_constant(NULL,"CL_KEY_F4",CL_KEY_F4);
 tolua_constant(NULL,"CL_KEY_F5",CL_KEY_F5);
 tolua_constant(NULL,"CL_KEY_F6",CL_KEY_F6);
 tolua_constant(NULL,"CL_KEY_F7",CL_KEY_F7);
 tolua_constant(NULL,"CL_KEY_F8",CL_KEY_F8);
 tolua_constant(NULL,"CL_KEY_F9",CL_KEY_F9);
 tolua_constant(NULL,"CL_KEY_F10",CL_KEY_F10);
 tolua_constant(NULL,"CL_KEY_F11",CL_KEY_F11);
 tolua_constant(NULL,"CL_KEY_F12",CL_KEY_F12);
 tolua_constant(NULL,"CL_KEY_ESCAPE",CL_KEY_ESCAPE);
 tolua_constant(NULL,"CL_KEY_LEFT",CL_KEY_LEFT);
 tolua_constant(NULL,"CL_KEY_RIGHT",CL_KEY_RIGHT);
 tolua_constant(NULL,"CL_KEY_UP",CL_KEY_UP);
 tolua_constant(NULL,"CL_KEY_DOWN",CL_KEY_DOWN);
 tolua_constant(NULL,"CL_KEY_LCTRL",CL_KEY_LCTRL);
 tolua_constant(NULL,"CL_KEY_RCTRL",CL_KEY_RCTRL);
 tolua_constant(NULL,"CL_KEY_LSHIFT",CL_KEY_LSHIFT);
 tolua_constant(NULL,"CL_KEY_RSHIFT",CL_KEY_RSHIFT);
 tolua_constant(NULL,"CL_KEY_ALT",CL_KEY_ALT);
 tolua_constant(NULL,"CL_KEY_ALTGR",CL_KEY_ALTGR);
 tolua_constant(NULL,"CL_KEY_TAB",CL_KEY_TAB);
 tolua_constant(NULL,"CL_KEY_ENTER",CL_KEY_ENTER);
 tolua_constant(NULL,"CL_KEY_SPACE",CL_KEY_SPACE);
 tolua_constant(NULL,"CL_KEY_BACKSPACE",CL_KEY_BACKSPACE);
 tolua_constant(NULL,"CL_KEY_INSERT",CL_KEY_INSERT);
 tolua_constant(NULL,"CL_KEY_DELETE",CL_KEY_DELETE);
 tolua_constant(NULL,"CL_KEY_HOME",CL_KEY_HOME);
 tolua_constant(NULL,"CL_KEY_END",CL_KEY_END);
 tolua_constant(NULL,"CL_KEY_PAGEUP",CL_KEY_PAGEUP);
 tolua_constant(NULL,"CL_KEY_PAGEDOWN",CL_KEY_PAGEDOWN);
 tolua_constant(NULL,"CL_KEY_CAPSLOCK",CL_KEY_CAPSLOCK);
 tolua_constant(NULL,"CL_KEY_NUMLOCK",CL_KEY_NUMLOCK);
 tolua_constant(NULL,"CL_KEY_SCRLOCK",CL_KEY_SCRLOCK);
 tolua_constant(NULL,"CL_KEY_PRINT",CL_KEY_PRINT);
 tolua_constant(NULL,"CL_KEY_PAUSE",CL_KEY_PAUSE);
 tolua_constant(NULL,"CL_KEY_KP_DIV",CL_KEY_KP_DIV);
 tolua_constant(NULL,"CL_KEY_KP_MULT",CL_KEY_KP_MULT);
 tolua_constant(NULL,"CL_KEY_KP_MINUS",CL_KEY_KP_MINUS);
 tolua_constant(NULL,"CL_KEY_KP_PLUS",CL_KEY_KP_PLUS);
 tolua_constant(NULL,"CL_KEY_KP_ENTER",CL_KEY_KP_ENTER);
 tolua_constant(NULL,"CL_KEY_NONE_OF_THE_ABOVE",CL_KEY_NONE_OF_THE_ABOVE);
 tolua_constant(NULL,"CL_NUM_KEYS",CL_NUM_KEYS);
 tolua_cclass("CL_Surface","");
 tolua_function("CL_Surface","load",toluaI_CL_Surface_load0);
 tolua_function("CL_Surface","create",toluaI_CL_Surface_create0);
 tolua_function("CL_Surface","delete",toluaI_CL_Surface_delete0);
 tolua_function("CL_Surface","reload",toluaI_CL_Surface_reload0);
 tolua_function("CL_Surface","get_provider",toluaI_CL_Surface_get_provider0);
 tolua_function("CL_Surface","put_screen",toluaI_CL_Surface_put_screen0);
 tolua_function("CL_Surface","put_screen",toluaI_CL_Surface_put_screen1);
 tolua_function("CL_Surface","put_screen",toluaI_CL_Surface_put_screen2);
 tolua_function("CL_Surface","put_target",toluaI_CL_Surface_put_target0);
 tolua_function("CL_Surface","get_width",toluaI_CL_Surface_get_width0);
 tolua_function("CL_Surface","get_height",toluaI_CL_Surface_get_height0);
 tolua_function("CL_Surface","get_num_frames",toluaI_CL_Surface_get_num_frames0);
 tolua_function("CL_Surface","is_video",toluaI_CL_Surface_is_video0);
 tolua_function("CL_Surface","is_loaded",toluaI_CL_Surface_is_loaded0);
 tolua_function("CL_Surface","convert_video",toluaI_CL_Surface_convert_video0);
 tolua_function("CL_Surface","convert_system",toluaI_CL_Surface_convert_system0);
 tolua_function("CL_Surface","flush",toluaI_CL_Surface_flush0);
 tolua_cclass("CL_Target","");
 tolua_function("CL_Target","delete",toluaI_CL_Target_delete0);
 tolua_function("CL_Target","is_video",toluaI_CL_Target_is_video0);
 tolua_function("CL_Target","lock",toluaI_CL_Target_lock0);
 tolua_function("CL_Target","unlock",toluaI_CL_Target_unlock0);
 tolua_function("CL_Target","get_data",toluaI_CL_Target_get_data0);
 tolua_function("CL_Target","get_num_frames",toluaI_CL_Target_get_num_frames0);
 tolua_function("CL_Target","get_width",toluaI_CL_Target_get_width0);
 tolua_function("CL_Target","get_height",toluaI_CL_Target_get_height0);
 tolua_function("CL_Target","get_pitch",toluaI_CL_Target_get_pitch0);
 tolua_function("CL_Target","get_depth",toluaI_CL_Target_get_depth0);
 tolua_function("CL_Target","get_bytes_per_pixel",toluaI_CL_Target_get_bytes_per_pixel0);
 tolua_function("CL_Target","is_indexed",toluaI_CL_Target_is_indexed0);
 tolua_function("CL_Target","get_red_mask",toluaI_CL_Target_get_red_mask0);
 tolua_function("CL_Target","get_green_mask",toluaI_CL_Target_get_green_mask0);
 tolua_function("CL_Target","get_blue_mask",toluaI_CL_Target_get_blue_mask0);
 tolua_function("CL_Target","get_alpha_mask",toluaI_CL_Target_get_alpha_mask0);
 tolua_function("CL_Target","get_palette",toluaI_CL_Target_get_palette0);
 tolua_function("CL_Target","push_clip_rect",toluaI_CL_Target_push_clip_rect0);
 tolua_function("CL_Target","push_clip_rect",toluaI_CL_Target_push_clip_rect1);
 tolua_function("CL_Target","get_clip_rect",toluaI_CL_Target_get_clip_rect0);
 tolua_function("CL_Target","set_clip_rect",toluaI_CL_Target_set_clip_rect0);
 tolua_function("CL_Target","pop_clip_rect",toluaI_CL_Target_pop_clip_rect0);
 tolua_function("CL_Target","fill_rect",toluaI_CL_Target_fill_rect0);
 tolua_function("CL_Target","draw_line",toluaI_CL_Target_draw_line0);
 tolua_cclass("CL_SurfaceProvider","CL_Target");
 tolua_function("CL_SurfaceProvider","delete",toluaI_CL_SurfaceProvider_delete0);
 tolua_function("CL_SurfaceProvider","get_translate_x",toluaI_CL_SurfaceProvider_get_translate_x0);
 tolua_function("CL_SurfaceProvider","get_translate_y",toluaI_CL_SurfaceProvider_get_translate_y0);
 tolua_function("CL_SurfaceProvider","uses_src_colorkey",toluaI_CL_SurfaceProvider_uses_src_colorkey0);
 tolua_function("CL_SurfaceProvider","get_src_colorkey",toluaI_CL_SurfaceProvider_get_src_colorkey0);
 tolua_cclass("CL_Canvas","CL_SurfaceProvider");
 tolua_function("CL_Canvas","create",toluaI_CL_Canvas_create0);
 tolua_function("CL_Canvas","new",toluaI_CL_Canvas_new0);
 tolua_function("CL_Canvas","delete",toluaI_CL_Canvas_delete0);
 tolua_function("CL_Canvas","get_width",toluaI_CL_Canvas_get_width0);
 tolua_function("CL_Canvas","get_height",toluaI_CL_Canvas_get_height0);
 tolua_function("CL_Canvas","get_num_frames",toluaI_CL_Canvas_get_num_frames0);
 tolua_function("CL_Canvas","get_red_mask",toluaI_CL_Canvas_get_red_mask0);
 tolua_function("CL_Canvas","get_green_mask",toluaI_CL_Canvas_get_green_mask0);
 tolua_function("CL_Canvas","get_blue_mask",toluaI_CL_Canvas_get_blue_mask0);
 tolua_function("CL_Canvas","get_alpha_mask",toluaI_CL_Canvas_get_alpha_mask0);
 tolua_function("CL_Canvas","get_pitch",toluaI_CL_Canvas_get_pitch0);
 tolua_function("CL_Canvas","is_indexed",toluaI_CL_Canvas_is_indexed0);
 tolua_function("CL_Canvas","set_palette",toluaI_CL_Canvas_set_palette0);
 tolua_function("CL_Canvas","get_palette",toluaI_CL_Canvas_get_palette0);
 tolua_function("CL_Canvas","set_src_colorkey",toluaI_CL_Canvas_set_src_colorkey0);
 tolua_function("CL_Canvas","uses_src_colorkey",toluaI_CL_Canvas_uses_src_colorkey0);
 tolua_function("CL_Canvas","get_src_colorkey",toluaI_CL_Canvas_get_src_colorkey0);
 tolua_function("CL_Canvas","get_data",toluaI_CL_Canvas_get_data0);
 tolua_function("CL_Canvas","lock",toluaI_CL_Canvas_lock0);
 tolua_function("CL_Canvas","unlock",toluaI_CL_Canvas_unlock0);
 tolua_cclass("CL_ClipRect","");
 tolua_tablevar("CL_ClipRect","m_x1",toluaI_get_CL_ClipRect_m_x1,toluaI_set_CL_ClipRect_m_x1);
 tolua_tablevar("CL_ClipRect","m_y1",toluaI_get_CL_ClipRect_m_y1,toluaI_set_CL_ClipRect_m_y1);
 tolua_tablevar("CL_ClipRect","m_x2",toluaI_get_CL_ClipRect_m_x2,toluaI_set_CL_ClipRect_m_x2);
 tolua_tablevar("CL_ClipRect","m_y2",toluaI_get_CL_ClipRect_m_y2,toluaI_set_CL_ClipRect_m_y2);
 tolua_function("CL_ClipRect","new",toluaI_CL_ClipRect_new0);
 tolua_function("CL_ClipRect","new",toluaI_CL_ClipRect_new1);
 tolua_function("CL_ClipRect","new",toluaI_CL_ClipRect_new2);
 tolua_function("CL_ClipRect","delete",toluaI_CL_ClipRect_delete0);
 tolua_function("CL_ClipRect","test_clipped",toluaI_CL_ClipRect_test_clipped0);
 tolua_function("CL_ClipRect","test_unclipped",toluaI_CL_ClipRect_test_unclipped0);
 tolua_function("CL_ClipRect","test_all_clipped",toluaI_CL_ClipRect_test_all_clipped0);
 tolua_function("CL_ClipRect","clip",toluaI_CL_ClipRect_clip0);
 lua_endblock();
 return 1;
}
/* Close function */
void tolua_clanLua_close (void)
{
 lua_pushnil(); lua_setglobal("TRUE");
 lua_pushnil(); lua_setglobal("FALSE");
 lua_pushnil(); lua_setglobal("CL_Display");
 lua_pushnil(); lua_setglobal("CL_System");
 lua_pushnil(); lua_setglobal("CL_Mouse");
 lua_pushnil(); lua_setglobal("CL_Keyboard");
 lua_pushnil(); lua_setglobal("CL_KEY_A");
 lua_pushnil(); lua_setglobal("CL_KEY_B");
 lua_pushnil(); lua_setglobal("CL_KEY_C");
 lua_pushnil(); lua_setglobal("CL_KEY_D");
 lua_pushnil(); lua_setglobal("CL_KEY_E");
 lua_pushnil(); lua_setglobal("CL_KEY_F");
 lua_pushnil(); lua_setglobal("CL_KEY_G");
 lua_pushnil(); lua_setglobal("CL_KEY_H");
 lua_pushnil(); lua_setglobal("CL_KEY_I");
 lua_pushnil(); lua_setglobal("CL_KEY_J");
 lua_pushnil(); lua_setglobal("CL_KEY_K");
 lua_pushnil(); lua_setglobal("CL_KEY_L");
 lua_pushnil(); lua_setglobal("CL_KEY_M");
 lua_pushnil(); lua_setglobal("CL_KEY_N");
 lua_pushnil(); lua_setglobal("CL_KEY_O");
 lua_pushnil(); lua_setglobal("CL_KEY_P");
 lua_pushnil(); lua_setglobal("CL_KEY_Q");
 lua_pushnil(); lua_setglobal("CL_KEY_R");
 lua_pushnil(); lua_setglobal("CL_KEY_S");
 lua_pushnil(); lua_setglobal("CL_KEY_T");
 lua_pushnil(); lua_setglobal("CL_KEY_U");
 lua_pushnil(); lua_setglobal("CL_KEY_V");
 lua_pushnil(); lua_setglobal("CL_KEY_W");
 lua_pushnil(); lua_setglobal("CL_KEY_X");
 lua_pushnil(); lua_setglobal("CL_KEY_Y");
 lua_pushnil(); lua_setglobal("CL_KEY_Z");
 lua_pushnil(); lua_setglobal("CL_KEY_0");
 lua_pushnil(); lua_setglobal("CL_KEY_1");
 lua_pushnil(); lua_setglobal("CL_KEY_2");
 lua_pushnil(); lua_setglobal("CL_KEY_3");
 lua_pushnil(); lua_setglobal("CL_KEY_4");
 lua_pushnil(); lua_setglobal("CL_KEY_5");
 lua_pushnil(); lua_setglobal("CL_KEY_6");
 lua_pushnil(); lua_setglobal("CL_KEY_7");
 lua_pushnil(); lua_setglobal("CL_KEY_8");
 lua_pushnil(); lua_setglobal("CL_KEY_9");
 lua_pushnil(); lua_setglobal("CL_KEY_F1");
 lua_pushnil(); lua_setglobal("CL_KEY_F2");
 lua_pushnil(); lua_setglobal("CL_KEY_F3");
 lua_pushnil(); lua_setglobal("CL_KEY_F4");
 lua_pushnil(); lua_setglobal("CL_KEY_F5");
 lua_pushnil(); lua_setglobal("CL_KEY_F6");
 lua_pushnil(); lua_setglobal("CL_KEY_F7");
 lua_pushnil(); lua_setglobal("CL_KEY_F8");
 lua_pushnil(); lua_setglobal("CL_KEY_F9");
 lua_pushnil(); lua_setglobal("CL_KEY_F10");
 lua_pushnil(); lua_setglobal("CL_KEY_F11");
 lua_pushnil(); lua_setglobal("CL_KEY_F12");
 lua_pushnil(); lua_setglobal("CL_KEY_ESCAPE");
 lua_pushnil(); lua_setglobal("CL_KEY_LEFT");
 lua_pushnil(); lua_setglobal("CL_KEY_RIGHT");
 lua_pushnil(); lua_setglobal("CL_KEY_UP");
 lua_pushnil(); lua_setglobal("CL_KEY_DOWN");
 lua_pushnil(); lua_setglobal("CL_KEY_LCTRL");
 lua_pushnil(); lua_setglobal("CL_KEY_RCTRL");
 lua_pushnil(); lua_setglobal("CL_KEY_LSHIFT");
 lua_pushnil(); lua_setglobal("CL_KEY_RSHIFT");
 lua_pushnil(); lua_setglobal("CL_KEY_ALT");
 lua_pushnil(); lua_setglobal("CL_KEY_ALTGR");
 lua_pushnil(); lua_setglobal("CL_KEY_TAB");
 lua_pushnil(); lua_setglobal("CL_KEY_ENTER");
 lua_pushnil(); lua_setglobal("CL_KEY_SPACE");
 lua_pushnil(); lua_setglobal("CL_KEY_BACKSPACE");
 lua_pushnil(); lua_setglobal("CL_KEY_INSERT");
 lua_pushnil(); lua_setglobal("CL_KEY_DELETE");
 lua_pushnil(); lua_setglobal("CL_KEY_HOME");
 lua_pushnil(); lua_setglobal("CL_KEY_END");
 lua_pushnil(); lua_setglobal("CL_KEY_PAGEUP");
 lua_pushnil(); lua_setglobal("CL_KEY_PAGEDOWN");
 lua_pushnil(); lua_setglobal("CL_KEY_CAPSLOCK");
 lua_pushnil(); lua_setglobal("CL_KEY_NUMLOCK");
 lua_pushnil(); lua_setglobal("CL_KEY_SCRLOCK");
 lua_pushnil(); lua_setglobal("CL_KEY_PRINT");
 lua_pushnil(); lua_setglobal("CL_KEY_PAUSE");
 lua_pushnil(); lua_setglobal("CL_KEY_KP_DIV");
 lua_pushnil(); lua_setglobal("CL_KEY_KP_MULT");
 lua_pushnil(); lua_setglobal("CL_KEY_KP_MINUS");
 lua_pushnil(); lua_setglobal("CL_KEY_KP_PLUS");
 lua_pushnil(); lua_setglobal("CL_KEY_KP_ENTER");
 lua_pushnil(); lua_setglobal("CL_KEY_NONE_OF_THE_ABOVE");
 lua_pushnil(); lua_setglobal("CL_NUM_KEYS");
 lua_pushnil(); lua_setglobal("CL_Surface");
 lua_pushnil(); lua_setglobal("CL_Target");
 lua_pushnil(); lua_setglobal("CL_SurfaceProvider");
 lua_pushnil(); lua_setglobal("CL_Canvas");
 lua_pushnil(); lua_setglobal("CL_ClipRect");
}

---