Merge pull request #300 from minggo/lua

Lua support

Box2D/Android.mk

@@ -43,4 +43,4 @@ Dynamics/b2WorldCallbacks.cpp
 
 LOCAL_C_INCLUDES := $(LOCAL_PATH)/..
                                  
-include $(BUILD_SHARED_LIBRARY)
+include $(BUILD_STATIC_LIBRARY)

CocosDenshion/android/Android.mk

@@ -5,9 +5,7 @@ LOCAL_MODULE := cocosdenshion
 LOCAL_SRC_FILES := SimpleAudioEngine.cpp \
 jni/SimpleAudioEngineJni.cpp
 
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/../include
-                   
-LOCAL_LDLIBS := -llog
-
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/../include \
+                    $(LOCAL_PATH)/../../cocos2dx                   
             
-include $(BUILD_SHARED_LIBRARY)
+include $(BUILD_STATIC_LIBRARY)

CocosDenshion/android/jni/SimpleAudioEngineJni.cpp

@@ -1,4 +1,5 @@
 #include "SimpleAudioEngineJni.h"
+#include "platform/android/Cocos2dJni.h"
 #include <android/log.h>
 
 #define  LOG_TAG    "libSimpleAudioEngine"
@@ -7,17 +8,9 @@
 
 extern "C"
 {
-	static JavaVM *gJavaVM = 0;
 	static jclass classOfCocos2dxActivity = 0;
 	JNIEnv *env = 0;
 
-	jint JNI_OnLoad(JavaVM *vm, void *reserved)
-	{
-		gJavaVM = vm;
-
-		return JNI_VERSION_1_4;
-	}
-
 	static jmethodID getMethodID(const char *methodName, const char *paramCode)
 	{
 		jmethodID ret = 0;

CocosDenshion/proj.win32/CocosDenshion.win32.vcproj.user

@@ -1 +1 @@
-<?xml version="1.0" encoding="utf-8"?><VisualStudioUserFile ProjectType="Visual C++" Version="9.00" ShowAllFiles="true"></VisualStudioUserFile>
+<?xml version="1.0" encoding="utf-8"?><VisualStudioUserFile ProjectType="Visual C++" Version="9.00" ShowAllFiles="false"></VisualStudioUserFile>

HelloLua/Classes/AppDelegate.cpp

@@ -0,0 +1,154 @@
+#include "AppDelegate.h"
+
+#include "cocos2d.h"
+
+USING_NS_CC;
+
+AppDelegate::AppDelegate()
+{
+
+}
+
+AppDelegate::~AppDelegate()
+{
+}
+
+bool AppDelegate::initInstance()
+{
+    bool bRet = false;
+    do 
+    {
+#if (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
+
+        // Initialize OpenGLView instance, that release by CCDirector when application terminate.
+        // The HelloWorld is designed as HVGA.
+        CCEGLView * pMainWnd = new CCEGLView();
+        CC_BREAK_IF(! pMainWnd
+            || ! pMainWnd->Create(TEXT("cocos2d: Hello World"), 480, 320));
+
+#endif  // CC_PLATFORM_WIN32
+        
+#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
+
+        // OpenGLView initialized in testsAppDelegate.mm on ios platform, nothing need to do here.
+
+#endif  // CC_PLATFORM_IOS
+        
+#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
+
+		// OpenGLView initialized in HelloWorld/android/jni/helloworld/main.cpp
+		// the default setting is to create a fullscreen view
+		// if you want to use auto-scale, please enable view->create(320,480) in main.cpp
+
+#endif  // CC_PLATFORM_ANDROID
+
+#if (CC_TARGET_PLATFORM == CC_PLATFORM_WOPHONE)
+
+        // Initialize OpenGLView instance, that release by CCDirector when application terminate.
+        // The HelloWorld is designed as HVGA.
+        CCEGLView* pMainWnd = new CCEGLView(this);
+        CC_BREAK_IF(! pMainWnd || ! pMainWnd->Create(320,480, WM_WINDOW_ROTATE_MODE_CW));
+
+#ifndef _TRANZDA_VM_  
+        // on wophone emulator, we copy resources files to Work7/NEWPLUS/TDA_DATA/Data/ folder instead of zip file
+        cocos2d::CCFileUtils::setResource("HelloWorld.zip");
+#endif
+
+#endif  // CC_PLATFORM_WOPHONE
+
+#if (CC_TARGET_PLATFORM == CC_PLATFORM_AIRPLAY)
+		// MaxAksenov said it's NOT a very elegant solution. I agree, haha
+		CCDirector::sharedDirector()->setDeviceOrientation(kCCDeviceOrientationLandscapeLeft);
+#endif
+        bRet = true;
+    } while (0);
+    return bRet;
+}
+
+bool AppDelegate::applicationDidFinishLaunching()
+{
+	// initialize director
+	CCDirector *pDirector = CCDirector::sharedDirector();
+    pDirector->setOpenGLView(&CCEGLView::sharedOpenGLView());
+
+    // enable High Resource Mode(2x, such as iphone4) and maintains low resource on other devices.
+//     pDirector->enableRetinaDisplay(true);
+
+	// turn on display FPS
+	pDirector->setDisplayFPS(true);
+
+	// pDirector->setDeviceOrientation(kCCDeviceOrientationLandscapeLeft);
+
+	// set FPS. the default value is 1.0/60 if you don't call this
+	pDirector->setAnimationInterval(1.0 / 60);
+
+#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
+        CCLog("1");
+	unsigned long size;
+	char *pFileContent = (char*)CCFileUtils::getFileData("hello.lua", "r", &size);
+
+	if (pFileContent)
+	{
+	    // copy the file contents and add '\0' at the end, or the lua parser can not parse it
+	    char *pTmp = new char[size + 1];
+	    pTmp[size] = '\0';
+	    memcpy(pTmp, pFileContent, size);
+	    delete[] pFileContent;
+
+	    string code(pTmp);
+	    CCLuaScriptModule::sharedLuaScriptModule()->executeString(code);
+	    delete []pTmp;
+	}
+#endif
+
+#if (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
+	CCLuaScriptModule::sharedLuaScriptModule()->executeScriptFile("./../../HelloLua/Resource/hello.lua");
+
+	/*
+	 * Another way to run lua script.
+	 * Load the file into memory and run it.
+	 *
+	unsigned long size;
+	char *pFileContent = (char*)CCFileUtils::getFileData("./../../HelloLua/Resource/hello.lua", "r", &size);
+	if (pFileContent)
+	{
+		// copy the file contents and add '\0' at the end, or the lua parser can not parse it
+		char *pTmp = new char[size + 1];
+		pTmp[size] = '\0';
+		memcpy(pTmp, pFileContent, size);
+		delete[] pFileContent;
+
+		string code(pTmp);
+		CCLuaScriptModule::sharedLuaScriptModule()->executeString(code);
+		delete []pTmp;
+	}
+	*/
+	
+#endif
+
+#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
+    pDirector->setDeviceOrientation(kCCDeviceOrientationLandscapeLeft);
+	string path = CCFileUtils::fullPathFromRelativePath("hello.lua");
+    CCLuaScriptModule::sharedLuaScriptModule()->executeScriptFile(path.c_str());
+#endif 
+
+	return true;
+}
+
+// This function will be called when the app is inactive. When comes a phone call,it's be invoked too
+void AppDelegate::applicationDidEnterBackground()
+{
+    CCDirector::sharedDirector()->pause();
+
+	// if you use SimpleAudioEngine, it must be pause
+	// SimpleAudioEngine::sharedEngine()->pauseBackgroundMusic();
+}
+
+// this function will be called when the app is active again
+void AppDelegate::applicationWillEnterForeground()
+{
+    CCDirector::sharedDirector()->resume();
+	
+	// if you use SimpleAudioEngine, it must resume here
+	// SimpleAudioEngine::sharedEngine()->resumeBackgroundMusic();
+}

HelloLua/Classes/AppDelegate.h

@@ -0,0 +1,43 @@
+#ifndef  _APP_DELEGATE_H_
+#define  _APP_DELEGATE_H_
+
+#include "CCApplication.h"
+
+/**
+@brief	The cocos2d Application.
+
+The reason for implement as private inheritance is to hide some interface call by CCDirector.
+*/
+class  AppDelegate : private cocos2d::CCApplication
+{
+public:
+	AppDelegate();
+	virtual ~AppDelegate();
+
+    /**
+    @brief	Implement for initialize OpenGL instance, set source path, etc...
+    */
+    virtual bool initInstance();
+
+    /**
+    @brief	Implement CCDirector and CCScene init code here.
+    @return true    Initialize success, app continue.
+    @return false   Initialize failed, app terminate.
+    */
+    virtual bool applicationDidFinishLaunching();
+
+    /**
+    @brief  The function be called when the application enter background
+    @param  the pointer of the application
+    */
+    virtual void applicationDidEnterBackground();
+
+    /**
+    @brief  The function be called when the application enter foreground
+    @param  the pointer of the application
+    */
+    virtual void applicationWillEnterForeground();
+};
+
+#endif // _APP_DELEGATE_H_
+

HelloLua/Resource/90001.jpg.REMOVED.git-id

@@ -0,0 +1 @@
+d7290c34702d1c6bdb368acb060d93b42d5deff8

HelloLua/Resource/hello.lua

@@ -0,0 +1,197 @@
+lastMouseX = 0;
+lastMouseY = 0;
+
+
+
+g_Scene = cocos2d.CCScene:node();
+pSprite = cocos2d.CCSprite:spriteWithFile("90001.jpg");pSprite:setPosition(cocos2d.CCPoint(300, 400));
+
+
+pLayer = cocos2d.CCLayer:node();
+pLayer:setIsTouchEnabled(true);
+pLayer:setAnchorPoint(cocos2d.CCPoint(0,0));
+pLayer:setPosition( cocos2d.CCPoint(0, -300) );
+g_Scene:addChild(pLayer);
+
+
+
+function btnTouchMove(e)
+
+	cocos2d.CCLuaLog("mousemove");
+	touch = e:anyObject()
+	debug.setmetatable(touch, cocos2d.CCTouch)
+	cocos2d.CCLuaLog("btnTouchBegin")
+	X = touch:locationInView(touch:view()).x
+	Y = touch:locationInView(touch:view()).y
+
+	OffX = lastMouseX - X;
+	OffY = lastMouseY - Y;
+	lastMouseX = X;
+	lastMouseY = Y;
+
+	point = pLayer:getPosition();
+
+	point.x = point.x + OffX;
+
+	if point.x  >100 then
+		point.x = 100
+	elseif point.x  < 0 then
+		point.x = 0
+	end
+
+	pLayer:setPosition(point)
+
+end --fuction
+
+
+function btnTouchBegin(e)
+
+	count = e:count();
+	if count > 1 then
+		cocos2d.CCLuaLog("2 click");
+	end
+
+	touch = e:anyObject()
+	debug.setmetatable(touch, cocos2d.CCTouch)
+	cocos2d.CCLuaLog("btnTouchBegin")
+	lastMouseX = touch:locationInView(touch:view()).x
+	lastMouseY = touch:locationInView(touch:view()).y
+
+	cocos2d.CCLuaLog("btnTouchBegin")
+end
+
+
+
+
+function btnTouchEnd(e)
+	cocos2d.CCLuaLog("btnTouchEnd")
+end
+
+-- register touch handler
+pLayer.__CCTouchDelegate__:registerLuaTouchEvent("ccTouchBegan", "btnTouchBegin")
+pLayer.__CCTouchDelegate__:registerLuaTouchEvent("ccTouchMoved", "btnTouchMove")
+pLayer.__CCTouchDelegate__:registerLuaTouchEvent("ccTouchEnded", "btnTouchEnd")
+pLayer:addChild(pSprite)
+
+
+
+-- add pop menu
+menuItem = cocos2d.CCMenuItemImage:itemFromNormalImage("menu2.png","menu2.png");
+menuItem:setAnchorPoint(cocos2d.CCPoint(0,0));
+menuItem:setPosition( cocos2d.CCPoint(100, 200) );
+menuItem:registerMenuHandler("CloseMenu");
+pMenu = cocos2d.CCMenu:menuWithItem(menuItem);
+pMenu:setPosition( cocos2d.CCPoint(1000, 200) );
+g_Scene:addChild(pMenu);
+
+
+
+function CloseMenu()
+	pMenu:setPosition(cocos2d.CCPoint(1000, 200) );
+
+end
+
+
+
+function PopMenu()
+
+	pMenu:setPosition( cocos2d.CCPoint(0, -50) );
+	cocos2d.CCLuaLog("pop click");
+
+end
+
+
+
+
+pCloseItem = cocos2d.CCMenuItemImage:itemFromNormalImage("menu1.png","menu1.png");
+pCloseItem:setPosition( cocos2d.CCPoint(30, 40) );
+pCloseItem:registerMenuHandler("PopMenu");
+pcloseMenu = cocos2d.CCMenu:menuWithItem(pCloseItem);
+pcloseMenu:setPosition( cocos2d.CCPoint(30, 40) );
+g_Scene:addChild(pcloseMenu);
+
+
+
+for i=0,3,1 do
+	for j=0,1,1 do
+
+		landSprite = cocos2d.CCSprite:spriteWithFile("land1.png");
+		pLayer:addChild(landSprite);
+
+		landSprite:setAnchorPoint(cocos2d.CCPoint(0,0));
+		landSprite:setPosition(cocos2d.CCPoint(90+j*180 - i%2*90, 200+i*95/2));
+
+	end
+end
+
+
+
+--crop
+
+for i=0,3,1 do
+	for j=0,1,1 do
+
+		texturecrop = cocos2d.CCTextureCache:sharedTextureCache():addImage("crop1.png");
+		framecrop = cocos2d.CCSpriteFrame:frameWithTexture(texturecrop, cocos2d.CCRectMake(0, 0, 105, 95));
+		spritecrop = cocos2d.CCSprite:spriteWithSpriteFrame(framecrop);
+
+		pLayer:addChild(spritecrop);
+
+		spritecrop:setAnchorPoint(cocos2d.CCPoint(0,0));
+		spritecrop:setPosition(cocos2d.CCPoint(45+90+j*180 - i%2*90, 25+200+i*95/2));
+
+	end
+end
+
+
+
+
+nFrameWidth = 105;
+nFrameHeight = 95;
+
+texture = cocos2d.CCTextureCache:sharedTextureCache():addImage("dog1.png");
+frame0 = cocos2d.CCSpriteFrame:frameWithTexture(texture, cocos2d.CCRectMake(0, 0, nFrameWidth, nFrameHeight));
+frame1 = cocos2d.CCSpriteFrame:frameWithTexture(texture, cocos2d.CCRectMake(nFrameWidth*1, 0, nFrameWidth, nFrameHeight));
+
+
+spritedog = cocos2d.CCSprite:spriteWithSpriteFrame(frame0);
+spritedog:setPosition(cocos2d.CCPoint(300, 500));
+pLayer:addChild(spritedog);
+
+
+
+animFrames = cocos2d.CCMutableArray_CCSpriteFrame__:new(2);
+
+animFrames:addObject(frame0);
+animFrames:addObject(frame1);
+
+
+animation = cocos2d.CCAnimation:animationWithName("wait", 0.5, animFrames)
+
+animate = cocos2d.CCAnimate:actionWithAnimation(animation, false);
+spritedog:runAction(cocos2d.CCRepeatForever:actionWithAction(animate))
+
+
+cocos2d.CCDirector:sharedDirector():runWithScene(g_Scene);
+
+
+
+function tick(cc)
+
+	point = cocos2d.CCPoint(300, 500);
+	point = spritedog:getPosition();
+
+
+	if point.x > 600 then
+		point.x = 0
+		spritedog:setPosition(point)
+	else
+		point.x = point.x + 1
+		spritedog:setPosition(point)
+	end
+
+end
+
+cocos2d.CCDirector:sharedDirector():registerTick("tick")
+
+

HelloLua/android/AndroidManifest.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="org.cocos2dx.hellolua"
+      android:versionCode="1"
+      android:versionName="1.0">
+    <application android:label="@string/app_name" android:debuggable="true">
+        <activity android:name=".HelloLua"
+                  android:label="@string/app_name"
+                  android:screenOrientation="landscape"
+                  android:theme="@android:style/Theme.NoTitleBar.Fullscreen">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+    <supports-screens android:largeScreens="true"
+                      android:smallScreens="true"
+                      android:anyDensity="true"
+                      android:normalScreens="true"/>
+</manifest> 

HelloLua/android/build_native.sh

@@ -0,0 +1,33 @@
+# set params
+ANDROID_NDK_ROOT=/cygdrive/e/android-ndk-r5
+COCOS2DX_ROOT=/cygdrive/d/Work7/cocos2d-x
+GAME_ROOT=$COCOS2DX_ROOT/HelloLua
+GAME_ANDROID_ROOT=$GAME_ROOT/android
+RESOURCE_ROOT=$GAME_ROOT/Resource
+
+# make sure assets is exist
+if [ -d $GAME_ANDROID_ROOT/assets ]; then
+    rm -rf $GAME_ANDROID_ROOT/assets
+fi
+
+mkdir $GAME_ANDROID_ROOT/assets
+
+# copy resources
+for file in $RESOURCE_ROOT/*
+do
+    if [ -d $file ]; then
+        cp -rf $file $GAME_ANDROID_ROOT/assets
+    fi
+
+    if [ -f $file ]; then
+        cp $file $GAME_ANDROID_ROOT/assets
+    fi
+done
+
+# to enable lua
+ENABLE_LUA=true
+export ENABLE_LUA
+
+# build
+$ANDROID_NDK_ROOT/ndk-build -C $GAME_ANDROID_ROOT $*
+

HelloLua/android/default.properties

@@ -0,0 +1,11 @@
+# This file is automatically generated by Android Tools.
+# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
+#
+# This file must be checked in Version Control Systems.
+#
+# To customize properties used by the Ant build system use,
+# "build.properties", and override values to adapt the script to your
+# project structure.
+
+# Project target.
+target=android-7

HelloLua/android/jni/Android.mk

@@ -0,0 +1,11 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+subdirs := $(addprefix $(LOCAL_PATH)/../../../,$(addsuffix /Android.mk, \
+           cocos2dx \
+           CocosDenshion/android \
+           lua/jni \
+	))
+subdirs += $(LOCAL_PATH)/helloworld/Android.mk
+
+include $(subdirs)

HelloLua/android/jni/Application.mk

@@ -0,0 +1,3 @@
+# it is needed for ndk-r5
+APP_STL := stlport_static
+APP_MODULES := game

HelloLua/android/jni/helloworld/Android.mk

@@ -0,0 +1,41 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+LOCAL_MODULE := game
+
+LOCAL_SRC_FILES := main.cpp \
+../../../Classes/AppDelegate.cpp
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/../../../../cocos2dx \
+                    $(LOCAL_PATH)/../../../../cocos2dx/platform \
+                    $(LOCAL_PATH)/../../../../cocos2dx/include \
+                    $(LOCAL_PATH)/../../../../cocos2dx/lua_support \
+                    $(LOCAL_PATH)/../../../../CocosDenshion/include \
+                    $(LOCAL_PATH)/../../../Classes \
+                    $(LOCAL_PATH)/../../../../lua/src \
+                    $(LOCAL_PATH)/../../../../lua/tolua 
+
+# it is used for ndk-r4
+# if you build with nkd-r4, uncomment it                    
+# LOCAL_LDLIBS := -llog -lGLESv1_CM -llog -lz \
+#                -L$(LOCAL_PATH)/../../../../cocos2dx/platform/third_party/android/libraries -lcurl \
+#                -lpng \
+#                -lxml2 \
+#                -ljpeg \
+#                -lskia
+
+# it is used for ndk-r5  
+# if you build with ndk-r4, comment it  
+# because the new Windows toolchain doesn't support Cygwin's drive
+# mapping (i.e /cygdrive/c/ instead of C:/)  
+LOCAL_LDLIBS := -llog -lGLESv1_CM -llog -lz \
+                -L$(call host-path, $(LOCAL_PATH)/../../../../cocos2dx/platform/third_party/android/libraries) -lcurl \
+                -lpng \
+                -lxml2 \
+                -ljpeg \
+                -lskia
+                
+LOCAL_STATIC_LIBRARIES := libcocos2d libcocosdenshion liblua
+
+LOCAL_CFLAGS := -DENABLE_LUA
+            
+include $(BUILD_SHARED_LIBRARY)

HelloLua/android/jni/helloworld/main.cpp

@@ -0,0 +1,38 @@
+#include "AppDelegate.h"
+#include "cocos2d.h"
+#include <jni.h>
+#include <android/log.h>
+
+#define  LOG_TAG    "main"
+#define  LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG,LOG_TAG,__VA_ARGS__)
+
+using namespace cocos2d;
+
+#define IMG_PATH        "assets"
+
+extern "C"
+{
+
+void Java_org_cocos2dx_lib_Cocos2dxRenderer_nativeInit(JNIEnv*  env, jobject thiz, jint w, jint h)
+{
+    if (!cocos2d::CCDirector::sharedDirector()->getOpenGLView())
+    {
+	cocos2d::CCEGLView *view = &cocos2d::CCEGLView::sharedOpenGLView();
+        view->setFrameWidthAndHeight(w, h);
+        // if you want to run in WVGA with HVGA resource, set it
+        // view->create(320, 480);
+        cocos2d::CCDirector::sharedDirector()->setOpenGLView(view);
+
+        CCFileUtils::setRelativePath(IMG_PATH);
+
+        AppDelegate *pAppDelegate = new AppDelegate();
+        cocos2d::CCApplication::sharedApplication().run();
+    }
+    else
+    {
+        cocos2d::CCTextureCache::reloadAllTextures();
+        cocos2d::CCDirector::sharedDirector()->setGLDefaultValues();
+    }
+}
+
+}

HelloLua/android/res/layout/game_demo.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+	android:layout_width="fill_parent"
+	android:layout_height="fill_parent"
+	android:orientation="vertical">
+
+	<org.cocos2dx.lib.Cocos2dxGLSurfaceView
+		android:id="@+id/game_gl_surfaceview"
+		android:layout_width="fill_parent"
+		android:layout_height="fill_parent"/>
+
+</LinearLayout>

HelloLua/android/res/values/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">HelloLua</string>
+</resources>

HelloLua/android/src/org/cocos2dx/hellolua/HelloLua.java

@@ -0,0 +1,49 @@
+package org.cocos2dx.hellolua;
+import org.cocos2dx.lib.Cocos2dxActivity;
+import org.cocos2dx.lib.Cocos2dxGLSurfaceView;
+import org.cocos2dx.hellolua.R;
+
+
+import android.opengl.GLSurfaceView;
+import android.os.Bundle;
+
+public class HelloLua extends Cocos2dxActivity{
+	protected void onCreate(Bundle savedInstanceState){
+		super.onCreate(savedInstanceState);
+		
+		// get the packageName,it's used to set the resource path
+		String packageName = getApplication().getPackageName();
+		super.setPackageName(packageName);
+		
+		setContentView(R.layout.game_demo);
+        mGLView = (Cocos2dxGLSurfaceView) findViewById(R.id.game_gl_surfaceview);
+
+        // Get the size of the mGLView after the layout happens
+        mGLView.post(new Runnable() {
+            
+            @Override
+            public void run() {
+                Cocos2dxActivity.screenHeight = mGLView.getHeight();
+                Cocos2dxActivity.screenWidth = mGLView.getWidth();
+            }
+        });
+	}
+	
+	 @Override
+	 protected void onPause() {
+	     super.onPause();
+	     mGLView.onPause();
+	 }
+
+	 @Override
+	 protected void onResume() {
+	     super.onResume();
+	     mGLView.onResume();
+	 }
+	  
+	 private GLSurfaceView mGLView;
+	
+     static {
+         System.loadLibrary("game");
+     }
+}

HelloLua/android/src/org/cocos2dx/lib/Cocos2dxAccelerometer.java

@@ -0,0 +1,52 @@
+package org.cocos2dx.lib;
+
+import android.content.Context;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+
+/**
+ * 
+ * This class is used for controlling the Accelerometer
+ *
+ */
+public class Cocos2dxAccelerometer implements SensorEventListener {
+	
+	private static final String TAG = "Cocos2dxAccelerometer";
+	private Context mContext;
+	private SensorManager mSensorManager;
+	private Sensor mAccelerometer;
+
+	public Cocos2dxAccelerometer(Context context){
+		mContext = context;
+
+		//Get an instance of the SensorManager
+	    mSensorManager = (SensorManager) mContext.getSystemService(Context.SENSOR_SERVICE);
+	    mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
+	}
+
+	public void enable() {
+		mSensorManager.registerListener(this, mAccelerometer, SensorManager.SENSOR_DELAY_GAME);
+	}
+
+	public void disable () {
+		mSensorManager.unregisterListener(this);
+	}
+
+	@Override
+	public void onSensorChanged(SensorEvent event) {
+
+		if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER)
+            return;
+
+        onSensorChanged(event.values[0], event.values[1], event.values[2], event.timestamp);
+        
+	}
+
+	@Override
+	public void onAccuracyChanged(Sensor sensor, int accuracy) {
+	}
+
+	private static native void onSensorChanged(float x, float y, float z, long timeStamp);
+}

HelloLua/android/src/org/cocos2dx/lib/Cocos2dxActivity.java

@@ -0,0 +1,245 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * This is a small port of the "San Angeles Observation" demo
+ * program for OpenGL ES 1.x. For more details, see:
+ *
+ *    http://jet.ro/visuals/san-angeles-observation/
+ *
+ * This program demonstrates how to use a GLSurfaceView from Java
+ * along with native OpenGL calls to perform frame rendering.
+ *
+ * Touching the screen will start/stop the animation.
+ *
+ * Note that the demo runs much faster on the emulator than on
+ * real devices, this is mainly due to the following facts:
+ *
+ * - the demo sends bazillions of polygons to OpenGL without
+ *   even trying to do culling. Most of them are clearly out
+ *   of view.
+ *
+ * - on a real device, the GPU bus is the real bottleneck
+ *   that prevent the demo from getting acceptable performance.
+ *
+ * - the software OpenGL engine used in the emulator uses
+ *   the system bus instead, and its code rocks :-)
+ *
+ * Fixing the program to send less polygons to the GPU is left
+ * as an exercise to the reader. As always, patches welcomed :-)
+ */
+
+package org.cocos2dx.lib;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.util.DisplayMetrics;
+import android.util.Log;
+
+public class Cocos2dxActivity extends Activity{
+	public static int screenWidth;
+    public static int screenHeight;
+    private static Cocos2dxMusic backgroundMusicPlayer;
+    private static Cocos2dxSound soundPlayer;
+    private static Cocos2dxAccelerometer accelerometer;
+    private static boolean accelerometerEnabled = false;
+    private static Handler handler;
+    private final static int HANDLER_SHOW_DIALOG = 1;
+    private static String packageName;
+
+    private static native void nativeSetPaths(String apkPath);
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        
+        // get frame size
+        DisplayMetrics dm = new DisplayMetrics();
+        getWindowManager().getDefaultDisplay().getMetrics(dm);
+        screenWidth = dm.widthPixels;
+        screenHeight = dm.heightPixels;
+        accelerometer = new Cocos2dxAccelerometer(this);
+
+        // init media player and sound player
+        backgroundMusicPlayer = new Cocos2dxMusic(this);
+        soundPlayer = new Cocos2dxSound(this);
+        
+        handler = new Handler(){
+        	public void handleMessage(Message msg){
+        		switch(msg.what){
+        		case HANDLER_SHOW_DIALOG:
+        			showDialog(((DialogMessage)msg.obj).title, ((DialogMessage)msg.obj).message);
+        			break;
+        		}
+        	}
+        };
+    }
+    
+    public static void showMessageBox(String title, String message){
+    	Message msg = new Message();
+    	msg.what = HANDLER_SHOW_DIALOG;
+    	msg.obj = new DialogMessage(title, message);
+    	
+    	handler.sendMessage(msg);
+    } 
+
+    public static void enableAccelerometer() {
+        accelerometerEnabled = true;
+        accelerometer.enable();
+    }
+
+    public static void disableAccelerometer() {
+        accelerometerEnabled = false;
+        accelerometer.disable();
+    }
+
+    public static void playBackgroundMusic(String path, boolean isLoop){
+    	backgroundMusicPlayer.playBackgroundMusic(path, isLoop);
+    }
+    
+    public static void stopBackgroundMusic(){
+    	backgroundMusicPlayer.stopBackgroundMusic();
+    }
+    
+    public static void pauseBackgroundMusic(){
+    	backgroundMusicPlayer.pauseBackgroundMusic();
+    }
+    
+    public static void resumeBackgroundMusic(){
+    	backgroundMusicPlayer.resumeBackgroundMusic();
+    }
+    
+    public static void rewindBackgroundMusic(){
+    	backgroundMusicPlayer.rewindBackgroundMusic();
+    }
+    
+    public static boolean isBackgroundMusicPlaying(){
+    	return backgroundMusicPlayer.isBackgroundMusicPlaying();
+    }
+    
+    public static float getBackgroundMusicVolume(){
+    	return backgroundMusicPlayer.getBackgroundVolume();
+    }
+    
+    public static void setBackgroundMusicVolume(float volume){
+    	backgroundMusicPlayer.setBackgroundVolume(volume);
+    }
+    
+    public static int playEffect(String path){
+    	return soundPlayer.playEffect(path);
+    }
+    
+    public static void stopEffect(int soundId){
+    	soundPlayer.stopEffect(soundId);
+    }
+    
+    public static float getEffectsVolume(){
+    	return soundPlayer.getEffectsVolume();
+    }
+    
+    public static void setEffectsVolume(float volume){
+    	soundPlayer.setEffectsVolume(volume);
+    }
+    
+    public static void preloadEffect(String path){
+    	soundPlayer.preloadEffect(path);
+    }
+    
+    public static void unloadEffect(String path){
+    	soundPlayer.unloadEffect(path);
+    }
+    
+    public static void end(){
+    	backgroundMusicPlayer.end();
+    	soundPlayer.end();
+    }
+    
+    public static String getCocos2dxPackageName(){
+    	return packageName;
+    }
+
+    @Override
+    protected void onResume() {
+    	super.onResume();
+    	if (accelerometerEnabled) {
+    	    accelerometer.enable();
+    	}
+    	
+    	// resume background music
+    	resumeBackgroundMusic();
+    }
+
+    @Override
+    protected void onPause() {
+    	super.onPause();
+    	if (accelerometerEnabled) {
+    	    accelerometer.disable();
+    	}
+    	
+    	// pause background music
+    	pauseBackgroundMusic();
+    }
+
+    protected void setPackageName(String packageName) {
+    	Cocos2dxActivity.packageName = packageName;
+    	
+    	String apkFilePath = "";
+        ApplicationInfo appInfo = null;
+        PackageManager packMgmr = getApplication().getPackageManager();
+        try {
+            appInfo = packMgmr.getApplicationInfo(packageName, 0);
+        } catch (NameNotFoundException e) {
+            e.printStackTrace();
+            throw new RuntimeException("Unable to locate assets, aborting...");
+        }
+        apkFilePath = appInfo.sourceDir;
+        Log.w("apk path", apkFilePath);
+
+        // add this link at the renderer class
+        nativeSetPaths(apkFilePath);
+    }
+    
+    private void showDialog(String title, String message){
+    	Dialog dialog = new AlertDialog.Builder(this)
+	    .setTitle(title)
+	    .setMessage(message)
+	    .setPositiveButton("Ok", 
+	    new DialogInterface.OnClickListener()
+	    {
+	    	public void onClick(DialogInterface dialog, int whichButton){
+	    		
+	    	}
+	    }).create();
+
+	    dialog.show();
+    }
+}
+
+class DialogMessage {
+	public String title;
+	public String message;
+	
+	public DialogMessage(String title, String message){
+		this.message = message;
+		this.title = title;
+	}
+}

HelloLua/android/src/org/cocos2dx/lib/Cocos2dxGLSurfaceView.java

@@ -0,0 +1,374 @@
+package org.cocos2dx.lib;
+
+import android.content.Context;
+import android.opengl.GLSurfaceView;
+import android.os.Handler;
+import android.os.Message;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+import android.widget.TextView.OnEditorActionListener;
+
+class TextInputWraper implements TextWatcher, OnEditorActionListener {
+	
+	private static final Boolean debug = false;
+	private void LogD(String msg) {
+		if (debug) Log.d("TextInputFilter", msg);
+	}
+	
+	private Cocos2dxGLSurfaceView mMainView;
+	private String mText;
+	private String mOriginText;
+	
+	private Boolean isFullScreenEdit() {
+		InputMethodManager imm = (InputMethodManager)mMainView.getTextField().getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
+		return imm.isFullscreenMode();
+	}
+
+	public TextInputWraper(Cocos2dxGLSurfaceView view) {
+		mMainView = view;
+	}
+	
+	public void setOriginText(String text) {
+		mOriginText = text;
+	}
+	
+	@Override
+	public void afterTextChanged(Editable s) {
+		if (isFullScreenEdit()) {
+			return;
+		}
+		
+		LogD("afterTextChanged: " + s);
+		int nModified = s.length() - mText.length();
+		if (nModified > 0) {
+			final String insertText = s.subSequence(mText.length(), s.length()).toString();
+			mMainView.insertText(insertText);
+			LogD("insertText(" + insertText + ")");
+		}
+		else {
+			for (; nModified < 0; ++nModified) {
+				mMainView.deleteBackward();
+				LogD("deleteBackward");
+			}
+		}
+		mText = s.toString();
+	}
+
+	@Override
+	public void beforeTextChanged(CharSequence s, int start, int count,
+			int after) {
+		LogD("beforeTextChanged(" + s + ")start: " + start + ",count: " + count + ",after: " + after);
+		mText = s.toString();
+	}
+
+	@Override
+	public void onTextChanged(CharSequence s, int start, int before, int count) {
+	}
+
+	@Override
+	public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
+		if (mMainView.getTextField() == v && isFullScreenEdit()) {
+			// user press the action button, delete all old text and insert new text
+			for (int i = mOriginText.length(); i > 0; --i) {
+				mMainView.deleteBackward();
+				LogD("deleteBackward");
+			}
+			String text = v.getText().toString();
+			if ('\n' != text.charAt(text.length() - 1)) {
+				text += '\n';
+			}
+			final String insertText = text;
+			mMainView.insertText(insertText);
+			LogD("insertText(" + insertText + ")");
+		}
+		return false;
+	}
+}
+
+public class Cocos2dxGLSurfaceView extends GLSurfaceView {
+    
+    static private Cocos2dxGLSurfaceView mainView;
+
+    private static final String TAG = Cocos2dxGLSurfaceView.class.getCanonicalName();
+    private Cocos2dxRenderer mRenderer;
+    
+    private static final boolean debug = false;
+	
+    ///////////////////////////////////////////////////////////////////////////
+    // for initialize
+	///////////////////////////////////////////////////////////////////////////
+    public Cocos2dxGLSurfaceView(Context context) {
+        super(context);
+        initView();
+    }
+
+    public Cocos2dxGLSurfaceView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        initView();
+    }
+
+    protected void initView() {
+        mRenderer = new Cocos2dxRenderer();
+        setFocusableInTouchMode(true);
+        setRenderer(mRenderer);
+        
+        textInputWraper = new TextInputWraper(this);
+
+        handler = new Handler(){
+        	public void handleMessage(Message msg){
+        		switch(msg.what){
+        		case HANDLER_OPEN_IME_KEYBOARD:
+        			if (null != mTextField && mTextField.requestFocus()) {
+        				mTextField.removeTextChangedListener(textInputWraper);
+        				mTextField.setText("");
+        				String text = (String)msg.obj;
+        				mTextField.append(text);
+        				textInputWraper.setOriginText(text);
+        				mTextField.addTextChangedListener(textInputWraper);
+                        InputMethodManager imm = (InputMethodManager)mainView.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
+                        imm.showSoftInput(mTextField, 0);
+                        Log.d("GLSurfaceView", "showSoftInput");
+        			}
+        			break;
+        			
+        		case HANDLER_CLOSE_IME_KEYBOARD:
+        			if (null != mTextField) {
+        				mTextField.removeTextChangedListener(textInputWraper);
+                        InputMethodManager imm = (InputMethodManager)mainView.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
+                        imm.hideSoftInputFromWindow(mTextField.getWindowToken(), 0);
+                        Log.d("GLSurfaceView", "HideSoftInput");
+        			}
+        			break;
+        		}
+        	}
+        };
+
+        mainView = this;
+    }
+    
+    public void onPause(){    	
+    	queueEvent(new Runnable() {
+            @Override
+            public void run() {
+                mRenderer.handleOnPause();
+            }
+        });
+    	
+    	super.onPause();
+    }
+    
+    public void onResume(){
+    	super.onResume();
+    	
+    	queueEvent(new Runnable() {
+            @Override
+            public void run() {
+                mRenderer.handleOnResume();
+            }
+        });
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // for text input
+	///////////////////////////////////////////////////////////////////////////
+    private final static int HANDLER_OPEN_IME_KEYBOARD = 2;
+    private final static int HANDLER_CLOSE_IME_KEYBOARD = 3;
+    private static Handler handler;
+    private static TextInputWraper textInputWraper;
+    private TextView mTextField;
+    
+    public TextView getTextField() {
+    	return mTextField;
+    }
+    
+    public void setTextField(TextView view) {
+    	mTextField = view;
+    	if (null != mTextField && null != textInputWraper) {
+    		LinearLayout.LayoutParams linearParams = (LinearLayout.LayoutParams) mTextField.getLayoutParams();
+    		linearParams.height = 0;
+    		mTextField.setLayoutParams(linearParams);
+    		mTextField.setOnEditorActionListener(textInputWraper);
+    	}
+    }
+    
+    public static void openIMEKeyboard() {
+    	Message msg = new Message();
+    	msg.what = HANDLER_OPEN_IME_KEYBOARD;
+    	msg.obj = mainView.getContentText();
+    	handler.sendMessage(msg);
+    	
+    }
+    
+    private String getContentText() {
+		return mRenderer.getContentText();
+	}
+
+	public static void closeIMEKeyboard() {
+    	Message msg = new Message();
+    	msg.what = HANDLER_CLOSE_IME_KEYBOARD;
+    	handler.sendMessage(msg);
+    }
+    
+    public void insertText(final String text) {
+        queueEvent(new Runnable() {
+            @Override
+            public void run() {
+                mRenderer.handleInsertText(text);
+            }
+        });
+    }
+    
+    public void deleteBackward() {
+        queueEvent(new Runnable() {
+            @Override
+            public void run() {
+                mRenderer.handleDeleteBackward();
+            }
+        });
+    }
+
+	///////////////////////////////////////////////////////////////////////////
+    // for touch event
+    ///////////////////////////////////////////////////////////////////////////
+
+    public boolean onTouchEvent(final MotionEvent event) {
+    	// these data are used in ACTION_MOVE and ACTION_CANCEL
+    	final int pointerNumber = event.getPointerCount();
+    	final int[] ids = new int[pointerNumber];
+    	final float[] xs = new float[pointerNumber];
+    	final float[] ys = new float[pointerNumber];
+
+    	for (int i = 0; i < pointerNumber; i++) {
+            ids[i] = event.getPointerId(i);
+            xs[i] = event.getX(i);
+            ys[i] = event.getY(i);
+        }
+        
+        switch (event.getAction() & MotionEvent.ACTION_MASK) {
+        case MotionEvent.ACTION_POINTER_DOWN:
+        	final int idPointerDown = event.getAction() >> MotionEvent.ACTION_POINTER_ID_SHIFT;
+            final float xPointerDown = event.getX(idPointerDown);
+            final float yPointerDown = event.getY(idPointerDown);
+
+            queueEvent(new Runnable() {
+                @Override
+                public void run() {
+                    mRenderer.handleActionDown(idPointerDown, xPointerDown, yPointerDown);
+                }
+            });
+            break;
+            
+        case MotionEvent.ACTION_DOWN:
+        	// there are only one finger on the screen
+        	final int idDown = event.getPointerId(0);
+            final float xDown = event.getX(idDown);
+            final float yDown = event.getY(idDown);
+            
+            queueEvent(new Runnable() {
+                @Override
+                public void run() {
+                    mRenderer.handleActionDown(idDown, xDown, yDown);
+                }
+            });
+            break;
+
+        case MotionEvent.ACTION_MOVE:
+            queueEvent(new Runnable() {
+                @Override
+                public void run() {
+                    mRenderer.handleActionMove(ids, xs, ys);
+                }
+            });
+            break;
+
+        case MotionEvent.ACTION_POINTER_UP:
+        	final int idPointerUp = event.getAction() >> MotionEvent.ACTION_POINTER_ID_SHIFT;
+            final float xPointerUp = event.getX(idPointerUp);
+            final float yPointerUp = event.getY(idPointerUp);
+            
+            queueEvent(new Runnable() {
+                @Override
+                public void run() {
+                    mRenderer.handleActionUp(idPointerUp, xPointerUp, yPointerUp);
+                }
+            });
+            break;
+            
+        case MotionEvent.ACTION_UP:  
+        	// there are only one finger on the screen
+        	final int idUp = event.getPointerId(0);
+            final float xUp = event.getX(idUp);
+            final float yUp = event.getY(idUp);
+            
+            queueEvent(new Runnable() {
+                @Override
+                public void run() {
+                    mRenderer.handleActionUp(idUp, xUp, yUp);
+                }
+            });
+            break;
+
+        case MotionEvent.ACTION_CANCEL:
+            queueEvent(new Runnable() {
+               @Override
+                public void run() {
+                    mRenderer.handleActionCancel(ids, xs, ys);
+                }
+            });
+            break;
+        }
+      
+        if (debug){
+        	dumpEvent(event);
+        }
+        return true;
+    }
+    
+ @Override
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+    	final int kc = keyCode;
+    	if (keyCode == KeyEvent.KEYCODE_BACK || keyCode == KeyEvent.KEYCODE_MENU) {
+    		queueEvent(new Runnable() {
+	            @Override
+	            public void run() {
+	                mRenderer.handleKeyDown(kc);
+	            }
+    		});
+    		return true;
+    	}
+        return super.onKeyDown(keyCode, event);
+    }
+    // Show an event in the LogCat view, for debugging
+    private void dumpEvent(MotionEvent event) {
+       String names[] = { "DOWN" , "UP" , "MOVE" , "CANCEL" , "OUTSIDE" ,
+          "POINTER_DOWN" , "POINTER_UP" , "7?" , "8?" , "9?" };
+       StringBuilder sb = new StringBuilder();
+       int action = event.getAction();
+       int actionCode = action & MotionEvent.ACTION_MASK;
+       sb.append("event ACTION_" ).append(names[actionCode]);
+       if (actionCode == MotionEvent.ACTION_POINTER_DOWN
+             || actionCode == MotionEvent.ACTION_POINTER_UP) {
+          sb.append("(pid " ).append(
+          action >> MotionEvent.ACTION_POINTER_ID_SHIFT);
+          sb.append(")" );
+       }
+       sb.append("[" );
+       for (int i = 0; i < event.getPointerCount(); i++) {
+          sb.append("#" ).append(i);
+          sb.append("(pid " ).append(event.getPointerId(i));
+          sb.append(")=" ).append((int) event.getX(i));
+          sb.append("," ).append((int) event.getY(i));
+          if (i + 1 < event.getPointerCount())
+             sb.append(";" );
+       }
+       sb.append("]" );
+       Log.d(TAG, sb.toString());
+    }
+}

HelloLua/android/src/org/cocos2dx/lib/Cocos2dxMusic.java

@@ -0,0 +1,177 @@
+package org.cocos2dx.lib;
+
+import android.content.Context;
+import android.content.res.AssetFileDescriptor;
+import android.media.MediaPlayer;
+import android.util.Log;
+
+/**
+ * 
+ * This class is used for controlling background music
+ *
+ */
+public class Cocos2dxMusic {
+	
+	private static final String TAG = "Cocos2dxMusic";
+	private float mLeftVolume;
+	private float mRightVolume;
+	private Context mContext;
+	private MediaPlayer mBackgroundMediaPlayer;
+	private boolean mIsPaused;
+	private String mCurrentPath;
+	
+	public Cocos2dxMusic(Context context){
+		this.mContext = context;
+		initData();
+	}
+	
+	public void playBackgroundMusic(String path, boolean isLoop){
+		if (mCurrentPath == null){
+			// it is the first time to play background music
+			// or end() was called
+			mBackgroundMediaPlayer = createMediaplayerFromAssets(path);	
+			mCurrentPath = path;
+		} 
+		else {
+			if (! mCurrentPath.equals(path)){
+				// play new background music
+				
+				// release old resource and create a new one
+				if (mBackgroundMediaPlayer != null){
+					mBackgroundMediaPlayer.release();				
+				}				
+				mBackgroundMediaPlayer = createMediaplayerFromAssets(path);
+				
+				// record the path
+				mCurrentPath = path;
+			}
+		}
+		
+		if (mBackgroundMediaPlayer == null){
+			Log.e(TAG, "playBackgroundMusic: background media player is null");
+		} else {		
+			// if the music is playing or paused, stop it
+			mBackgroundMediaPlayer.stop();			
+			
+			mBackgroundMediaPlayer.setLooping(isLoop);
+			
+			try {
+				mBackgroundMediaPlayer.prepare();
+				mBackgroundMediaPlayer.seekTo(0);
+				mBackgroundMediaPlayer.start();
+				
+				this.mIsPaused = false;
+			} catch (Exception e){
+				Log.e(TAG, "playBackgroundMusic: error state");
+			}			
+		}
+	}
+	
+	public void stopBackgroundMusic(){
+		if (mBackgroundMediaPlayer != null){
+			mBackgroundMediaPlayer.stop();
+			
+			// should set the state, if not , the following sequence will be error
+			// play -> pause -> stop -> resume
+			this.mIsPaused = false;
+		}
+	}
+	
+	public void pauseBackgroundMusic(){		
+		if (mBackgroundMediaPlayer != null && mBackgroundMediaPlayer.isPlaying()){
+			mBackgroundMediaPlayer.pause();
+			this.mIsPaused = true;
+		}
+	}
+	
+	public void resumeBackgroundMusic(){
+		if (mBackgroundMediaPlayer != null && this.mIsPaused){
+			mBackgroundMediaPlayer.start();
+			this.mIsPaused = false;
+		}
+	}
+	
+	public void rewindBackgroundMusic(){		
+		if (mBackgroundMediaPlayer != null){
+			mBackgroundMediaPlayer.stop();			
+			
+			try {
+				mBackgroundMediaPlayer.prepare();
+				mBackgroundMediaPlayer.seekTo(0);
+				mBackgroundMediaPlayer.start();
+				
+				this.mIsPaused = false;
+			} catch (Exception e){
+				Log.e(TAG, "rewindBackgroundMusic: error state");
+			}			
+		}
+	}
+	
+	public boolean isBackgroundMusicPlaying(){
+		boolean ret = false;
+		
+		if (mBackgroundMediaPlayer == null){
+			ret = false;
+		} else {
+			ret = mBackgroundMediaPlayer.isPlaying();
+		}
+		
+		return ret;
+	}
+	
+	public void end(){
+		if (mBackgroundMediaPlayer != null){
+			mBackgroundMediaPlayer.release();
+		}
+
+		initData();
+	}
+	
+	public float getBackgroundVolume(){
+		if (this.mBackgroundMediaPlayer != null){
+			return (this.mLeftVolume + this.mRightVolume) / 2;
+		} else {
+			return 0.0f;
+		}
+	}
+	
+	public void setBackgroundVolume(float volume){
+		if (this.mBackgroundMediaPlayer != null){
+			this.mLeftVolume = this.mRightVolume = volume;
+			this.mBackgroundMediaPlayer.setVolume(this.mLeftVolume, this.mRightVolume);
+		}
+	}
+	
+	private void initData(){
+		mLeftVolume =0.5f;
+		mRightVolume = 0.5f;
+		mBackgroundMediaPlayer = null;
+		mIsPaused = false;
+		mCurrentPath = null;
+	}
+	
+	/**
+	 * create mediaplayer for music
+	 * @param path the path relative to assets
+	 * @return 
+	 */
+	private MediaPlayer createMediaplayerFromAssets(String path){
+		MediaPlayer mediaPlayer = null;
+		
+		try{			
+			AssetFileDescriptor assetFileDescritor = mContext.getAssets().openFd(path);
+			
+			mediaPlayer = new MediaPlayer();
+	        mediaPlayer.setDataSource(assetFileDescritor.getFileDescriptor(), 
+	        		assetFileDescritor.getStartOffset(), assetFileDescritor.getLength());
+	        mediaPlayer.prepare();
+	        
+	        mediaPlayer.setVolume(mLeftVolume, mRightVolume);
+		}catch (Exception e) {
+			mediaPlayer = null;
+            Log.e(TAG, "error: " + e.getMessage(), e);
+        }
+		
+        return mediaPlayer;
+	}
+}

HelloLua/android/src/org/cocos2dx/lib/Cocos2dxRenderer.java

@@ -0,0 +1,107 @@
+package org.cocos2dx.lib;
+
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.opengles.GL10;
+
+import android.opengl.GLSurfaceView;
+
+public class Cocos2dxRenderer implements GLSurfaceView.Renderer {
+	private final static long NANOSECONDSPERSECOND = 1000000000L;
+	private final static long NANOSECONDSPERMINISECOND = 1000000;
+	private static long animationInterval = (long)(1.0 / 60 * NANOSECONDSPERSECOND);
+	private long last;
+	
+    public void onSurfaceCreated(GL10 gl, EGLConfig config) { 	
+    	nativeInit(Cocos2dxActivity.screenWidth, Cocos2dxActivity.screenHeight); 
+    	last = System.nanoTime();
+    }
+
+    public void onSurfaceChanged(GL10 gl, int w, int h) {  	
+    }
+    
+    public void onDrawFrame(GL10 gl) {
+    	
+    	long now = System.nanoTime();
+    	long interval = now - last;
+    	
+    	// should render a frame when onDrawFrame() is called
+    	// or there is a "ghost"
+    	nativeRender();   	
+   	
+    	// fps controlling
+    	if (interval < animationInterval){ 
+    		try {
+    			// because we render it before, so we should sleep twice time interval
+    			Thread.sleep((animationInterval - interval) * 2 / NANOSECONDSPERMINISECOND);
+    		} catch (Exception e){}
+    	}	
+    	
+    	last = now;
+    }
+    
+    public void handleActionDown(int id, float x, float y)
+    {
+    	nativeTouchesBegin(id, x, y);
+    }
+    
+    public void handleActionUp(int id, float x, float y)
+    {
+    	nativeTouchesEnd(id, x, y);
+    }
+    
+    public void handleActionCancel(int[] id, float[] x, float[] y)
+    {
+    	nativeTouchesCancel(id, x, y);
+    }
+    
+    public void handleActionMove(int[] id, float[] x, float[] y)
+    {
+    	nativeTouchesMove(id, x, y);
+    }
+    
+    public void handleKeyDown(int keyCode)
+    {
+    	nativeKeyDown(keyCode);
+    }
+    
+    public void handleOnPause(){
+    	nativeOnPause();
+    }
+    
+    public void handleOnResume(){
+    	nativeOnResume();
+    }
+    
+    public static void setAnimationInterval(double interval){
+    	animationInterval = (long)(interval * NANOSECONDSPERSECOND);
+    }
+    private static native void nativeTouchesBegin(int id, float x, float y);
+    private static native void nativeTouchesEnd(int id, float x, float y);
+    private static native void nativeTouchesMove(int[] id, float[] x, float[] y);
+    private static native void nativeTouchesCancel(int[] id, float[] x, float[] y);
+    private static native boolean nativeKeyDown(int keyCode);
+    private static native void nativeRender();
+    private static native void nativeInit(int w, int h);
+    private static native void nativeOnPause();
+    private static native void nativeOnResume();
+    
+    /////////////////////////////////////////////////////////////////////////////////
+    // handle input method edit message
+    /////////////////////////////////////////////////////////////////////////////////
+    
+    public void handleInsertText(final String text) {
+    	nativeInsertText(text);
+    }
+    
+    public void handleDeleteBackward() {
+    	nativeDeleteBackward();
+    }
+
+	public String getContentText() {
+		return nativeGetContentText();
+	}
+	
+    private static native void nativeInsertText(String text);
+    private static native void nativeDeleteBackward();
+    private static native String nativeGetContentText();
+}

HelloLua/android/src/org/cocos2dx/lib/Cocos2dxSound.java

@@ -0,0 +1,148 @@
+package org.cocos2dx.lib;
+
+import java.util.HashMap;
+
+import android.content.Context;
+import android.media.AudioManager;
+import android.media.SoundPool;
+import android.util.Log;
+
+/**
+ * 
+ * This class is used for controlling effect
+ *
+ */
+
+public class Cocos2dxSound {
+	private Context mContext;
+	private SoundPool mSoundPool;
+	private float mLeftVolume;
+	private float mRightVolume;
+	
+	// sound id and stream id map
+	private HashMap<Integer,Integer> mSoundIdStreamIdMap;
+	// sound path and sound id map
+	private HashMap<String,Integer> mPathSoundIDMap;	
+	
+	private static final String TAG = "Cocos2dxSound";
+	private static final int MAX_SIMULTANEOUS_STREAMS_DEFAULT = 5;
+	private static final float SOUND_RATE = 1.0f;
+	private static final int SOUND_PRIORITY = 1;
+	private static final int SOUND_LOOP_TIME = 0;
+	private static final int SOUND_QUALITY = 5;
+	
+	private final int INVALID_SOUND_ID = -1;
+	private final int INVALID_STREAM_ID = -1;
+	
+	public Cocos2dxSound(Context context){
+		this.mContext = context;	
+		initData();
+	}
+	
+	public int preloadEffect(String path){
+		int soundId = INVALID_SOUND_ID;
+		
+		// if the sound is preloaded, pass it
+		if (this.mPathSoundIDMap.get(path) != null){
+			soundId =  this.mPathSoundIDMap.get(path).intValue();
+		} else {
+			soundId = createSoundIdFromAsset(path);
+			
+			if (soundId != INVALID_SOUND_ID){
+				// the sound is loaded but has not been played
+				this.mSoundIdStreamIdMap.put(soundId, INVALID_STREAM_ID);
+				
+				// record path and sound id map
+				this.mPathSoundIDMap.put(path, soundId);
+			}
+		}
+		
+		
+		
+		return soundId;
+	}
+	
+	public void unloadEffect(String path){
+		// get sound id and remove from mPathSoundIDMap
+		Integer soundId = this.mPathSoundIDMap.remove(path);
+		
+		if (soundId != null){
+			// unload effect
+			this.mSoundPool.unload(soundId.intValue());
+			
+			// remove record from mSoundIdStreamIdMap
+			this.mSoundIdStreamIdMap.remove(soundId);
+		}
+	}
+	
+	public int playEffect(String path){
+		Integer soundId = this.mPathSoundIDMap.get(path);
+		
+		if (soundId != null){
+			// the sound is preloaded
+			
+			// play sound
+			int streamId = this.mSoundPool.play(soundId.intValue(), this.mLeftVolume, 
+					this.mRightVolume, SOUND_PRIORITY, SOUND_LOOP_TIME, SOUND_RATE);
+			
+			// record sound id and stream id map
+			this.mSoundIdStreamIdMap.put(soundId, streamId);
+		} else {
+			// the effect is not prepared
+			soundId = preloadEffect(path);	
+			if (soundId == INVALID_SOUND_ID){
+				// can not preload effect
+				return INVALID_SOUND_ID;
+			}
+			
+			playEffect(path);
+		}
+		
+		return soundId.intValue();
+	}
+	
+	public void stopEffect(int soundId){
+        Integer streamId = this.mSoundIdStreamIdMap.get(soundId);
+        
+        if (streamId != null && streamId.intValue() != INVALID_STREAM_ID){
+        	this.mSoundPool.stop(streamId.intValue());
+        }
+	}
+	
+	public float getEffectsVolume(){
+		return (this.mLeftVolume + this.mRightVolume) / 2;
+	}
+	
+	public void setEffectsVolume(float volume){
+		this.mLeftVolume = this.mRightVolume = volume;
+	}
+	
+	public void end(){		
+		this.mSoundPool.release();	
+		this.mPathSoundIDMap.clear();	
+		this.mSoundIdStreamIdMap.clear();
+		
+		initData();
+	}
+	
+	public int createSoundIdFromAsset(String path){
+		int soundId = INVALID_SOUND_ID;
+		
+		try {
+			soundId = mSoundPool.load(mContext.getAssets().openFd(path), 0);
+		} catch(Exception e){
+			 Log.e(TAG, "error: " + e.getMessage(), e);
+		}
+		
+		return soundId;
+	}
+	
+	private void initData(){
+		this.mSoundIdStreamIdMap = new HashMap<Integer,Integer>();
+		mSoundPool = new SoundPool(MAX_SIMULTANEOUS_STREAMS_DEFAULT, AudioManager.STREAM_MUSIC, SOUND_QUALITY);
+		mPathSoundIDMap = new HashMap<String,Integer>();
+		
+		this.mLeftVolume = 0.5f;
+		this.mRightVolume = 0.5f;
+	}
+}

HelloLua/ios/HelloLua.xcodeproj/project.pbxproj.REMOVED.git-id

@@ -0,0 +1 @@
+fa7dfcb01ab5dedab7cf38ce21a1c0b5ea7ceda5

HelloLua/ios/HelloLuaAppController.h

@@ -0,0 +1,14 @@
+//
+//  HelloLuaAppController.h
+//  HelloLua
+//
+//  Created by Walzer on 11-6-15.
+//  Copyright __MyCompanyName__ 2011. All rights reserved.
+//
+
+@interface HelloLuaAppController : NSObject <UIAccelerometerDelegate, UIAlertViewDelegate, UITextFieldDelegate,UIApplicationDelegate> {
+    UIWindow *window;
+}
+
+@end
+

HelloLua/ios/HelloLuaAppController.mm

@@ -0,0 +1,97 @@
+//
+//  HelloLuaAppController.mm
+//  HelloLua
+//
+//  Created by Walzer on 11-6-15.
+//  Copyright __MyCompanyName__ 2011. All rights reserved.
+//
+#import <UIKit/UIKit.h>
+#import "HelloLuaAppController.h"
+#import "cocos2d.h"
+#import "EAGLView.h"
+#import "AppDelegate.h"
+
+@implementation HelloLuaAppController
+
+#pragma mark -
+#pragma mark Application lifecycle
+
+// cocos2d application instance
+static AppDelegate s_sharedApplication;
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {    
+    
+    // Override point for customization after application launch.
+
+    // Add the view controller's view to the window and display.
+    window = [[UIWindow alloc] initWithFrame: [[UIScreen mainScreen] bounds]];
+    EAGLView *__glView = [EAGLView viewWithFrame: [window bounds]
+                                     pixelFormat: kEAGLColorFormatRGBA8
+                                     depthFormat: GL_DEPTH_COMPONENT16_OES
+                              preserveBackbuffer: NO
+                                      sharegroup: nil
+                                   multiSampling: NO
+                                 numberOfSamples: 0 ];
+    [window addSubview: __glView];
+    [window makeKeyAndVisible];
+
+    [[UIApplication sharedApplication] setStatusBarHidden: YES];
+    
+    cocos2d::CCApplication::sharedApplication().run();
+    return YES;
+}
+
+- (void)applicationWillResignActive:(UIApplication *)application {
+    /*
+     Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
+     Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game.
+     */
+	cocos2d::CCDirector::sharedDirector()->pause();
+}
+
+- (void)applicationDidBecomeActive:(UIApplication *)application {
+    /*
+     Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
+     */
+	cocos2d::CCDirector::sharedDirector()->resume();
+}
+
+- (void)applicationDidEnterBackground:(UIApplication *)application {
+    /*
+     Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later. 
+     If your application supports background execution, called instead of applicationWillTerminate: when the user quits.
+     */
+	cocos2d::CCDirector::sharedDirector()->stopAnimation();
+}
+
+- (void)applicationWillEnterForeground:(UIApplication *)application {
+    /*
+     Called as part of  transition from the background to the inactive state: here you can undo many of the changes made on entering the background.
+     */
+	cocos2d::CCDirector::sharedDirector()->startAnimation();
+}
+
+- (void)applicationWillTerminate:(UIApplication *)application {
+    /*
+     Called when the application is about to terminate.
+     See also applicationDidEnterBackground:.
+     */
+}
+
+
+#pragma mark -
+#pragma mark Memory management
+
+- (void)applicationDidReceiveMemoryWarning:(UIApplication *)application {
+    /*
+     Free up as much memory as possible by purging cached data objects that can be recreated (or reloaded from disk) later.
+     */
+}
+
+
+- (void)dealloc {
+    [super dealloc];
+}
+
+
+@end

HelloLua/ios/HelloLua_Prefix.pch

@@ -0,0 +1,8 @@
+//
+// Prefix header for all source files of the 'HelloLua' target in the 'HelloLua' project
+//
+
+#ifdef __OBJC__
+	#import <Foundation/Foundation.h>
+	#import <UIKit/UIKit.h>
+#endif

HelloLua/ios/main.m

@@ -0,0 +1,16 @@
+//
+//  main.m
+//  HelloLua
+//
+//  Created by Walzer on 11-6-15.
+//  Copyright __MyCompanyName__ 2011. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+int main(int argc, char *argv[]) {
+	NSAutoreleasePool *pool = [NSAutoreleasePool new];
+	int retVal = UIApplicationMain(argc, argv, nil, @"HelloLuaAppController");
+	[pool release];
+	return retVal;
+}

HelloLua/win32/HelloLua.win32.vcproj

@@ -0,0 +1,220 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="HelloLua"
+	ProjectGUID="{13E55395-94A2-4CD9-BFC2-1A051F80C17D}"
+	RootNamespace="HelloLua.win32"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName).win32"
+			IntermediateDirectory="$(ConfigurationName).win32"
+			ConfigurationType="1"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="_DEBUG"
+				MkTypLibCompatible="false"
+				TargetEnvironment="1"
+				GenerateStublessProxies="true"
+				TypeLibraryName="$(IntDir)/HelloLua.tlb"
+				HeaderFileName="HelloLua.h"
+				DLLDataFileName=""
+				InterfaceIdentifierFileName="HelloLua_i.c"
+				ProxyFileName="HelloLua_p.c"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\Classes;.;&quot;$(SolutionDir)\lua\tolua&quot;;&quot;$(SolutionDir)\lua\src&quot;;&quot;$(SolutionDir)\cocos2dx&quot;;&quot;$(SolutionDir)\cocos2dx\include&quot;;&quot;$(SolutionDir)\cocos2dx\platform&quot;;&quot;$(SolutionDir)\cocos2dx\platform\third_party\win32\OGLES&quot;;&quot;$(SolutionDir)\CocosDenshion\Include&quot;"
+				PreprocessorDefinitions="WIN32;_WINDOWS;STRICT;_DEBUG;COCOS2D_DEBUG=1;ENABLE_LUA"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="4"
+				DisableSpecificWarnings="4251"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+				Culture="1033"
+				AdditionalIncludeDirectories="$(IntDir)"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="libcocos2d.lib libgles_cm.lib"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories="$(OutDir)"
+				GenerateDebugInformation="true"
+				SubSystem="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName).win32"
+			IntermediateDirectory="$(ConfigurationName).win32"
+			ConfigurationType="1"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="NDEBUG"
+				MkTypLibCompatible="false"
+				TargetEnvironment="1"
+				GenerateStublessProxies="true"
+				TypeLibraryName="$(IntDir)/HelloLua.tlb"
+				HeaderFileName="HelloLua.h"
+				DLLDataFileName=""
+				InterfaceIdentifierFileName="HelloLua_i.c"
+				ProxyFileName="HelloLua_p.c"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories=".;.\win32;.\Classes;..\cocos2dx;..\cocos2dx\include;..\cocos2dx\platform;..\cocos2dx\platform\third_party\win32\OGLES;..\CocosDenshion\Include"
+				PreprocessorDefinitions="WIN32;_WINDOWS;STRICT;NDEBUG"
+				ExceptionHandling="0"
+				RuntimeLibrary="2"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="0"
+				DisableSpecificWarnings="4251"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+				Culture="1033"
+				AdditionalIncludeDirectories="$(IntDir)"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="libcocos2d.lib libgles_cm.lib libCocosDenshion.lib"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories="$(OutDir)"
+				SubSystem="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Classes"
+			>
+			<File
+				RelativePath="..\Classes\AppDelegate.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\Classes\AppDelegate.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="win32"
+			>
+			<File
+				RelativePath=".\main.cpp"
+				>
+			</File>
+			<File
+				RelativePath=".\main.h"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

HelloLua/win32/HelloLua.win32.vcproj.user

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<VisualStudioUserFile
+	ProjectType="Visual C++"
+	Version="9.00"
+	ShowAllFiles="false"
+	>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			>
+			<DebugSettings
+				WorkingDirectory="$(ProjectDir)Resource\"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			>
+			<DebugSettings
+				WorkingDirectory="$(ProjectDir)Resource\"
+			/>
+		</Configuration>
+    </Configurations>
+</VisualStudioUserFile>

HelloLua/win32/main.cpp

@@ -0,0 +1,17 @@
+#include "main.h"
+
+#include "AppDelegate.h"
+
+int APIENTRY _tWinMain(HINSTANCE hInstance,
+					   HINSTANCE hPrevInstance,
+					   LPTSTR    lpCmdLine,
+					   int       nCmdShow)
+{
+	UNREFERENCED_PARAMETER(hPrevInstance);
+	UNREFERENCED_PARAMETER(lpCmdLine);
+
+    // create the application instance
+	AppDelegate app;
+
+    return cocos2d::CCApplication::sharedApplication().run();
+}

HelloLua/win32/main.h

@@ -0,0 +1,13 @@
+#ifndef __MAIN_H__
+#define __MAIN_H__
+
+#define WIN32_LEAN_AND_MEAN             // Exclude rarely-used stuff from Windows headers
+
+// Windows Header Files:
+#include <windows.h>
+#include <tchar.h>
+
+// C RunTime Header Files
+#include "CCStdC.h"
+
+#endif	// __MAIN_H__

HelloWorld/android/jni/Android.mk

@@ -3,7 +3,7 @@ include $(CLEAR_VARS)
 
 subdirs := $(addprefix $(LOCAL_PATH)/../../../,$(addsuffix /Android.mk, \
            cocos2dx \
-           CocosDenshion/android \
+           CocosDenshion/android
 	))
 subdirs += $(LOCAL_PATH)/helloworld/Android.mk
 

HelloWorld/android/jni/Application.mk

@@ -1,4 +1,4 @@
 # it is needed for ndk-r5
 APP_STL := stlport_static
 
-APP_MODULES := cocos2d cocosdenshion helloworld
+APP_MODULES := helloworld

HelloWorld/android/jni/helloworld/Android.mk

@@ -9,20 +9,30 @@ LOCAL_SRC_FILES := main.cpp \
 LOCAL_C_INCLUDES := $(LOCAL_PATH)/../../../../cocos2dx \
                     $(LOCAL_PATH)/../../../../cocos2dx/platform \
                     $(LOCAL_PATH)/../../../../cocos2dx/include \
+                    $(LOCAL_PATH)/../../../../cocos2dx/lua_support \
                     $(LOCAL_PATH)/../../../../CocosDenshion/include \
-                    $(LOCAL_PATH)/../../.. 
+                    $(LOCAL_PATH)/../../..
 
 # it is used for ndk-r4
 # if you build with nkd-r4, uncomment it                    
-# LOCAL_LDLIBS := -L$(LOCAL_PATH)/../../libs/armeabi -lcocos2d -llog -lcocosdenshion \
-#                -L$(LOCAL_PATH)/../../../../cocos2dx/platform/third_party/android/libraries -lcurl
+# LOCAL_LDLIBS := -llog -lGLESv1_CM -llog -lz \
+#                -L$(LOCAL_PATH)/../../../../cocos2dx/platform/third_party/android/libraries -lcurl \
+#                -lpng \
+#                -lxml2 \
+#                -ljpeg \
+#                -lskia
 
 # it is used for ndk-r5  
 # if you build with ndk-r4, comment it  
 # because the new Windows toolchain doesn't support Cygwin's drive
 # mapping (i.e /cygdrive/c/ instead of C:/)  
-LOCAL_LDLIBS := -L$(call host-path, $(LOCAL_PATH)/../../libs/armeabi) \
-                -lcocos2d -llog -lcocosdenshion \
-                -L$(call host-path, $(LOCAL_PATH)/../../../../cocos2dx/platform/third_party/android/libraries) -lcurl
+LOCAL_LDLIBS := -llog -lGLESv1_CM -llog -lz \
+                -L$(call host-path, $(LOCAL_PATH)/../../../../cocos2dx/platform/third_party/android/libraries) -lcurl \
+                -lpng \
+                -lxml2 \
+                -ljpeg \
+                -lskia
+                
+LOCAL_STATIC_LIBRARIES := libcocos2d libcocosdenshion
             
 include $(BUILD_SHARED_LIBRARY)

HelloWorld/android/src/org/cocos2dx/application/ApplicationDemo.java

@@ -44,8 +44,6 @@ public class ApplicationDemo extends Cocos2dxActivity{
 	 private GLSurfaceView mGLView;
 	
      static {
-    	 System.loadLibrary("cocos2d");
-    	 System.loadLibrary("cocosdenshion");
          System.loadLibrary("helloworld");
      }
 }

HelloWorld/ios/HelloWorld.xcodeproj/project.pbxproj.REMOVED.git-id

@@ -1 +1 @@
-631e30d698eec53284c6bd9facd0f3e44eb4f18c
+622833576c05896c841e7beaab322d4def50e54b

HelloWorld/win32/HelloWorld.win32.vcproj

@@ -41,8 +41,8 @@
 			<Tool
 				Name="VCCLCompilerTool"
 				Optimization="0"
-				AdditionalIncludeDirectories="&quot;$(SolutionDir)cocos2dx\platform&quot;;&quot;$(SolutionDir)cocos2dx\include&quot;;&quot;$(SolutionDir)cocos2dx&quot;;&quot;$(SolutionDir)cocos2dx\platform\third_party\win32\OGLES&quot;;..\;.\"
-				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS"
+				AdditionalIncludeDirectories="&quot;$(SolutionDir)cocos2dx\platform&quot;;&quot;$(SolutionDir)cocos2dx\include&quot;;&quot;$(SolutionDir)lua\tolua&quot;;&quot;$(SolutionDir)lua\src&quot;;&quot;$(SolutionDir)cocos2dx&quot;;&quot;$(SolutionDir)cocos2dx\platform\third_party\win32\OGLES&quot;;..\;.\"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;ENABLE_LUA"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
 				RuntimeLibrary="3"

chipmunk/Android.mk

@@ -35,4 +35,4 @@ src/cpVect.c
 LOCAL_C_INCLUDES := $(LOCAL_PATH)/include/chipmunk
 LOCAL_CFLAGS := -std=c99
                                  
-include $(BUILD_SHARED_LIBRARY)
+include $(BUILD_STATIC_LIBRARY)

cocos2d-win32.vc2008.sln

@@ -8,6 +8,9 @@ EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libCocosDenshion", "CocosDenshion\proj.win32\CocosDenshion.win32.vcproj", "{F8EDD7FA-9A51-4E80-BAEB-860825D2EAC6}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libcocos2d", "cocos2dx\proj.win32\cocos2d-win32.vcproj", "{98A51BA8-FC3A-415B-AC8F-8C7BD464E93E}"
+	ProjectSection(ProjectDependencies) = postProject
+		{A9376AC9-4D65-498F-885D-EEC3B41DD6E8} = {A9376AC9-4D65-498F-885D-EEC3B41DD6E8}
+	EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "HelloWorld", "HelloWorld\win32\HelloWorld.win32.vcproj", "{B8BF9E81-35FD-4582-BA1C-B85FA365BABB}"
 	ProjectSection(ProjectDependencies) = postProject
@@ -22,6 +25,10 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tests", "tests\test.win32\t
 		{F8EDD7FA-9A51-4E80-BAEB-860825D2EAC6} = {F8EDD7FA-9A51-4E80-BAEB-860825D2EAC6}
 	EndProjectSection
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "liblua", "lua\lua.vcproj", "{A9376AC9-4D65-498F-885D-EEC3B41DD6E8}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "HelloLua", "HelloLua\win32\HelloLua.win32.vcproj", "{13E55395-94A2-4CD9-BFC2-1A051F80C17D}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Win32 = Debug|Win32
@@ -52,6 +59,14 @@ Global
 		{76A39BB2-9B84-4C65-98A5-654D86B86F2A}.Debug|Win32.Build.0 = Debug|Win32
 		{76A39BB2-9B84-4C65-98A5-654D86B86F2A}.Release|Win32.ActiveCfg = Release|Win32
 		{76A39BB2-9B84-4C65-98A5-654D86B86F2A}.Release|Win32.Build.0 = Release|Win32
+		{A9376AC9-4D65-498F-885D-EEC3B41DD6E8}.Debug|Win32.ActiveCfg = Debug|Win32
+		{A9376AC9-4D65-498F-885D-EEC3B41DD6E8}.Debug|Win32.Build.0 = Debug|Win32
+		{A9376AC9-4D65-498F-885D-EEC3B41DD6E8}.Release|Win32.ActiveCfg = Release|Win32
+		{A9376AC9-4D65-498F-885D-EEC3B41DD6E8}.Release|Win32.Build.0 = Release|Win32
+		{13E55395-94A2-4CD9-BFC2-1A051F80C17D}.Debug|Win32.ActiveCfg = Debug|Win32
+		{13E55395-94A2-4CD9-BFC2-1A051F80C17D}.Debug|Win32.Build.0 = Debug|Win32
+		{13E55395-94A2-4CD9-BFC2-1A051F80C17D}.Release|Win32.ActiveCfg = Release|Win32
+		{13E55395-94A2-4CD9-BFC2-1A051F80C17D}.Release|Win32.Build.0 = Release|Win32
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

cocos2dx/Android.mk

@@ -96,7 +96,18 @@ tileMap_parallax_nodes/CCTMXTiledMap.cpp \
 tileMap_parallax_nodes/CCTMXXMLParser.cpp \
 tileMap_parallax_nodes/CCTileMapAtlas.cpp \
 touch_dispatcher/CCTouchDispatcher.cpp \
-touch_dispatcher/CCTouchHandler.cpp
+touch_dispatcher/CCTouchHandler.cpp 
+
+ifeq ($(ENABLE_LUA), true)
+    LOCAL_SRC_FILES += lua_support/CCLuaSrcipt.cpp \
+                       lua_support/LuaCocos2d.cpp
+                       
+    LOCAL_CFLAGS := -DENABLE_LUA -DUSE_FILE32API
+else
+    # define the macro to compile through support/zip_support/ioapi.c                
+    LOCAL_CFLAGS := -DUSE_FILE32API
+endif
+
 
 LOCAL_C_INCLUDES := $(LOCAL_PATH)/ \
                     $(LOCAL_PATH)/include \
@@ -116,29 +127,9 @@ LOCAL_C_INCLUDES := $(LOCAL_PATH)/ \
                     $(LOCAL_PATH)/platform/third_party/android/skia/text \
                     $(LOCAL_PATH)/platform/third_party/android/skia/utils \
                     $(LOCAL_PATH)/platform/third_party/android/skia/views \
-                    $(LOCAL_PATH)/platform/third_party/android/skia/xml
-                    
-# it is used for ndk-r4
-# if you build with nkd-r4, uncomment it   
-# LOCAL_LDLIBS := -L$(LOCAL_PATH)/platform/third_party/android/libraries \
-#                -lGLESv1_CM -llog -lz \
-#                -lpng \
-#                -lxml2 \
-#                -ljpeg \
-#                -lskia
+                    $(LOCAL_PATH)/platform/third_party/android/skia/xml \
+		    $(LOCAL_PATH)/../lua/src \
+		    $(LOCAL_PATH)/../lua/tolua                    
 
-# it is used for ndk-r5  
-# if you build with ndk-r4, comment it   
-# because the new Windows toolchain doesn't support Cygwin's drive
-# mapping (i.e /cygdrive/c/ instead of C:/)  
-LOCAL_LDLIBS := -L$(call host-path, $(LOCAL_PATH)/platform/third_party/android/libraries) \
-                 -lGLESv1_CM -llog -lz \
-                 -lpng \
-                 -lxml2 \
-                 -ljpeg \
-                 -lskia
-
-# define the macro to compile through support/zip_support/ioapi.c                
-LOCAL_CFLAGS := -DUSE_FILE32API  -Wno-unused-value
                                  
-include $(BUILD_SHARED_LIBRARY)
+include $(BUILD_STATIC_LIBRARY)

cocos2dx/CCDirector.cpp

@@ -188,6 +188,12 @@ void CCDirector::drawScene(void)
 	//tick before glClear: issue #533
 	if (! m_bPaused)
 	{
+#ifdef  ENABLE_LUA
+		if (m_luatick.size())
+		{
+			schedule_SCHEDULE(NULL, NULL, m_fDeltaTime, m_luatick);
+		}
+#endif
 		CCScheduler::sharedScheduler()->tick(m_fDeltaTime);
 	}
 
@@ -884,6 +890,20 @@ void CCDirector::setDeviceOrientation(ccDeviceOrientation kDeviceOrientation)
     }
 }
 
+
+#ifdef  ENABLE_LUA
+void CCDirector::registerTick(const char* szfn)
+{
+	if (szfn == NULL || strlen(szfn) == 0)
+	{
+		CCLOG("error registerTick");
+		return ;
+	}
+	m_luatick = szfn;
+}
+#endif
+
+
 /***************************************************
 * implementation of DisplayLinkDirector
 **************************************************/

cocos2dx/CCScheduler.cpp

@@ -85,6 +85,33 @@ CCTimer* CCTimer::timerWithTarget(SelectorProtocol *pTarget, SEL_SCHEDULE pfnSel
 
 	return pTimer;
 }
+#ifdef  ENABLE_LUA
+CCTimer* CCTimer::timerWithScript(SelectorProtocol* pTarget, const char* szFuncName, ccTime fSeconds)
+{
+	CCTimer *pTimer = new CCTimer();
+	pTimer->initWithScript(pTarget, szFuncName, fSeconds);
+	pTimer->autorelease();
+	return pTimer;
+}
+
+bool CCTimer::initWithScript(SelectorProtocol* pTarget,  const char* szFuncName, ccTime fSeconds)
+{
+	m_pTarget= pTarget;
+	m_scriptFunc = szFuncName;
+	m_fElapsed = -1;
+	m_fInterval = fSeconds;
+	m_pfnSelector = NULL;
+	return true;
+}
+bool CCTimer::isScriptFuncExist( const char* szFuncName)
+{
+	if (m_pTarget&& szFuncName)
+	{
+		return strcmp(m_scriptFunc.c_str(), szFuncName)== 0? true: false;
+	}
+	return false;
+}
+#endif
 
 bool CCTimer::initWithTarget(SelectorProtocol *pTarget, SEL_SCHEDULE pfnSelector)
 {
@@ -119,6 +146,13 @@ void CCTimer::update(ccTime dt)
 			(m_pTarget->*m_pfnSelector)(m_fElapsed);
 			m_fElapsed = 0;
 		}
+#ifdef  ENABLE_LUA
+		else if (m_scriptFunc.size())
+		{
+			schedule_SCHEDULE(m_pTarget, m_pfnSelector, m_fElapsed, m_scriptFunc);
+			m_fElapsed = 0;
+		}
+#endif
 	}
 }
 
@@ -206,10 +240,13 @@ void CCScheduler::unscheduleAllTimers()
 {
 	assert(false);
 }
-
+#ifdef  ENABLE_LUA
+void CCScheduler::scheduleSelector(SEL_SCHEDULE pfnSelector, SelectorProtocol *pTarget, float fInterval, bool bPaused, const char* szScriptFunc)
+#else
 void CCScheduler::scheduleSelector(SEL_SCHEDULE pfnSelector, SelectorProtocol *pTarget, float fInterval, bool bPaused)
+#endif
 {
-	assert(pfnSelector);
+	//assert(pfnSelector);
 	assert(pTarget);
 
 	tHashSelectorEntry *pElement = NULL;
@@ -242,32 +279,66 @@ void CCScheduler::scheduleSelector(SEL_SCHEDULE pfnSelector, SelectorProtocol *p
 		for (unsigned int i = 0; i < pElement->timers->num; ++i)
 		{
 			CCTimer *timer = (CCTimer*)pElement->timers->arr[i];
+#ifdef  ENABLE_LUA
+			if ((timer->m_pfnSelector &&pfnSelector == timer->m_pfnSelector) 
+				|| (szScriptFunc && timer->isScriptFuncExist(szScriptFunc)))
+			{
+				CCLOG("CCSheduler#scheduleSelector. Selector already scheduled.");
+				timer->m_fInterval = fInterval;
+				return;
+			}
+#else
 			if (pfnSelector == timer->m_pfnSelector)
 			{
 				CCLOG("CCSheduler#scheduleSelector. Selector already scheduled.");
 				timer->m_fInterval = fInterval;
 				return;
 			}
+
+#endif
+			
 		}
 		ccArrayEnsureExtraCapacity(pElement->timers, 1);
 	}
 
 	CCTimer *pTimer = new CCTimer();
+#ifdef  ENABLE_LUA
+	if (szScriptFunc)
+	{
+		pTimer->initWithScript(pTarget, szScriptFunc, fInterval);
+	}
+	else
+	{
+		pTimer->initWithTarget(pTarget, pfnSelector, fInterval);
+	}
+	
+#else
 	pTimer->initWithTarget(pTarget, pfnSelector, fInterval);
+#endif
 	ccArrayAppendObject(pElement->timers, pTimer);
 	pTimer->release();	
 }
-
+#ifdef  ENABLE_LUA
+void CCScheduler::unscheduleSelector(SEL_SCHEDULE pfnSelector, SelectorProtocol *pTarget, const char* szScriptFunc)
+#else
 void CCScheduler::unscheduleSelector(SEL_SCHEDULE pfnSelector, SelectorProtocol *pTarget)
+#endif
 {
 	// explicity handle nil arguments when removing an object
+#ifdef  ENABLE_LUA
+	if (pTarget == 0 || (pfnSelector == 0 && szScriptFunc == 0))
+	{
+		return;
+	}
+#else
 	if (pTarget == 0 || pfnSelector == 0)
 	{
 		return;
 	}
+#endif
 
-	assert(pTarget);
-	assert(pfnSelector);
+	//assert(pTarget);
+	//assert(pfnSelector);
 
 	tHashSelectorEntry *pElement = NULL;
 	HASH_FIND_INT(m_pHashForSelectors, &pTarget, pElement);
@@ -278,7 +349,12 @@ void CCScheduler::unscheduleSelector(SEL_SCHEDULE pfnSelector, SelectorProtocol
 		{
 			CCTimer *pTimer = (CCTimer*)(pElement->timers->arr[i]);
 
+#ifdef  ENABLE_LUA
+			if ((pTimer->m_pfnSelector&& pfnSelector == pTimer->m_pfnSelector) ||
+				 pTimer->isScriptFuncExist(szScriptFunc))
+#else
 			if (pfnSelector == pTimer->m_pfnSelector)
+#endif
 			{
 				if (pTimer == pElement->currentTimer && (! pElement->currentTimerSalvaged))
 				{
@@ -562,7 +638,18 @@ void CCScheduler::tick(ccTime dt)
 	{
 		if (! pEntry->paused)
 		{
+#ifdef  ENABLE_LUA
+			if (pEntry->target->m_scriptFunc[ccSEL_Update].size())
+			{
+				schedule_SCHEDULE(NULL, NULL, dt, pEntry->target->m_scriptFunc[ccSEL_Update]);
+			}
+			else
+			{
+				pEntry->target->update(dt);
+			}
+#else
 			pEntry->target->update(dt);
+#endif
 		}
 	}
 
@@ -571,7 +658,19 @@ void CCScheduler::tick(ccTime dt)
 	{
 		if (! pEntry->paused)
 		{
+#ifdef  ENABLE_LUA
+			if (pEntry->target->m_scriptFunc[ccSEL_Update].size())
+			{
+				schedule_SCHEDULE(NULL, NULL,dt,  pEntry->target->m_scriptFunc[ccSEL_Update]);
+			}
+			else
+			{
+				pEntry->target->update(dt);
+			}
+#else
 			pEntry->target->update(dt);
+#endif
+			
 		}
 	}
 
@@ -580,7 +679,19 @@ void CCScheduler::tick(ccTime dt)
 	{
 		if (! pEntry->paused)
 		{
+#ifdef  ENABLE_LUA
+			if (pEntry->target->m_scriptFunc[ccSEL_Update].size())
+			{
+				schedule_SCHEDULE(NULL, NULL,dt,  pEntry->target->m_scriptFunc[ccSEL_Update]);
+			}
+			else
+			{
+				pEntry->target->update(dt);
+			}
+#else
 			pEntry->target->update(dt);
+#endif
+			
 		}
 	}
 

cocos2dx/actions/CCActionInstant.cpp

@@ -268,6 +268,29 @@ namespace cocos2d {
 
 		return pCallFunc;
 	}
+#ifdef  ENABLE_LUA
+	CCCallFunc * CCCallFunc::actionWithLua(const char * pszfunc)
+	{
+		if (pszfunc)
+		{
+			
+			CCCallFunc* pCallFunc = new CCCallFunc();
+			pCallFunc->initWithLua(pszfunc);
+			pCallFunc->autorelease();
+			return pCallFunc;
+		}
+		return NULL;
+	}
+	bool CCCallFunc::initWithLua(const char* pszfn)
+	{
+		if (pszfn)
+		{
+			m_pLuaCallFun = pszfn;
+			return true;
+		}
+		return false;
+	}
+#endif
 	bool CCCallFunc::initWithTarget(SelectorProtocol* pSelectorTarget)
 	{
 		if (pSelectorTarget)
@@ -306,20 +329,28 @@ namespace cocos2d {
 	}
 	void CCCallFunc::execute()
 	{
+#ifdef  ENABLE_LUA
+		schedule_CallFunc(m_pSelectorTarget, m_pCallFunc, m_pLuaCallFun);	
+#else
 		if(m_pCallFunc)
 		{
 			(m_pSelectorTarget->*m_pCallFunc)();
 		}
+#endif
 	}
 	//
 	// CallFuncN
 	//
 	void CCCallFuncN::execute()
 	{
+#ifdef  ENABLE_LUA
+		schedule_CallFuncN(m_pSelectorTarget, m_pCallFuncN, m_pTarget, m_pLuaCallFun);
+#else
 		if(m_pCallFuncN)
 		{
 			(m_pSelectorTarget->*m_pCallFuncN)(m_pTarget);
 		}
+#endif
 	}
 	CCCallFuncN * CCCallFuncN::actionWithTarget(SelectorProtocol* pSelectorTarget, SEL_CallFuncN selector)
 	{
@@ -332,6 +363,20 @@ namespace cocos2d {
 		CC_SAFE_DELETE(pRet);
 		return NULL;
 	}
+#ifdef  ENABLE_LUA
+	CCCallFuncN * CCCallFuncN::actionWithLua(const char * pszfunc)
+	{
+		
+		if (pszfunc)
+		{
+			CCCallFuncN *pRet = new CCCallFuncN();
+			pRet->initWithLua(pszfunc);
+			pRet->autorelease();
+			return pRet;
+		}
+		return NULL;
+	}
+#endif
 	bool CCCallFuncN::initWithTarget(SelectorProtocol* pSelectorTarget, SEL_CallFuncN selector)
 	{
 		if( CCCallFunc::initWithTarget(pSelectorTarget) ) 
@@ -341,6 +386,7 @@ namespace cocos2d {
 		}
 		return false;
 	}
+
 	CCObject * CCCallFuncN::copyWithZone(CCZone* zone)
 	{
 		CCZone* pNewZone = NULL;
@@ -371,6 +417,20 @@ namespace cocos2d {
 		CC_SAFE_DELETE(pRet);
 		return NULL;
 	}
+#ifdef  ENABLE_LUA
+	CCCallFuncND * CCCallFuncND::actionWithLua(const char * pszfunc)
+	{
+		if (pszfunc)
+		{
+			CCCallFuncND* pRet = new CCCallFuncND();
+			pRet->autorelease();
+			pRet->initWithLua(pszfunc);
+			return pRet;
+		}
+		return NULL;
+		
+	}
+#endif
 
 	bool CCCallFuncND::initWithTarget(SelectorProtocol* pSelectorTarget, SEL_CallFuncND selector, void* d)
 	{
@@ -402,10 +462,14 @@ namespace cocos2d {
 
 	void CCCallFuncND::execute()
 	{
+#ifdef  ENABLE_LUA
+		 schedule_CallFuncND(m_pSelectorTarget,m_pCallFuncND, m_pTarget, m_pData, m_pLuaCallFun);
+#else
 		if(m_pCallFuncND)
 		{
 			(m_pSelectorTarget->*m_pCallFuncND)(m_pTarget, m_pData);
 		}
+#endif
 	}
 	
     //
@@ -423,10 +487,14 @@ namespace cocos2d {
 
     void CCCallFuncO::execute()
     {
+#ifdef  ENABLE_LUA
+		schedule_CallFuncO(m_pSelectorTarget, m_pCallFuncO, m_pObject, m_pLuaCallFun);
+#else
         if(m_pCallFuncO)
         {
             (m_pSelectorTarget->*m_pCallFuncO)(m_pObject);
         }
+#endif
     }
     CCCallFuncO * CCCallFuncO::actionWithTarget(SelectorProtocol* pSelectorTarget, SEL_CallFuncO selector, CCObject* pObject)
     {
@@ -439,6 +507,20 @@ namespace cocos2d {
         CC_SAFE_DELETE(pRet);
         return NULL;
     }
+#ifdef  ENABLE_LUA
+	CCCallFuncO * CCCallFuncO::actionWithLua(const char * pszfunc)
+	{
+		if (pszfunc)
+		{
+			 CCCallFuncO *pRet = new CCCallFuncO();
+			 pRet->autorelease();
+			 pRet->initWithLua(pszfunc);
+			 return pRet;
+		}
+		return NULL;
+
+	}
+#endif
     bool CCCallFuncO::initWithTarget(SelectorProtocol* pSelectorTarget, SEL_CallFuncO selector, CCObject* pObject)
     {
         if( CCCallFunc::initWithTarget(pSelectorTarget) ) 

cocos2dx/base_nodes/CCNode.cpp

@@ -933,7 +933,33 @@ void CCNode::unschedule(SEL_SCHEDULE selector)
 
 	CCScheduler::sharedScheduler()->unscheduleSelector(selector, this);
 }
+#ifdef  ENABLE_LUA
+void CCNode::schedule(const char* selector)
+{
+	if (selector == NULL || strlen(selector) == 0)
+	{
+		CCLog(" schedule Argument must be non-nil");
+	}
+	this->schedule(selector, 0);
+	
+}
+void CCNode::schedule(const char*  selector, ccTime interval)
+{
+	if (selector == NULL || strlen(selector) == 0)
+	{
+		CCLog(" schedule Argument must be non-nil");
+	}
+	CCScheduler::sharedScheduler()->scheduleSelector(NULL, this, interval, !m_bIsRunning, selector);
+}
+void CCNode::unschedule(const char* selector)
+{
+	if (selector == 0)
+		return;
 
+	CCScheduler::sharedScheduler()->unscheduleSelector(NULL, this, selector);
+
+}
+#endif
 void CCNode::unscheduleAllSelectors()
 {
 	CCScheduler::sharedScheduler()->unscheduleAllSelectorsForTarget(this);
@@ -1095,5 +1121,11 @@ CCPoint CCNode::convertTouchToNodeSpaceAR(CCTouch *touch)
 	point = CCDirector::sharedDirector()->convertToGL(point);
 	return this->convertToNodeSpaceAR(point);
 }
+#ifdef  ENABLE_LUA
+bool CCNode::registerScriptSelector(const char* szType, const char* szSeletor)
+{
+	return SelectorProtocol::registerScriptSelector(szType, szSeletor);
+}
+#endif
 
 }//namespace   cocos2d 

cocos2dx/include/CCActionInstant.h

@@ -191,6 +191,11 @@ namespace cocos2d {
 		
 		typedef void (SelectorProtocol::*SEL_CallFunc)();
 		*/
+#ifdef  ENABLE_LUA
+		static CCCallFunc * actionWithLua(const char * pszfunc);
+		virtual bool initWithLua(const char* pszfn);
+#endif
+
 		virtual bool initWithTarget(SelectorProtocol* pSelectorTarget);
 		/** executes the callback */
 		virtual void execute();
@@ -200,6 +205,9 @@ namespace cocos2d {
 
 	protected:
 		SelectorProtocol*   m_pSelectorTarget;
+#ifdef  ENABLE_LUA
+		std::string m_pLuaCallFun;
+#endif
 		union
 		{
 			SEL_CallFunc	m_pCallFunc;
@@ -227,6 +235,9 @@ namespace cocos2d {
 
 		typedef void (SelectorProtocol::*SEL_CallFuncN)(CCNode*);
 		*/
+#ifdef  ENABLE_LUA
+		static CCCallFuncN * actionWithLua(const char * pszfunc);
+#endif
 		virtual bool initWithTarget(SelectorProtocol* pSelectorTarget, SEL_CallFuncN selector);
 		// super methods
 		virtual CCObject* copyWithZone(CCZone *pZone);
@@ -244,6 +255,9 @@ namespace cocos2d {
 
 		/** creates the action with the callback and the data to pass as an argument */
 		static CCCallFuncND * actionWithTarget(SelectorProtocol* pSelectorTarget, SEL_CallFuncND selector, void* d);
+#ifdef  ENABLE_LUA
+		static CCCallFuncND * actionWithLua(const char * pszfunc);
+#endif
 		/** initializes the action with the callback and the data to pass as an argument */
 		virtual bool initWithTarget(SelectorProtocol* pSelectorTarget, SEL_CallFuncND selector, void* d);
 		// super methods
@@ -274,6 +288,9 @@ namespace cocos2d {
 
         typedef void (SelectorProtocol::*SEL_CallFuncO)(CCObject*);
         */
+#ifdef  ENABLE_LUA
+		static CCCallFuncO * actionWithLua(const char * pszfunc);
+#endif
         virtual bool initWithTarget(SelectorProtocol* pSelectorTarget, SEL_CallFuncO selector, CCObject* pObject);
         // super methods
         virtual CCObject* copyWithZone(CCZone *pZone);

cocos2dx/include/CCDirector.h

@@ -34,7 +34,9 @@ THE SOFTWARE.
 #include "CCGeometry.h"
 #include "CCEGLView.h"
 #include "CCGL.h"
-
+#ifdef  ENABLE_LUA
+#include <string>
+#endif
 namespace   cocos2d {
 
 	enum  {
@@ -311,6 +313,9 @@ public:
 	/** Ends the execution, releases the running scene.
 	 It doesn't remove the OpenGL view from its parent. You have to do it manually.
 	 */
+#ifdef  ENABLE_LUA
+	inline void endToLua(void){end();}
+#endif
 	void end(void);
 
 	/** Pauses the running scene.
@@ -425,6 +430,10 @@ public:
 	/** detach the cocos2d view from the view/window */
 	bool detach(void);
 
+#ifdef  ENABLE_LUA 
+	std::string m_luatick;
+	void registerTick(const char* szfn);
+#endif
 public:
 	/** returns a shared instance of the director */
 	static CCDirector* sharedDirector(void);

cocos2dx/include/CCLayer.h

@@ -225,6 +225,12 @@ public:
 
 	/** creates a CCMultiplexLayer with one or more layers using a variable argument list. */
 	static CCMultiplexLayer * layerWithLayers(CCLayer* layer, ... );
+
+#ifdef  ENABLE_LUA
+	static CCMultiplexLayer * layerWithLayer(CCLayer* layer);
+	void addLayer(CCLayer* layer);
+	bool initWithLayer(CCLayer* layer);
+#endif
 	/** initializes a MultiplexLayer with one or more layers using a variable argument list. */
 	bool initWithLayers(CCLayer* layer, va_list params);
 	/** switches to a certain layer indexed by n. 

cocos2dx/include/CCMenu.h

@@ -57,7 +57,9 @@ namespace cocos2d{
 		virtual ~CCMenu(){}
 		/** creates a CCMenu with it's items */
 		static CCMenu* menuWithItems(CCMenuItem* item, ...);
-
+#ifdef  ENABLE_LUA
+		static CCMenu*menuWithItem(CCMenuItem* item);
+#endif
 		/** initializes a CCMenu with it's items */
 		bool initWithItems(CCMenuItem* item, va_list args);
 

cocos2dx/include/CCMenuItem.h

@@ -69,6 +69,10 @@ namespace cocos2d{
 		virtual void selected();
 		/** The item was unselected */
 		virtual void unselected();
+#ifdef  ENABLE_LUA
+		virtual void registerMenuHandler(const char* fn);
+		std::string m_strScriptFunc;
+#endif
 	protected:
 		SelectorProtocol*	m_pListener;
 		SEL_MenuHandler		m_pfnSelector;

cocos2dx/include/CCMutableArray.h

@@ -325,6 +325,12 @@ public:
 		return m_array.rbegin();
 	}
 
+#ifdef  ENABLE_LUA
+	CCMutableArrayIterator endToLua(void)
+	{
+		return m_array.end();
+	}
+#endif
 	CCMutableArrayIterator end(void)
 	{
 		return m_array.end();

cocos2dx/include/CCMutableDictionary.h

@@ -182,6 +182,12 @@ public:
 		return pObject;
 	}
 
+#ifdef  ENABLE_LUA
+	void endToLua()
+	{
+		end();
+	} 
+#endif
 	void end()
 	{
 		m_bBegin = false;

cocos2dx/include/CCNode.h

@@ -450,6 +450,14 @@ namespace   cocos2d {
 		/** unschedules a custom selector.*/
 		void unschedule(SEL_SCHEDULE selector);
 
+		/*
+		ad for lua script
+		*/
+#ifdef  ENABLE_LUA
+		void schedule(const char* selector);
+		void schedule(const char*  selector, ccTime interval);
+		void unschedule(const char* selector);
+#endif
 		/** unschedule all scheduled selectors: custom selectors, and the 'update' selector.
 		Actions are not affected by this method.
 		@since v0.99.3
@@ -525,6 +533,9 @@ namespace   cocos2d {
 		@since v0.7.1
 		*/
 		CCPoint convertTouchToNodeSpaceAR(CCTouch * touch);
+#ifdef  ENABLE_LUA
+		bool registerScriptSelector(const char* szType, const char* szSeletor);
+#endif
 
 	};
 }//namespace   cocos2d 

cocos2dx/include/CCRenderTexture.h

@@ -75,6 +75,9 @@ public:
     void beginWithClear(float r, float g, float b, float a);
 
     /** ends grabbing */
+#ifdef  ENABLE_LUA
+	inline void endToLua(){ end();};
+#endif
     void end();
 
     /** clears the texture with a color */

cocos2dx/include/CCScheduler.h

@@ -60,6 +60,14 @@ public:
 
 	/** Allocates a timer with a target, a selector and an interval in seconds. */
 	static CCTimer* timerWithTarget(SelectorProtocol *pTarget, SEL_SCHEDULE pfnSelector, ccTime fSeconds);
+	
+#ifdef  ENABLE_LUA
+	//CCTimer init from Script
+	static CCTimer* timerWithScript(SelectorProtocol* pTarget, const char* szFuncName, ccTime fSeconds);
+	bool initWithScript(SelectorProtocol* pTarget,  const char* szFuncName, ccTime fSeconds);
+	bool isScriptFuncExist( const char* szFuncName);
+	std::string m_scriptFunc;
+#endif
 
 public:
 	SEL_SCHEDULE m_pfnSelector;
@@ -115,8 +123,11 @@ public:
 
 	 @since v0.99.3
 	 */
+#ifdef  ENABLE_LUA 
+	void scheduleSelector(SEL_SCHEDULE pfnSelector, SelectorProtocol *pTarget, ccTime fInterval, bool bPaused, const char* szScriptFunc = NULL);
+#else
 	void scheduleSelector(SEL_SCHEDULE pfnSelector, SelectorProtocol *pTarget, ccTime fInterval, bool bPaused);
-
+#endif
 	/** Schedules the 'update' selector for a given target with a given priority.
 	 The 'update' selector will be called every frame.
 	 The lower the priority, the earlier it is called.
@@ -128,7 +139,11 @@ public:
 	 If you want to unschedule the "update", use unscheudleUpdateForTarget.
 	 @since v0.99.3
 	 */
+#ifdef  ENABLE_LUA
+	void unscheduleSelector(SEL_SCHEDULE pfnSelector, SelectorProtocol *pTarget, const char* szScriptFunc = NULL);
+#else
 	void unscheduleSelector(SEL_SCHEDULE pfnSelector, SelectorProtocol *pTarget);
+#endif
 
 	/** Unschedules the update selector for a given target
 	 @since v0.99.3

cocos2dx/include/CCTouchDelegateProtocol.h

@@ -27,7 +27,12 @@ THE SOFTWARE.
 #define __TOUCH_DISPATHCHER_CCTOUCH_DELEGATE_PROTOCOL_H__
 
 #include "CCObject.h"
-
+#include "ccConfig.h"
+#ifdef  ENABLE_LUA
+#include "CCMutableDictionary.h"
+#include "CCString.h"
+#include "../lua_support/CCLuaSrcipt.h"
+#endif
 namespace   cocos2d {
 
 typedef enum
@@ -46,7 +51,9 @@ class CC_DLL CCTouchDelegate
 {
 protected:
 	ccTouchDelegateFlag m_eTouchDelegateType;
-
+#ifdef  ENABLE_LUA
+	CCMutableDictionary<int, cocos2d::CCString*> *m_pEventDictionary;
+#endif
 public:
 	friend class CCTouchDispatcher; // only CCTouchDispatcher & children can change m_eTouchDelegateType
 	inline ccTouchDelegateFlag getTouchDelegateType(void) { return m_eTouchDelegateType; }
@@ -68,6 +75,90 @@ public:
  	virtual void ccTouchesMoved(CCSet *pTouches, CCEvent *pEvent) {CC_UNUSED_PARAM(pTouches); CC_UNUSED_PARAM(pEvent);}
  	virtual void ccTouchesEnded(CCSet *pTouches, CCEvent *pEvent) {CC_UNUSED_PARAM(pTouches); CC_UNUSED_PARAM(pEvent);}
  	virtual void ccTouchesCancelled(CCSet *pTouches, CCEvent *pEvent) {CC_UNUSED_PARAM(pTouches); CC_UNUSED_PARAM(pEvent);}
+
+#ifdef  ENABLE_LUA
+	//use for lua register event 
+	/*
+	szEventName must be one of follow value 
+	{ "ccTouchBegan" "ccTouchMoved" "ccTouchEnded" "ccTouchCancelled" }
+	*/
+	
+
+	void registerLuaTouchEvent(const char* szEventName, const char* fn)
+	{
+		if (szEventName == NULL || strlen(szEventName) == 0 || fn == NULL || strlen(fn) == 0)
+		{
+			CCLog("registerEvent input parameter error ");
+			return ;
+		}
+
+		std::string strEventType[] = {"ccTouchBegan", "ccTouchMoved", "ccTouchEnded", "ccTouchCancelled", 
+		"ccMulTouchBegan", "ccMulTouchMoved", "ccMulTouchEnded", "ccMulTouchCancelled"};
+		int nSize = sizeof(strEventType);
+		int nType = -1;
+		for(int i = 0; i < nSize; i++)
+		{
+			if (strcmp(strEventType[i].c_str(), szEventName) == 0)
+			{
+				nType = i;
+				break;
+			}
+		}
+		if(nType != -1)
+		{
+			if (m_pEventDictionary == NULL)
+			{
+				m_pEventDictionary = new CCMutableDictionary<int, cocos2d::CCString*>();
+			}
+
+			if (m_pEventDictionary->objectForKey(nType) == NULL)
+			{
+				CCString *pStr = new CCString(fn);
+				m_pEventDictionary->setObject(pStr, nType);
+			}
+			else
+			{
+				CCLog("registerEvent %s already exist", szEventName);
+			}
+		}
+	}
+	CCString* getLuaEvent(int nType)
+	{
+		if (m_pEventDictionary == NULL)
+		{
+			return NULL;
+		}
+		CCString *pfn = NULL;
+		pfn = m_pEventDictionary->objectForKey(nType);
+		return pfn;
+
+	}
+	void excuteLuaTouchEvent(CCString* pLuafn, CCTouch *pTouch)
+	{
+		if (pLuafn)
+		{
+			CCLuaScriptModule::sharedLuaScriptModule()->executeTouch(pLuafn->m_sString.c_str(), pTouch);
+		}
+	}
+
+	void excuteLuaTouchesEvent(CCString* pLuafn, CCSet *pTouches)
+	{
+		if (pLuafn)
+		{
+			CCLuaScriptModule::sharedLuaScriptModule()->executeTouchesEvent(pLuafn->m_sString.c_str(), pTouches);
+		}
+	}
+	CCTouchDelegate(){m_pEventDictionary = NULL;}
+	~CCTouchDelegate()
+	{
+		if (m_pEventDictionary)
+		{
+			delete m_pEventDictionary;
+			m_pEventDictionary = NULL;
+		}
+
+	}
+#endif
 };
 /**
  @brief

cocos2dx/include/selector_protocol.h

@@ -27,16 +27,74 @@ THE SOFTWARE.
 
 #include "ccTypes.h"
 #include "CCObject.h"
+#include <string>
+
+#ifdef  ENABLE_LUA
+#include "../lua_support/CCLuaSrcipt.h"
+#endif
+
 
 namespace   cocos2d {
 class CCNode;
 class CCEvent;
 
+#ifdef  ENABLE_LUA
+enum ccScriptFuncType
+{
+	ccSEL_Update,
+	ccSEL_Tick,
+	ccSEL_CallFunc,
+	ccSEL_CallFuncN,
+	ccSEL_CallFuncND,
+	ccSEL_MenuHandler,
+	ccSEL_EventHandler,
+	ccSEL_Max,
+};
+class CC_DLL CCScriptSelector
+{
+public:
+	std::string m_scriptFunc[ccSEL_Max];
+	inline bool registerScriptSelector(const char* szType, const char* szSeletor)
+	{
+		if (szType == NULL || szSeletor == NULL || strlen(szType) == 0 || strlen(szSeletor) == 0)
+		{
+			CCLog("registerScriptSelector input parameter error");
+			return false;
+		}
+		std::string strType[] ={"SEL_Update", "SEL_Tick", "SEL_CallFunc", "SEL_CallFuncN", \
+			"SEL_CallFuncND", "SEL_CallFuncO", "SEL_MenuHandler", "SEL_EventHandler"};
+		int nType = -1;
+		for (int i = 0; i < sizeof(strType); i++)
+		{
+			if (strcmp(strType[i].c_str(), szType) == 0)
+			{
+				nType = i;
+				break;
+			}
+		}
+		if (nType == -1)
+		{
+			CCLog("registerScriptSelector function type error");
+			return false;
+		}
+		else
+		{
+			m_scriptFunc[nType] = szSeletor;
+		}
+		return true;
+	}
+};
+#endif
+#ifdef  ENABLE_LUA
+class CC_DLL SelectorProtocol:public CCScriptSelector
+#else
 class CC_DLL SelectorProtocol
+#endif
 {
 public:
 	virtual void update(ccTime dt) {CC_UNUSED_PARAM(dt);};
 	virtual void tick(ccTime dt){CC_UNUSED_PARAM(dt);};
+	SelectorProtocol(){};
 	virtual void callfunc(){};
 	virtual void callfunc(CCNode* pSender){CC_UNUSED_PARAM(pSender);};
 	virtual void callfunc(CCNode* pSender, void* pData){CC_UNUSED_PARAM(pSender);CC_UNUSED_PARAM(pData);};
@@ -71,6 +129,101 @@ typedef void (SelectorProtocol::*SEL_EventHandler)(CCEvent*);
   #define callfuncO_selector(_SELECTOR) (SEL_CallFuncO)(&_SELECTOR)
   #define menu_selector(_SELECTOR) (SEL_MenuHandler)(&_SELECTOR)
   #define event_selector(_SELECTOR) (SEL_EventHandler)(&_SELECTOR)
+
+
+inline void schedule_SCHEDULE(SelectorProtocol* pSel,SEL_SCHEDULE pfn, ccTime cc, std::string & strluafnc) 
+{
+	if (pSel && pfn)
+	{
+		(pSel->*pfn)(cc);
+	}
+	else
+	{
+#ifdef  ENABLE_LUA
+		CCLuaScriptModule::sharedLuaScriptModule()->executeSchedule(strluafnc, cc);
+#endif
+
+	}
+}
+
+inline void schedule_CallFunc(SelectorProtocol* pSel,SEL_CallFunc pfn, std::string & strluafnc)
+{
+	if (pSel && pfn)
+	{
+		(pSel->*pfn)();
+	}
+	else
+	{
+#ifdef  ENABLE_LUA
+		CCLuaScriptModule::sharedLuaScriptModule()->executeCallFunc(strluafnc);
+#endif
+
+	}
+}
+inline void schedule_CallFuncN(SelectorProtocol* pSel,SEL_CallFuncN pfn, CCNode* pNode, std::string & strluafnc)
+{
+	if (pSel && pfn)
+	{
+		(pSel->*pfn)(pNode);
+	}
+	else
+	{
+#ifdef  ENABLE_LUA
+		CCLuaScriptModule::sharedLuaScriptModule()->executeCallFuncN(strluafnc, pNode);
+#endif
+	}
+}
+
+inline void schedule_CallFuncND(SelectorProtocol* pSel,SEL_CallFuncND pfn, CCNode* pNode, void* pdata, std::string & strluafnc)
+{
+	if (pSel && pfn)
+	{
+		(pSel->*pfn)(pNode, pdata);
+	}
+	else
+	{
+#ifdef  ENABLE_LUA
+		CCLuaScriptModule::sharedLuaScriptModule()->executeCallFuncND(strluafnc, pNode, pdata);
+#endif
+	}
+}
+
+inline void schedule_MenuHandler(SelectorProtocol* pSel,SEL_MenuHandler pfn, CCObject* pobj, std::string & strluafnc)
+{
+	if (pSel && pfn)
+	{
+		(pSel->*pfn)(pobj);
+	}
+	else
+	{
+#ifdef  ENABLE_LUA
+		CCLuaScriptModule::sharedLuaScriptModule()->executeMenuHandler(strluafnc.c_str(), pobj);
+#endif
+	}
+}
+inline void schedule_CallFuncO(SelectorProtocol* pSel,SEL_MenuHandler pfn, CCObject* pobj, std::string & strluafnc)
+{
+	schedule_MenuHandler(pSel, pfn, pobj, strluafnc);
+}
+
+
+inline void schedule_EventHandler(SelectorProtocol* pSel,SEL_EventHandler pfn, CCEvent* pEvent, std::string & strluafnc)
+{
+	if (pSel && pfn)
+	{
+		(pSel->*pfn)(pEvent);
+	}
+	else
+	{
+#ifdef  ENABLE_LUA
+		CCLuaScriptModule::sharedLuaScriptModule()->executeEventHandler(strluafnc, pEvent);
+#endif
+
+	}
+}
+
+
+
 }//namespace   cocos2d 
 
 #endif // __COCOA_SELECTOR_PROTOCOL_H__

cocos2dx/layers_scenes_transitions_nodes/CCLayer.cpp

@@ -604,6 +604,29 @@ CCMultiplexLayer * CCMultiplexLayer::layerWithLayers(CCLayer * layer, ...)
 	return NULL;
 }
 
+#ifdef  ENABLE_LUA
+CCMultiplexLayer * CCMultiplexLayer::layerWithLayer(CCLayer* layer)
+{
+	CCMultiplexLayer * pMultiplexLayer = new CCMultiplexLayer();
+	pMultiplexLayer->initWithLayer(layer);
+	pMultiplexLayer->autorelease();
+	return pMultiplexLayer;
+}
+void CCMultiplexLayer::addLayer(CCLayer* layer)
+{
+	assert(m_pLayers);
+	m_pLayers->addObject(layer);
+}
+
+bool CCMultiplexLayer::initWithLayer(CCLayer* layer)
+{
+	m_pLayers = new CCMutableArray<CCLayer*>(1);
+	m_pLayers->addObject(layer);
+	m_nEnabledLayer = 0;
+	this->addChild(layer);
+	return true;
+}
+#endif
 bool CCMultiplexLayer::initWithLayers(CCLayer *layer, va_list params)
 {
 	m_pLayers = new CCMutableArray<CCLayer*>(5);

cocos2dx/lua_support/CCLuaSrcipt.cpp

@@ -0,0 +1,535 @@
+#include "CCLuaSrcipt.h"
+#ifdef  ENABLE_LUA
+
+extern "C" {
+#include "lualib.h"
+#include "lauxlib.h"
+}
+
+
+#include "tolua++.h"
+#include "CCTouch.h"
+#include "CCNode.h"
+#include "CCObject.h"
+#include "LuaCocos2d.h"
+namespace cocos2d
+{
+
+CCLuaScriptModule* CCLuaScriptModule::s_luaScriptModule = NULL;
+
+CCLuaScriptModule* CCLuaScriptModule::sharedLuaScriptModule(void)
+{
+	if (s_luaScriptModule == NULL)
+	{
+		s_luaScriptModule = new CCLuaScriptModule();
+	}
+	return s_luaScriptModule;
+}
+void CCLuaScriptModule::purgeSharedLuaScriptModule()
+{
+	s_luaScriptModule->release();
+	s_luaScriptModule = NULL;
+}
+
+/*************************************************************************
+	Constructor (creates Lua state)
+*************************************************************************/
+CCLuaScriptModule::CCLuaScriptModule()
+{
+	
+	d_ownsState = true;
+	d_state = lua_open();
+	luaL_openlibs(d_state);
+	int nOpen = tolua_Cocos2d_open(d_state);
+	// init all standard libraries
+	/*luaopen_base(d_state);
+	luaopen_io(d_state);
+	luaopen_string(d_state);
+	luaopen_table(d_state);
+	luaopen_math(d_state);
+	*/
+	//luaopen_debug(d_state);
+}
+
+
+/*************************************************************************
+	Constructor (uses given Lua state)
+*************************************************************************/
+CCLuaScriptModule::CCLuaScriptModule(lua_State* state)
+{
+	// just use the given state
+	d_ownsState = false;
+	d_state = state;
+}
+
+
+/*************************************************************************
+	Destructor
+*************************************************************************/
+CCLuaScriptModule::~CCLuaScriptModule()
+{
+	if ( d_ownsState && d_state )
+	{
+		lua_close( d_state );
+	}
+	s_luaScriptModule = NULL;
+
+}
+
+/*************************************************************************
+	Execute script file
+*************************************************************************/
+void CCLuaScriptModule::executeScriptFile(const std::string& filename)
+{
+	int nRet = luaL_dofile(d_state,filename.c_str());
+	if (nRet != 0)
+	{
+		CCLog("executeScriptFile Error nRet = %d", nRet);
+	}
+}
+
+
+/*************************************************************************
+	Execute global script function
+*************************************************************************/
+int	CCLuaScriptModule::executeScriptGlobal(const std::string& function_name)
+{
+	// get the function from lua
+	lua_getglobal(d_state, function_name.c_str());
+	// is it a function
+	if ( !lua_isfunction(d_state,-1) )
+	{
+		CCLog("name does not represent a Lua function");
+		lua_settop( d_state, 0 );
+		return 0;
+	}
+
+	// call it
+	int error = lua_pcall(d_state,0,1,0);		
+
+	// handle errors
+	if ( error )
+	{
+		std::string msg = lua_tostring(d_state,-1);
+		lua_pop(d_state,1);
+		CCLog("%s", msg.c_str());
+		lua_settop( d_state, 0 );
+		return 0;
+	}
+
+	// get return value
+	if ( !lua_isnumber(d_state,-1) )
+	{
+		CCLog("return value is not a number %s", function_name.c_str());
+		lua_settop( d_state, 0 );
+		return 0;
+	}
+
+	int ret = (int)lua_tonumber(d_state,-1);
+	lua_pop(d_state,1);
+
+	// return it
+	return ret;
+
+	
+}
+
+
+/*************************************************************************
+	Execute scripted event handler
+*************************************************************************/
+
+
+bool CCLuaScriptModule::executeSchedule(const std::string& handler_name, ccTime cc)
+{
+
+	if (handler_name.size() == 0)
+	{
+		std::string msg = "(LuaScriptModule) Unable to execute scripted event handler: handler_name == NULL\n";
+		CCLog("%s  %d", msg.c_str(), __LINE__);
+		return false;
+	}
+	
+	// get the function from lua
+	lua_getglobal(d_state, handler_name.c_str());
+
+	// is it a function
+	if ( !lua_isfunction(d_state,-1) )
+	{
+		lua_settop( d_state, 0 );
+		std::string msg = "(LuaScriptModule) Unable to execute scripted event handler: "+handler_name+"\n\n"+"name does not represent a Lua function"+"\n";
+		CCLog("%s %d", msg.c_str(), __FILE__);
+		return false;
+	}
+
+	// push EventArgs as the first parameter
+	//tolua_pushusertype(d_state,(void*)&cc,"dFloat");
+	lua_pushfstring(d_state, "%f", cc);
+
+	// call it
+	int error = lua_pcall(d_state,1,0,0);
+
+	// handle errors
+	if ( error )
+	{
+		std::string msg = lua_tostring(d_state,-1);
+		lua_pop(d_state,1);
+		lua_settop( d_state, 0 );
+		std::string msgerror = "(LuaScriptModule) Unable to execute scripted event handler: "+handler_name+"\n\n"+msg+"\n";
+		CCLog("%s %d", msgerror.c_str(), __FILE__);
+		return false;
+	}
+	// return it
+	return true;
+
+
+}
+bool CCLuaScriptModule::executeCallFunc(const std::string& handler_name)
+{
+	
+	if (handler_name.size() == 0)
+	{
+		std::string msg = "(LuaScriptModule) Unable to execute scripted event handler:handler_name == NULL\n";
+		CCLog("%s  %d", msg.c_str(), __LINE__);
+		return false;
+	}
+	lua_getglobal(d_state, handler_name.c_str());
+
+	// is it a function
+	if ( !lua_isfunction(d_state,-1) )
+	{
+		lua_settop( d_state, 0 );
+		std::string msg = "(LuaScriptModule) Unable to execute scripted event handler: "+handler_name + "name does not represent a Lua functio"+"\n";
+		CCLog("%s %d", msg.c_str(), __LINE__);
+		return false;
+	}
+	// push EventArgs as the first parameter
+	//tolua_pushusertype(d_state,(void*)&cc,"cocos2d::ccTime");
+	// call it
+	int error = lua_pcall(d_state,0,0,0);
+	// handle errors
+	if ( error )
+	{
+		std::string msg = lua_tostring(d_state,-1);
+		lua_pop(d_state,1);
+		lua_settop( d_state, 0 );
+		std::string msgerror = "(LuaScriptModule) Unable to execute scripted event handler: "+handler_name + msg +"\n";
+		CCLog("%s  %d", msgerror.c_str(), __LINE__);
+		return false;
+	}
+	// return it
+	return true;
+
+}
+bool CCLuaScriptModule::executeCallFuncN(const std::string& handler_name, CCNode* pNode)
+{
+
+	if (handler_name.size() == 0)
+	{
+		std::string msg = "(executeCallFuncN) Unable to execute scripted event handler: handler_name == NULL\n";
+		CCLog("%s  %d ", msg.c_str(), __LINE__);
+		return false;
+	}
+	lua_getglobal(d_state, handler_name.c_str());
+
+
+	// is it a function
+	if ( !lua_isfunction(d_state,-1) )
+	{
+		lua_settop( d_state, 0 );
+		std::string msg = "(executeCallFuncN) Unable to execute scripted event handler: "+handler_name +"name does not represent a Lua function"+"\n";
+			CCLog("%s  %d", msg.c_str(), __LINE__);
+		return false;
+	}
+	// push EventArgs as the first parameter
+	tolua_pushusertype(d_state,(void*)pNode,"cocos2d::CCNode");
+	// call it
+	int error = lua_pcall(d_state,1,0,0);
+	// handle errors
+	if ( error )
+	{
+		std::string msg = lua_tostring(d_state,-1);
+		lua_pop(d_state,1);
+		lua_settop( d_state, 0 );
+		std::string msgerror = "(executeCallFuncN) Unable to execute scripted event handler: "+handler_name +msg+"\n";
+			CCLog("%s %d", msgerror.c_str(),  __LINE__);
+		return false;
+	}
+	// return it
+	return true;
+
+}
+bool CCLuaScriptModule::executeCallFuncND(const std::string& handler_name, CCNode* pNode,  void*pData)
+{
+
+
+	if (handler_name.size() == 0)
+	{
+		std::string msg = "(executeCallFuncND) Unable to execute scripted event handler: handler_name == NULL\n";
+		CCLog("%s  %d", msg.c_str(), __LINE__);
+		return false;
+	}
+	// get the function from lua
+	lua_getglobal(d_state, handler_name.c_str());
+
+	// is it a function
+	if ( !lua_isfunction(d_state,-1) )
+	{
+		lua_settop( d_state, 0 );
+		std::string msg = "(executeCallFuncND) Unable to execute scripted event handler: "+handler_name +"name does not represent a Lua function"+"\n";
+		CCLog("%s  %d", msg.c_str(), __LINE__);
+		return false;
+	}
+	// push EventArgs as the first parameter
+	tolua_pushusertype(d_state,(void*)pNode,"cocos2d::CCNode");
+	tolua_pushusertype(d_state,(void*)pData,"void*");
+	// call it
+	int error = lua_pcall(d_state,2,0,0);
+	// handle errors
+	if ( error )
+	{
+		std::string msg = lua_tostring(d_state,-1);
+		lua_pop(d_state,1);
+		lua_settop( d_state, 0 );
+		std::string msgerror = "(executeCallFuncND) Unable to execute scripted event handler: "+handler_name +msg+"\n";
+		CCLog("%s  %d", msgerror.c_str(), __LINE__);
+		return false;
+	}
+	// return it
+	return true;
+
+}
+bool CCLuaScriptModule::executeMenuHandler(const std::string& handler_name, CCObject* pobj)
+{
+
+		if (handler_name.size() == 0)
+		{
+			std::string msg = "(LuaScriptModule) Unable to execute scripted event handler: handler_name == NULL\n";
+			CCLog("%s  %d", msg.c_str(), __LINE__);
+			return false;
+		}
+		// get the function from lua
+		lua_getglobal(d_state, handler_name.c_str());
+
+		// is it a function
+		if ( !lua_isfunction(d_state,-1) )
+		{
+			lua_settop( d_state, 0 );
+			std::string msg = "(LuaScriptModule) Unable to execute scripted event handler: "+handler_name + "name does not represent a Lua function"+"\n";
+			CCLog("%s %d", msg.c_str(), __LINE__);
+			return false;
+		}
+		// push EventArgs as the first parameter
+		tolua_pushusertype(d_state,(void*)pobj,"cocos2d::CCObject");
+		// call it
+		int error = lua_pcall(d_state,1,0,0);
+		// handle errors
+		if ( error )
+		{
+			std::string msg = lua_tostring(d_state,-1);
+			lua_pop(d_state,1);
+			std::string msgerror = "(LuaScriptModule) Unable to execute scripted event handler: "+handler_name +msg+"\n";
+			CCLog("%s %d", msgerror.c_str(), __LINE__);
+			return false;
+		}
+		// return it
+		return true;
+
+}
+
+bool CCLuaScriptModule::executeTouchesEvent(const std::string& handler_name, CCSet *pobj)
+{
+
+	if (handler_name.size() == 0)
+	{
+		std::string msg = "(LuaScriptModule) Unable to execute scripted event handler: handler_name == null\n";
+		CCLog("%s %d", msg.c_str(), __LINE__);
+		return false;
+	}
+	// get the function from lua
+	lua_getglobal(d_state, handler_name.c_str());
+
+	// is it a function
+	if ( !lua_isfunction(d_state,-1) )
+	{
+		lua_settop( d_state, 0 );
+		std::string msg = "(LuaScriptModule) Unable to execute scripted event handler: "+handler_name+"name does not represent a Lua function"+"\n";
+		CCLog("%s %d", msg.c_str(), __LINE__);
+		return false;
+	}
+	// push EventArgs as the first parameter
+	tolua_pushusertype(d_state,(void*)pobj,"cocos2d::CCSet");
+	// call it
+	int error = lua_pcall(d_state,1,0,0);
+	// handle errors
+	if ( error )
+	{
+		std::string msg = lua_tostring(d_state,-1);
+		lua_pop(d_state,1);
+		lua_settop( d_state, 0 );
+		std::string msgerror = "(LuaScriptModule) Unable to execute scripted event handler: "+handler_name+msg+"\n";
+		CCLog("%s %d", msgerror.c_str(), __LINE__);
+		return false;
+	}
+	// return it
+	return true;
+}
+
+bool CCLuaScriptModule::executeTouch(const std::string& handler_name, CCTouch *pobj)
+{
+
+		if (handler_name.size() == 0)
+		{
+			std::string msg = "(LuaScriptModule) Unable to execute scripted event handler: handler_name == null\n";
+			CCLog("%s %d", msg.c_str(), __LINE__);
+			return false;
+		}
+		// get the function from lua
+		lua_getglobal(d_state, handler_name.c_str());
+
+		// is it a function
+		if ( !lua_isfunction(d_state,-1) )
+		{
+			lua_settop( d_state, 0 );
+			std::string msg = "(LuaScriptModule) Unable to execute scripted event handler: "+handler_name+"\n\n"+"name does not represent a Lua function"+"\n";
+			CCLog("%s ", msg.c_str());
+			return false;
+		}
+		// push EventArgs as the first parameter
+		tolua_pushusertype(d_state,(void*)pobj,"cocos2d::CCTouch");
+		// call it
+		int error = lua_pcall(d_state,1,0,0);
+		// handle errors
+		if ( error )
+		{
+			std::string msg = lua_tostring(d_state,-1);
+			lua_pop(d_state,1);
+			std::string msgerror = "(LuaScriptModule) Unable to execute scripted event handler: "+handler_name+"\n\n"+msg+"\n";
+			CCLog("%s ", msgerror.c_str());
+			return false;
+		}
+		// return it
+		return true;
+	
+
+}
+bool CCLuaScriptModule::executeEventHandler(const std::string& handler_name, CCEvent* pEvent)
+{
+
+	if (handler_name.size() == 0)
+	{
+		std::string msg = "(LuaScriptModule) Unable to execute scripted event handler: handler_name == NULL\n";
+		CCLog("%s ", msg.c_str());
+		return false;
+	}
+	// get the function from lua
+	lua_getglobal(d_state, handler_name.c_str());
+
+	// is it a function
+	if ( !lua_isfunction(d_state,-1) )
+	{
+		lua_settop( d_state, 0 );
+		std::string msg = "(LuaScriptModule) Unable to execute scripted event handler: "+handler_name+"\n\n"+"name does not represent a Lua function"+"\n";
+		CCLog("%s ", msg.c_str());
+		return false;
+	}
+	// push EventArgs as the first parameter
+	tolua_pushusertype(d_state,(void*)pEvent,"cocos2d::CCEvent");
+	// call it
+	int error = lua_pcall(d_state,1,0,0);
+	// handle errors
+	if ( error )
+	{
+		std::string msg = lua_tostring(d_state,-1);
+		lua_pop(d_state,1);
+		lua_settop( d_state, 0 );
+		std::string msgerror = "(LuaScriptModule) Unable to execute scripted event handler: "+handler_name+"\n\n"+msg+"\n";
+		CCLog("%s ", msgerror.c_str());
+		return false;
+	}
+	// return it
+	return true;
+
+}
+
+bool CCLuaScriptModule::executeListItem(const std::string& handler_name, int index, CCObject* pobj)
+{
+
+	if (handler_name.size() == 0)
+	{
+		std::string msg = "(CCLuaScriptModule) Unable to execute scripted event handler: handler_name == NULL\n";
+		CCLog("%s  %d", msg.c_str(), __LINE__);
+		return false;
+	}
+	// get the function from lua
+	lua_getglobal(d_state, handler_name.c_str());
+
+	// is it a function
+	if ( !lua_isfunction(d_state,-1) )
+	{
+		lua_settop( d_state, 0 );
+		std::string msg = "(CCLuaScriptModule) Unable to execute scripted event handler: "+handler_name +"name does not represent a Lua function"+"\n";
+		CCLog("%s  %d", msg.c_str(), __LINE__);
+		return false;
+	}
+	// push EventArgs as the first parameter
+	lua_pushfstring(d_state, "%d", index);
+	tolua_pushusertype(d_state,(void*)pobj,"cocos2d::CCObject");
+	// call it
+	int error = lua_pcall(d_state,2,0,0);
+	// handle errors
+	if ( error )
+	{
+		std::string msg = lua_tostring(d_state,-1);
+		lua_pop(d_state,1);
+		lua_settop( d_state, 0 );
+		std::string msgerror = "(CCLuaScriptModule) Unable to execute scripted event handler: "+handler_name +msg+"\n";
+		CCLog("%s  %d", msgerror.c_str(), __LINE__);
+		return false;
+	}
+	// return it
+	return true;
+
+}
+
+/*************************************************************************
+	Execute script code string
+*************************************************************************/
+void CCLuaScriptModule::executeString(const std::string& str)
+{
+	// load code into lua and call it
+	int error =	luaL_dostring(d_state, str.c_str());
+
+	// handle errors
+	if ( error )
+	{
+		CCLog("executeString %d", error);
+	}
+
+}
+	
+
+/*************************************************************************
+	Create Lua bindings
+*************************************************************************/
+void CCLuaScriptModule::createBindings(void)
+{
+	
+	//tolua_Cocos2d_open(d_state);
+}
+
+
+/*************************************************************************
+	Destroy Lua bindings
+*************************************************************************/
+void CCLuaScriptModule::destroyBindings(void)
+{
+	
+	lua_pushnil(d_state);
+	lua_setglobal(d_state,"cocos2d");
+}
+
+
+} // namespace CEGUI
+
+#endif //CC_ENABLE_LUA

cocos2dx/lua_support/CCLuaSrcipt.h

@@ -0,0 +1,175 @@
+#ifndef _CCLUASRCIPT_H
+#define _CCLUASRCIPT_H
+#include "ccConfig.h"
+
+#ifdef  ENABLE_LUA
+#include "CCCommon.h"
+#include "CCObject.h"
+#include <string>
+#include "ccTypes.h"
+// include Lua
+extern "C" {
+#include "lua.h"
+}
+
+
+
+namespace cocos2d
+{
+	class CCEvent;
+	class CCNode;
+	class CCObject;
+
+class CC_DLL CCLuaScriptModule :  public CCObject
+{
+public:
+	/*************************************************************************
+		Construction and Destruction
+	*************************************************************************/
+	/*!
+	\brief
+		Constructor for LuaScriptModule class which create a lua_State
+	*/
+	CCLuaScriptModule();
+
+	/*!
+	\brief
+		Constructor for LuaScriptModule class which takes a lua_State
+
+	\param state
+		Pointer to the lua_State that the script module should attach to.
+	*/
+	CCLuaScriptModule(lua_State* state);
+
+
+	/*!
+	\brief
+		Destructor for LuaScriptModule class.
+	*/
+	virtual ~CCLuaScriptModule();
+
+
+	/*************************************************************************
+		Script Execution Functions
+	*************************************************************************/
+	/*!
+	\brief
+		Execute a script file.
+
+	\param filename
+		String object holding the filename of the script file that is to be executed
+		
+	*/
+	void executeScriptFile(const std::string& filename);
+
+
+	/*!
+	\brief
+		Execute a scripted global function.  The function should not take any parameters and should return an integer.
+
+	\param function_name
+		String object holding the name of the function, in the global script environment, that
+		is to be executed.
+
+	\return
+		The integer value returned from the script function.
+	*/
+	int executeScriptGlobal(const std::string& function_name);
+
+
+	/*!
+	\brief
+		Execute a scripted global 'event handler' function.  The function should take some kind of EventArgs like parameter
+		that the concrete implementation of this function can create from the passed EventArgs based object.  The function
+		should not return anything.
+
+	\param handler_name
+		String object holding the name of the scripted handler function.
+
+	\param e
+		EventArgs based object that should be passed, by any appropriate means, to the scripted function.
+
+	\return
+		- true if the event was handled.
+		- false if the event was not handled.
+	*/
+	bool executeSchedule(const std::string& handler_name, ccTime cc);
+	bool executeCallFunc(const std::string& handler_name);
+	bool executeCallFuncN(const std::string& handler_name, CCNode* pNode);
+	bool executeCallFuncND(const std::string& handler_name, CCNode* pNode,  void*pData);
+	bool executeMenuHandler(const std::string& handler_name, CCObject* pobj);
+	bool executeEventHandler(const std::string& handler_name, CCEvent* pEvent);
+	bool executeTouchesEvent(const std::string& handler_name, CCSet *pobj);
+	bool executeTouch(const std::string& handler_name, CCTouch *pobj);
+	bool executeListItem(const std::string& handler_name, int index, CCObject* pobj);
+	/*!
+    \brief
+        Execute script code contained in the given CEGUI::String object.
+
+    \param str
+        String object holding the valid script code that should be executed.
+
+    \return
+        Nothing.
+    */
+	void executeString(const std::string& str);
+
+
+	/*************************************************************************
+		Bindings creation / destruction
+	*************************************************************************/
+	/*!
+    \brief
+        Method called during system initialisation, prior to running any scripts via the ScriptModule, to enable the ScriptModule
+        to perform any operations required to complete initialisation or binding of the script language to the gui system objects.
+
+    \return
+        Nothing.
+    */
+	void createBindings(void);
+
+
+	/*!
+    \brief
+        Method called during system destruction, after all scripts have been run via the ScriptModule, to enable the ScriptModule
+        to perform any operations required to cleanup bindings of the script language to the gui system objects, as set-up in the
+        earlier createBindings call.
+
+    \return
+        Nothing.
+    */
+	void destroyBindings(void);
+
+
+	/*************************************************************************
+		Accessor type functions
+	*************************************************************************/
+	/*!
+    \brief
+		Method used to get a pointer to the lua_State that the script module is attached to.
+
+    \return
+        A pointer to the lua_State that the script module is attached to.
+    */
+	lua_State* getLuaState(void) const	{return d_state;}
+
+
+	static CCLuaScriptModule* sharedLuaScriptModule(void);
+
+	static void purgeSharedLuaScriptModule();
+
+	
+private:
+	static CCLuaScriptModule* s_luaScriptModule;
+	/*************************************************************************
+		Implementation Data
+	*************************************************************************/
+	bool d_ownsState;		//!< true when the attached lua_State was created by this script module
+	lua_State* d_state;		//!< The lua_State that this script module uses.
+
+};
+
+} // namespace cocos2d
+
+#endif //CC_ENABLE_LUA
+#endif // end of guard _CCLUASRCIPT_H

cocos2dx/lua_support/LuaCocos2d.cpp.REMOVED.git-id

@@ -0,0 +1 @@
+4a88465b2e4f0be14a616912fe45fbe1f1ac169a

cocos2dx/lua_support/LuaCocos2d.h

@@ -0,0 +1,19 @@
+#ifndef LUACOCOS2D_H
+#define LUACOCOS2D_H
+#include "cocos2d.h"
+#ifdef  ENABLE_LUA
+#include <stdio.h>
+#include "lua.h"
+#include "CCKeypadDispatcher.h"
+#include "CCRibbon.h"
+#include "CCParallaxNode.h"
+#include "CCAutoreleasePool.h"
+#include "CCIMEDispatcher.h"
+#include "CCMutableArray.h"
+//#define  TOLUA_RELEASE
+#if  defined(_WIN32) && defined(_DEBUG)
+#pragma warning (disable:4800)
+#endif
+int  tolua_Cocos2d_open(lua_State* tolua_S);
+#endif
+#endif//LUACOCOS2D_H

cocos2dx/menu_nodes/CCMenu.cpp

@@ -60,6 +60,14 @@ namespace cocos2d{
 		return NULL;
 	}
 
+#ifdef  ENABLE_LUA
+	CCMenu* CCMenu::menuWithItem(CCMenuItem* item)
+	{
+		return menuWithItems(item, NULL);
+	}
+
+#endif
+
 	bool CCMenu::initWithItems(CCMenuItem* item, va_list args)
 	{
 		if (CCLayer::init())

cocos2dx/menu_nodes/CCMenuItem.cpp

@@ -29,7 +29,9 @@ THE SOFTWARE.
 #include "CCSprite.h"
 #include "CCLabelAtlas.h"
 #include "CCLabelTTF.h"
-
+#ifdef  ENABLE_LUA
+#include "CCTouchDispatcher.h"
+#endif
 #include <stdarg.h>
 
 namespace cocos2d{
@@ -64,6 +66,16 @@ namespace cocos2d{
 		m_bIsSelected = false;
 		return true;
 	}
+#ifdef  ENABLE_LUA
+	void CCMenuItem::registerMenuHandler(const char* fn)
+	{
+		if (fn && strlen(fn))
+		{
+			//SelectorProtocol is not a child of CCObject  Obj->autorelease function can not be use
+			m_strScriptFunc = fn;
+		}
+	}
+#endif
 	void CCMenuItem::selected()
 	{
 		m_bIsSelected = true;
@@ -74,9 +86,18 @@ namespace cocos2d{
 	}
 	void CCMenuItem::activate()
 	{
-		if (m_bIsEnabled && m_pListener)
+		if (m_bIsEnabled)
 		{
-			(m_pListener->*m_pfnSelector)(this);
+			if (m_pListener)
+			{
+				(m_pListener->*m_pfnSelector)(this);
+			}
+#ifdef  ENABLE_LUA
+			else if(m_strScriptFunc.size())
+			{
+				schedule_MenuHandler(m_pListener, m_pfnSelector, this, m_strScriptFunc); 
+			}
+#endif
 		}
 	}
 	void CCMenuItem::setIsEnabled(bool enabled)

cocos2dx/platform/CCCommon.h

@@ -37,6 +37,13 @@ static const int kMaxLogLen = 255;
 */
 void CC_DLL CCLog(const char * pszFormat, ...);
 
+#ifdef  ENABLE_LUA 
+inline void CC_DLL CCLuaLog(const char * pszFormat)
+{
+	CCLog(pszFormat);
+}
+#endif
+
 /**
 @brief Pop out a message box
 */

cocos2dx/proj.win32/cocos2d-win32.vcproj

@@ -42,8 +42,8 @@
 			<Tool
 				Name="VCCLCompilerTool"
 				Optimization="0"
-				AdditionalIncludeDirectories="..\platform;..\platform\third_party\win32\iconv;..\platform\third_party\win32\zlib;..\platform\third_party\win32\libpng;..\platform\third_party\win32\libjpeg;..\platform\third_party\win32\libxml2;..\platform\third_party\win32\OGLES;..\include;.."
-				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;COCOS2DXWIN32_EXPORTS;GL_GLEXT_PROTOTYPES"
+				AdditionalIncludeDirectories="..\..\lua\tolua;..\..\lua\src;..\platform;..\platform\third_party\win32\iconv;..\platform\third_party\win32\zlib;..\platform\third_party\win32\libpng;..\platform\third_party\win32\libjpeg;..\platform\third_party\win32\libxml2;..\platform\third_party\win32\OGLES;..\include;.."
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;COCOS2DXWIN32_EXPORTS;GL_GLEXT_PROTOTYPES;ENABLE_LUA"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
 				RuntimeLibrary="3"
@@ -65,7 +65,7 @@
 			/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="libEGL.lib libgles_cm.lib libxml2.lib libzlib.lib libpng.lib libjpeg.lib libiconv.lib"
+				AdditionalDependencies="libEGL.lib libgles_cm.lib libxml2.lib libzlib.lib libpng.lib libjpeg.lib libiconv.lib liblua.lib"
 				OutputFile="$(OutDir)\$(ProjectName).dll"
 				LinkIncremental="2"
 				AdditionalLibraryDirectories="&quot;$(OutDir)&quot;"
@@ -1080,6 +1080,26 @@
 				>
 			</File>
 		</Filter>
+		<Filter
+			Name="lua_support"
+			>
+			<File
+				RelativePath="..\lua_support\CCLuaSrcipt.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\lua_support\CCLuaSrcipt.h"
+				>
+			</File>
+			<File
+				RelativePath="..\lua_support\LuaCocos2d.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\lua_support\LuaCocos2d.h"
+				>
+			</File>
+		</Filter>
 		<File
 			RelativePath="..\CCCamera.cpp"
 			>

cocos2dx/touch_dispatcher/CCTouchDispatcher.cpp

@@ -279,7 +279,20 @@ void CCTouchDispatcher::touches(CCSet *pTouches, CCEvent *pEvent, unsigned int u
 				bool bClaimed = false;
 				if (uIndex == ccTouchBegan)
 				{
+#ifdef  ENABLE_LUA
+					CCString*pLuaFn = pHandler->getDelegate()->getLuaEvent(ccTouchBegan);
+					if (pLuaFn)
+					{
+						bClaimed = true;
+						pHandler->getDelegate()->excuteLuaTouchEvent(pLuaFn, pTouch);
+					}
+					else
+					{
+						bClaimed = pHandler->getDelegate()->ccTouchBegan(pTouch, pEvent);
+					}
+#else
 					bClaimed = pHandler->getDelegate()->ccTouchBegan(pTouch, pEvent);
+#endif
 					if (bClaimed)
 					{
 						pHandler->getClaimedTouches()->addObject(pTouch);
@@ -289,7 +302,45 @@ void CCTouchDispatcher::touches(CCSet *pTouches, CCEvent *pEvent, unsigned int u
 				{
 					// moved ended cancelled
 					bClaimed = true;
+#ifdef  ENABLE_LUA
+					CCString*pLuaFn = pHandler->getDelegate()->getLuaEvent(sHelper.m_type);
 
+					switch (sHelper.m_type)
+					{
+					case ccTouchMoved:
+						if (pLuaFn)
+						{
+							pHandler->getDelegate()->excuteLuaTouchEvent(pLuaFn, pTouch);
+						}
+						else
+						{
+							pHandler->getDelegate()->ccTouchMoved(pTouch, pEvent);
+						}
+						break;
+					case ccTouchEnded:
+						if (pLuaFn)
+						{
+							pHandler->getDelegate()->excuteLuaTouchEvent(pLuaFn, pTouch);
+						}
+						else
+						{
+							pHandler->getDelegate()->ccTouchEnded(pTouch, pEvent);
+						}
+						pHandler->getClaimedTouches()->removeObject(pTouch);
+						break;
+					case ccTouchCancelled:
+						if (pLuaFn)
+						{
+							pHandler->getDelegate()->excuteLuaTouchEvent(pLuaFn, pTouch);
+						}
+						else
+						{
+							pHandler->getDelegate()->ccTouchCancelled(pTouch, pEvent);
+						}
+						pHandler->getClaimedTouches()->removeObject(pTouch);
+						break;
+					}
+#else
 					switch (sHelper.m_type)
 					{
 					case ccTouchMoved:
@@ -304,6 +355,7 @@ void CCTouchDispatcher::touches(CCSet *pTouches, CCEvent *pEvent, unsigned int u
 						pHandler->getClaimedTouches()->removeObject(pTouch);
 						break;
 					}
+#endif
 				}
 
 				if (bClaimed && pHandler->isSwallowsTouches())
@@ -334,7 +386,34 @@ void CCTouchDispatcher::touches(CCSet *pTouches, CCEvent *pEvent, unsigned int u
             {
 			    break;
             }
+#ifdef  ENABLE_LUA
+			CCString*pLuaTouchesfn = pHandler->getDelegate()->getLuaEvent(sHelper.m_type);
+			if (pLuaTouchesfn)
+			{
+				pHandler->getDelegate()->excuteLuaTouchesEvent(pLuaTouchesfn, pMutableTouches);
+			}
+			else
+			{
 
+				switch (sHelper.m_type)
+				{
+				case ccTouchBegan:
+					pHandler->getDelegate()->ccTouchesBegan(pMutableTouches, pEvent);
+					break;
+				case ccTouchMoved:
+					pHandler->getDelegate()->ccTouchesMoved(pMutableTouches, pEvent);
+					break;
+				case ccTouchEnded:
+					pHandler->getDelegate()->ccTouchesEnded(pMutableTouches, pEvent);
+					break;
+				case ccTouchCancelled:
+					pHandler->getDelegate()->ccTouchesCancelled(pMutableTouches, pEvent);
+					break;
+				}
+
+			}
+	
+#else
 			switch (sHelper.m_type)
 			{
 			case ccTouchBegan:
@@ -350,6 +429,7 @@ void CCTouchDispatcher::touches(CCSet *pTouches, CCEvent *pEvent, unsigned int u
 				pHandler->getDelegate()->ccTouchesCancelled(pMutableTouches, pEvent);
 				break;
 			}
+#endif
 		}
 	}
 

extensions/NdControls/ControlDefine.h

@@ -0,0 +1,43 @@
+#ifndef _CONTROL_DEFINE_H_
+#define _CONTROL_DEFINE_H_
+
+namespace NdCxControl
+{
+
+typedef enum
+{
+    PARENT_CENTER,
+    VERTICAL_TOP,
+    VERTICAL_BOTTOM,
+    HORIZONTAL_LEFT,
+    HORIZONTAL_RIGHT,
+    ABS_WITH_PIXEL,
+    ABS_WITH_PERCENT,
+    REF_PREV_X_INC,
+    REF_PREV_X_DEC,
+    REF_PREV_Y_INC,
+    REF_PREV_Y_DEC,
+    REL_FLOW
+} LAYOUT_TYPE;
+
+typedef struct
+{
+    LAYOUT_TYPE t;
+    union
+    {
+        float pixel_val;
+        float percent_val;
+    } val;
+} LayoutParamVal;
+
+typedef struct
+{
+    LayoutParamVal val_x;
+    LayoutParamVal val_y;
+    float          padding;
+    bool           wrap;
+} LayoutParam;
+
+}
+
+#endif

extensions/NdControls/NdCxList.cpp

@@ -0,0 +1,513 @@
+#include "../effects/CCGrid.h"
+#include "NdCxList.h"
+
+namespace NdCxControl 
+{
+    #define FLOAT_EQUAL(x,y)    (fabs((x)-(y)) < 0.0001f)
+
+    NdCxList::NdCxList(float row_height, ccColor4B bg_color, CCSize size) 
+          : sel_item_(NULL)
+          , row_height_(row_height)
+          , old_y_(0.f)
+          , min_y_(0.f)
+          , max_y_(0.f)
+          , touch_began_y_(0.f)
+          , touch_ended_y_(0.f)
+          , snap_flag_(false)
+          , list_state_(LS_WAITING)
+          , item_click_listener_(NULL)
+    {
+        if (size.width <= 0 || size.height <= 0)
+        {
+            size = CCDirector::sharedDirector()->getWinSize();
+        }
+
+        initWithColorWidthHeight(bg_color, size.width, size.height);
+
+        inner_panel_ = CCLayer::node();
+        inner_panel_->setPosition(CCPointZero);
+        inner_panel_->setContentSize(size);
+        CCLayerColor::addChild(inner_panel_);
+
+        line_color_ = ccc3(0xBD, 0xBD, 0xBD);
+        sel_item_end_color_ = ccc3(0, 0xFF, 0xFF);
+        sel_item_start_color_ = ccc3(0xFF, 0xFF, 0);
+    }
+
+    NdCxList::~NdCxList(void) 
+    {
+        inner_panel_->removeAllChildrenWithCleanup(true);
+    }
+
+    int NdCxList::addChild(NdCxListItem *item, bool scroll_to_view)
+    {
+        inner_panel_->addChild(item);
+        item->release();
+
+        CCArray *children = inner_panel_->getChildren();
+        int item_count = children->count();
+        if (1 == item_count)
+        {
+            item->setDrawTopLine(true);
+        }
+
+        CCSize panel_size = inner_panel_->getContentSize();
+
+        item->setLineColor(line_color_);
+        item->setSelectedColor(sel_item_start_color_, sel_item_end_color_);
+        item->initWithWidthHeight(panel_size.width, row_height_);
+        item->requestLayout();
+
+        // 计算位置，item的高度可能在调用requestLayout后有所变化
+        float item_y_pos = 0.f;
+        CCSize item_size = item->getContentSize();
+        if (item_count > 1)
+        {
+            CCNode *last_child = (CCNode *)children->objectAtIndex(item_count - 2);
+            item_y_pos = last_child->getPosition().y - item_size.height;
+        }
+        else
+        {
+            item_y_pos = panel_size.height - item_size.height;
+        }
+
+        item->setPosition(CCPointMake(0, item_y_pos));
+
+        float total_height = 0.f;
+        for (int i = 0; i < (int)children->count(); ++i)
+        {
+            total_height += ((CCNode *)children->objectAtIndex(i))->getContentSize().height;
+        }
+
+        if (total_height > panel_size.height)
+        {
+            max_y_ = total_height - panel_size.height;
+        }
+        else
+        {
+            max_y_ = 0;
+        }
+
+        int rst = children->count() - 1;
+        if (scroll_to_view && (rst + 1) * row_height_ > panel_size.height)
+        {
+            doFitPos(max_y_);
+        }
+
+        return rst;
+    }
+
+    NdCxListItem *NdCxList::getChild(int row_index)
+    {
+        return (NdCxListItem *)inner_panel_->getChildren()->objectAtIndex(row_index);
+    }
+
+    void NdCxList::clear(void)
+    {
+        inner_panel_->removeAllChildrenWithCleanup(true);
+        sel_item_ = NULL;
+        old_y_ = 0.f;
+        min_y_ = 0.f;
+        max_y_ = 0.f;
+        touch_began_y_ = 0.f;
+        touch_ended_y_ = 0.f;
+        snap_flag_ = false;
+        list_state_ = LS_WAITING;
+        inner_panel_->setPosition(CCPointZero);
+    }
+    
+    void NdCxList::onEnter(void)
+    {
+        setIsTouchEnabled(true);
+        CCLayerColor::onEnter();
+    }
+
+    void NdCxList::onExit(void)
+    {
+        setIsTouchEnabled(false);
+        CCLayerColor::onExit();
+    }
+
+    void NdCxList::registerWithTouchDispatcher()
+    {
+        CCTouchDispatcher::sharedDispatcher()->addTargetedDelegate(this, INT_MIN+9999, false);
+    }
+
+    bool NdCxList::ccTouchBegan(CCTouch* touch, CCEvent* event)
+    {
+        if (!containsTouchLocation(touch) || !getIsVisible())
+        {
+            return false;
+        }
+
+        CCArray *children = inner_panel_->getChildren();
+        if (LS_WAITING != list_state_ || !m_bIsVisible || !children)
+        {
+            return false;
+        }
+
+        list_state_ = LS_TRACKINGTOUCH;
+        CCPoint touchPoint = touch->locationInView(touch->view());
+        old_y_ = inner_panel_->getPosition().y;
+        touch_began_y_ = touch_ended_y_ = CCDirector::sharedDirector()->convertToGL(touchPoint).y;
+        
+        snap_flag_ = true;
+
+        NdCxListItem *sel_item = itemForTouch(touch);
+        if (sel_item && sel_item != sel_item_)
+        {
+            sel_item->selected();
+            if (sel_item_)
+            {
+                sel_item_->unselected();
+            }
+        }
+        
+        sel_item_ = sel_item;
+
+        //CCTime::gettimeofdayCocos2d(&touch_began_time_, NULL);
+        touch_began_time_ = clock();
+
+        return true;
+    }
+
+    void NdCxList::doFitPos(float y_pos)
+    {
+        inner_panel_->stopAllActions();
+
+        CCMoveTo *move_to = new CCMoveTo();
+        move_to->initWithDuration(0.66f, CCPointMake(0, y_pos));
+        CCEaseExponentialOut *ease_action = new CCEaseExponentialOut();
+        ease_action->initWithAction(move_to);
+        move_to->release();
+        inner_panel_->runAction(ease_action);
+        ease_action->release();
+    }
+
+    void NdCxList::ccTouchEnded(CCTouch* touch, CCEvent* event)
+    {
+        if (LS_TRACKINGTOUCH != list_state_)
+        {
+            return;
+        }
+
+        if (sel_item_)
+        {
+            if (FLOAT_EQUAL(touch_began_y_, touch_ended_y_))
+            {
+                if (item_click_listener_)
+                {
+                    item_click_listener_->onClick(
+                        inner_panel_->getChildren()->indexOfObject(sel_item_), sel_item_);
+                }
+#ifdef  ENABLE_LUA
+				else if (m_scriptSeletor.size())
+				{
+					CCLuaScriptModule::sharedLuaScriptModule()->executeListItem(m_scriptSeletor,
+						inner_panel_->getChildren()->indexOfObject(sel_item_), sel_item_);
+				}
+#endif
+
+                onItemClick(inner_panel_->getChildren()->indexOfObject(sel_item_), sel_item_);
+            }           
+        }
+
+        // 如果超出范围，则反弹回去。
+        CCPoint pos = inner_panel_->getPosition();
+        if (FLOAT_EQUAL(min_y_, max_y_))
+        {
+            if (!FLOAT_EQUAL(pos.y, 0.f))
+            {
+                doFitPos(0.f);
+            }
+        }
+        else
+        {
+            if (pos.y < min_y_)
+            {
+                doFitPos(min_y_);
+            }
+            else if (pos.y > max_y_)
+            {
+                doFitPos(max_y_);
+            }
+            else
+            {
+                if (!FLOAT_EQUAL(touch_began_y_, touch_ended_y_))
+                {
+                    float acce_val = 0.f;
+                    float fit_pos = inner_panel_->getPosition().y;
+                    float abs_distance = fabs(touch_ended_y_ - touch_began_y_);
+
+                    /*cc_timeval end_time, sub_time;
+                    CCTime::gettimeofdayCocos2d(&end_time, NULL);
+                    CCTime::timersubCocos2d(&sub_time, &touch_began_time_, &end_time);
+                    int time_consume = sub_time.tv_sec * 1000 + sub_time.tv_usec/1000;*/
+                    int time_consume = clock() - touch_began_time_;
+                    if (time_consume < 400 && abs_distance > row_height_)
+                    {
+                        acce_val = (abs_distance / row_height_) * 3.f * row_height_;
+                    }
+                    else
+                    {
+                        acce_val = float((int)row_height_ / 3);
+                    }                    
+
+                    // 向下拖拽
+                    if (touch_began_y_ > touch_ended_y_)
+                    {
+                        fit_pos -= acce_val;
+                        if (fit_pos < min_y_)
+                        {
+                            fit_pos = min_y_;
+                        }
+                    }
+                    else
+                    {
+                        fit_pos += acce_val;
+                        if (fit_pos > max_y_)
+                        {
+                            fit_pos = max_y_;
+                        }
+                    }
+
+                    doFitPos(fit_pos);
+                }
+            }
+        }
+
+        list_state_ = LS_WAITING;
+    }
+
+    void NdCxList::ccTouchCancelled(CCTouch *touch, CCEvent *event)
+    {
+        list_state_ = LS_WAITING;
+    }
+
+    void NdCxList::ccTouchMoved(CCTouch* touch, CCEvent* event)
+    {
+        if (LS_TRACKINGTOUCH != list_state_)
+        {
+            return;
+        }
+
+        CCPoint touchPoint = touch->locationInView(touch->view());
+        touchPoint = CCDirector::sharedDirector()->convertToGL(touchPoint);         
+        touch_ended_y_ = touchPoint.y;
+
+        if (snap_flag_ && fabs(touch_ended_y_ - touch_began_y_) < 15.f)
+        {
+            return;
+        }
+
+        snap_flag_ = false;
+        
+        inner_panel_->setPosition(CCPointMake(inner_panel_->getPosition().x, 
+            old_y_ + (touch_ended_y_ - touch_began_y_)));
+    }
+
+    void NdCxList::destroy(void)
+    {
+        release();
+    }
+
+    void NdCxList::keep(void)
+    {
+        retain();
+    }
+
+    NdCxListItem* NdCxList::itemForTouch(CCTouch * touch)
+    {
+        CCArray *children = inner_panel_->getChildren();
+        if (!children || !children->count())
+        {
+            return NULL;
+        }
+
+        CCPoint touch_loc = touch->locationInView(touch->view());
+        touch_loc = CCDirector::sharedDirector()->convertToGL(touch_loc);
+        CCPoint local_loc = inner_panel_->convertToNodeSpace(touch_loc);
+
+        for (int i = 0, l = (int)children->count(); i != l; ++i)
+        {
+            CCNode *node = (CCNode *)children->objectAtIndex(i);
+            if (CCRect::CCRectContainsPoint(node->boundingBox(), local_loc))
+            {
+                return (NdCxListItem*)node;
+            }
+        }
+        
+        return NULL;
+    }
+
+    void NdCxList::selectChild(int row_index)
+    {
+        CCArray *children = inner_panel_->getChildren();
+        if (!children || !children->count() || row_index < 0 || row_index >= (int)children->count())
+        {
+            return;
+        }
+
+        NdCxListItem *sel_item = (NdCxListItem *)children->objectAtIndex(row_index);
+        if (sel_item != sel_item_)
+        {
+            sel_item->selected();
+
+            if (sel_item_)
+            {
+                sel_item_->unselected();
+            }
+
+            sel_item_ = sel_item;
+
+            CCSize panel_size = inner_panel_->getContentSize();
+            CCArray *children = inner_panel_->getChildren();
+            float inc_height = 0.f;
+            for (int i = 0; i <= row_index; ++i)
+            {
+                inc_height += ((CCNode *)children->objectAtIndex(i))->getContentSize().height;
+            }
+
+            if (inc_height > panel_size.height)
+            {
+                doFitPos(inc_height - panel_size.height);
+            }
+        }
+    }
+
+    NdCxListItem *NdCxList::getSelectedChild(void)
+    {
+        return sel_item_;
+    }
+
+    void NdCxList::setLineColor(ccColor3B &color)
+    {
+        line_color_ = color;
+    }
+
+    void NdCxList::setSelectedItemColor(ccColor3B &start_color, ccColor3B &end_color)
+    {
+        sel_item_start_color_ = start_color;
+        sel_item_end_color_ = end_color;
+    }
+
+    int NdCxList::getChildCount(void)
+    {
+        CCArray *children = inner_panel_->getChildren();
+        if (!children)
+        {
+            return 0;
+        }
+        else
+        {
+            return children->count();
+        }
+    }
+
+    void NdCxList::setRowHeight(float height)
+    {
+        row_height_ = height;
+    }
+
+    float NdCxList::getRowHeight(void)
+    {
+        return row_height_;
+    }
+
+    void NdCxList::registerItemClickListener(NdCxListItemClickListener *listener)
+    {
+        item_click_listener_ = listener;
+    }
+
+    void NdCxList::unregisterItemClickListener(void)
+    {
+        item_click_listener_ = NULL;
+		
+#ifdef  ENABLE_LUA
+		m_scriptSeletor.clear();
+#endif
+    }
+#ifdef  ENABLE_LUA
+	void NdCxList::registerItemClickListener(const char* szSeletor)
+	{
+		if (szSeletor)
+		{
+			m_scriptSeletor = szSeletor;
+		}
+		else
+		{
+			CCLog("registerItemClickListener Error szSelector == null");
+		}
+	}
+#endif
+
+    void NdCxList::visit(void)
+    {
+        // quick return if not visible
+        if (!m_bIsVisible)
+        {
+            return;
+        }
+        glPushMatrix();
+
+        /*if (m_pGrid && m_pGrid->isActive())
+        {
+            m_pGrid->beforeDraw();
+            this->transformAncestors();
+        }*/
+
+        this->transform();
+
+        CCNode* pNode = NULL;
+        unsigned int i = 0;
+
+        if(m_pChildren && m_pChildren->count() > 0)
+        {
+            // draw children zOrder < 0
+            ccArray *arrayData = m_pChildren->data;
+            for( ; i < arrayData->num; i++ )
+            {
+                pNode = (CCNode*) arrayData->arr[i];
+
+                if ( pNode && pNode->getZOrder() < 0 ) 
+                {
+                    pNode->visit();
+                }
+                else
+                {
+                    break;
+                }
+            }
+        }
+
+        // self draw
+        this->draw();
+
+        // 左下角世界坐标
+        CCPoint world_pt = convertToWorldSpace(CCPointZero);
+        CCPoint ui_pt = CCDirector::sharedDirector()->convertToUI(world_pt);
+        CCPoint gl_pt = CCDirector::sharedDirector()->convertToGL(ui_pt);
+
+        glEnable(GL_SCISSOR_TEST);
+        glScissor((GLsizei)gl_pt.x, (GLsizei)gl_pt.y, (GLsizei)m_tContentSize.width, (GLsizei)m_tContentSize.height);
+
+        // draw children zOrder >= 0
+        if (m_pChildren && m_pChildren->count() > 0)
+        {
+            ccArray *arrayData = m_pChildren->data;
+            for( ; i < arrayData->num; i++ )
+            {
+                pNode = (CCNode*) arrayData->arr[i];
+                if (pNode)
+                {
+                    pNode->visit();
+                }
+            }		
+        }
+
+        glDisable(GL_SCISSOR_TEST);
+
+        glPopMatrix();
+    }
+}
+

extensions/NdControls/NdCxList.h

@@ -0,0 +1,109 @@
+#ifndef __NDCX_LIST_H__
+#define __NDCX_LIST_H__
+
+#include <time.h>
+#include "../platform/platform.h"
+#include "NdCxListItem.h"
+#include <vector>
+using namespace cocos2d;
+namespace NdCxControl 
+{
+	class NdCxListItem;
+    typedef enum  
+    {
+        LS_WAITING,
+        LS_TRACKINGTOUCH,
+    } LIST_STATE;
+
+    struct NdCxListItemClickListener
+    {
+		virtual void onClick(int index, NdCxListItem *item) = 0;
+    };
+
+    class NdCxList : public CCLayerColor
+    {
+    public:
+        NdCxList(float row_height, 
+                 ccColor4B bg_color, 
+                 CCSize size);
+        virtual ~NdCxList(void);
+
+    public:
+        int addChild(NdCxListItem *item, bool scroll_to_view);
+        NdCxListItem *getChild(int row_index);
+        void clear(void);
+        
+        void selectChild(int row_index);
+
+        NdCxListItem *getSelectedChild(void);
+
+        void setLineColor(ccColor3B &color);
+        void setSelectedItemColor(ccColor3B &start_color, ccColor3B &end_color);
+        int getChildCount(void);
+        
+        // ±ØÐëÔÚÌí¼Óitem֮ǰµ÷ÓÃ
+        void setRowHeight(float height);
+        float getRowHeight(void);
+        
+    public:
+        virtual void onEnter(void);
+        virtual void onExit(void);
+        virtual void registerWithTouchDispatcher(void);
+        virtual bool ccTouchBegan(CCTouch* touch, CCEvent* event);
+        virtual void ccTouchEnded(CCTouch* touch, CCEvent* event);
+        virtual void ccTouchCancelled(CCTouch *touch, CCEvent* event);
+        virtual void ccTouchMoved(CCTouch* touch, CCEvent* event);
+        virtual void destroy(void);
+        virtual void keep(void);
+
+        virtual void registerItemClickListener(NdCxListItemClickListener *listener);
+        virtual void unregisterItemClickListener(void);
+#ifdef  ENABLE_LUA
+		virtual void registerItemClickListener(const char* szSeletor);
+#endif
+
+    protected:
+        virtual void onItemClick(int index, NdCxListItem *item) {}
+        virtual void visit(void);
+
+    private:
+        NdCxListItem *itemForTouch(CCTouch * touch);
+        void doLayout(void);
+        void doFitPos(float y_pos);
+        
+        CCRect rect(void)
+        {
+            CCSize s = getContentSize();
+            return CCRectMake(-s.width / 2, -s.height / 2, s.width, s.height);
+        }
+
+        bool containsTouchLocation(CCTouch* touch)
+        {
+            return CCRect::CCRectContainsPoint(rect(), convertTouchToNodeSpaceAR(touch));
+        }
+
+    private:
+        NdCxListItem *sel_item_;
+        float row_height_;
+        LIST_STATE list_state_;
+        CCLayer *inner_panel_;
+        float touch_began_y_;
+        float touch_ended_y_;
+        float old_y_;
+        float min_y_;
+        float max_y_;
+        bool snap_flag_;
+        //cc_timeval touch_began_time_;
+        clock_t touch_began_time_;
+        ccColor3B line_color_;
+        ccColor3B sel_item_start_color_;
+        ccColor3B sel_item_end_color_;
+
+        NdCxListItemClickListener *item_click_listener_;
+#ifdef  ENABLE_LUA
+		std::string m_scriptSeletor;
+#endif
+    };
+}
+
+#endif

extensions/NdControls/NdCxListItem.cpp

@@ -0,0 +1,363 @@
+
+#include "NdCxListItem.h"
+
+namespace NdCxControl 
+{
+    NdCxListItem::NdCxListItem(void) 
+              : selected_(false)
+              , draw_top_line_(false)
+              , draw_bottom_line_(true)
+              , horizontal_margin_(10.f)
+              , vertical_margin_(10.f)
+    {
+    }
+    
+    NdCxListItem::~NdCxListItem(void) 
+    {
+    }
+    
+    void NdCxListItem::updateColor(void)
+    {
+        const unsigned int l = sizeof(m_pSquareColors) / sizeof(m_pSquareColors[0]);
+
+        if (selected_)
+        {
+            ccColor3B color = sel_item_start_color_;
+            const unsigned int half = l / 2;
+            for (unsigned int i=0; i < l; ++i)
+            {
+                if (i >= half)
+                {
+                    color = sel_item_end_color_;
+                }
+
+                if (i % 4 == 0)
+                    m_pSquareColors[i] = color.r;
+                else if (i % 4 == 1)
+                    m_pSquareColors[i] = color.g;
+                else if (i % 4 ==2)
+                    m_pSquareColors[i] = color.b;
+                else
+                    m_pSquareColors[i] = m_cOpacity;
+            }
+        }
+        else
+        {
+            for( unsigned int i=0; i < 4; i++ )
+            {
+                m_pSquareColors[i * 4]     = m_tColor.r;
+                m_pSquareColors[i * 4 + 1] = m_tColor.g;
+                m_pSquareColors[i * 4 + 2] = m_tColor.b;
+                m_pSquareColors[i * 4 + 3] = m_cOpacity;
+            }
+        }
+    }
+
+    void NdCxListItem::draw(void)
+    {
+        updateColor();
+
+        CCSize size = getContentSize();
+        if (selected_)
+        {
+            glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+            glDisable(GL_TEXTURE_2D);
+            glShadeModel(GL_SMOOTH);
+
+            glVertexPointer(2, GL_FLOAT, 0, m_pSquareVertices);
+            glColorPointer(4, GL_UNSIGNED_BYTE, 0, m_pSquareColors);
+
+            bool newBlend = false;
+            if( m_tBlendFunc.src != CC_BLEND_SRC || m_tBlendFunc.dst != CC_BLEND_DST ) {
+                newBlend = true;
+                glBlendFunc(m_tBlendFunc.src, m_tBlendFunc.dst);
+            }
+            else if( m_cOpacity != 255 ) {
+                newBlend = true;
+                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            }
+
+            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+            if( newBlend )
+                glBlendFunc(CC_BLEND_SRC, CC_BLEND_DST);
+
+            // restore default GL state
+            glShadeModel(GL_FLAT);
+            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+            glEnable(GL_TEXTURE_2D);
+        }
+        else
+        {
+            CCLayerColor::draw();
+        }
+        
+        glDisable(GL_LINE_SMOOTH);
+
+        if (draw_top_line_)
+        {
+            glLineWidth(1.0f);
+            glColor4ub(line_color_.r, line_color_.g, line_color_.b, 0xFF);
+            ccDrawLine(CCPointMake(0, size.height-0.5f), CCPointMake(size.width, size.height-0.5f));
+        }
+
+        if (draw_bottom_line_)
+        {
+            glLineWidth(1.0f);
+            glColor4ub(line_color_.r, line_color_.g, line_color_.b, 0xFF);
+            ccDrawLine(CCPointMake(0, 0.5f), CCPointMake(size.width, 0.5f));
+        }
+    }
+
+    CCRect NdCxListItem::rect(void)
+    {
+        return CCRectMake( m_tPosition.x - m_tContentSize.width * m_tAnchorPoint.x, 
+            m_tPosition.y - m_tContentSize.height * m_tAnchorPoint.y,
+            m_tContentSize.width, m_tContentSize.height);
+    }
+    
+    void NdCxListItem::selected(void)
+    {
+        selected_ = true;
+    }
+
+    void NdCxListItem::unselected(void)
+    {
+        selected_ = false;
+    }
+
+    void NdCxListItem::setItemColor(const ccColor3B &color)
+    {
+        setColor(color);
+    }
+
+    void NdCxListItem::setMargin(CCSize margin)
+    {
+        horizontal_margin_ = margin.width;
+        vertical_margin_ = margin.height;
+    }
+
+    CCSize NdCxListItem::getMargin(void)
+    {
+        return CCSizeMake(horizontal_margin_, vertical_margin_);
+    }
+
+    void NdCxListItem::addChild(NdCxListItemChild *child, const LayoutParam &layout)
+    {
+        addChild(child, layout, 0);
+    }
+
+    void NdCxListItem::addChild(NdCxListItemChild *child, const LayoutParam &layout, int tag)
+    {
+        layout_info_.insert(std::make_pair(child, layout));
+        child->setIsRelativeAnchorPoint(false);
+        CCLayerColor::addChild(child, 0, tag);
+        child->release();
+    }
+
+    NdCxListItemChild *NdCxListItem::getChildByTag(int tag)
+    {
+        return (NdCxListItemChild *)CCLayerColor::getChildByTag(tag);
+    }
+
+    void NdCxListItem::requestLayout(void)
+    {
+        if (m_pChildren && m_pChildren->count() > 0)
+        {
+            CCPoint child_pos;
+            CCSize size = getContentSize();
+            CCPoint curr_pos;
+            CCPoint prev_pos;
+            float vertical_height = size.height;
+            bool height_changed = false;
+
+            for (int i = 0, l = m_pChildren->count(); i < l; ++i)
+            {
+                CCNode *it = (CCNode *)m_pChildren->objectAtIndex(i);
+                if (!(it))
+                {
+                    break;
+                }
+
+                CCSize child_size = (*(it)).getContentSize();
+                child_size.width *= (*(it)).getScaleX();
+                child_size.height *= (*(it)).getScaleY();
+                
+                std::map<CCNode *, LayoutParam>::iterator pos = layout_info_.find(it);
+                CCAssert(layout_info_.end() != pos, "!!");
+                LayoutParam *lp = &pos->second;
+                switch ((*lp).val_x.t)
+                {
+                case PARENT_CENTER:
+                    child_pos.x = (size.width - child_size.width) / 2;
+                    break;
+                case HORIZONTAL_LEFT:
+                    child_pos.x = horizontal_margin_;
+                    break;
+                case HORIZONTAL_RIGHT:
+                    child_pos.x = size.width - child_size.width - horizontal_margin_;
+                    break;
+                case ABS_WITH_PIXEL:
+                    child_pos.x = (float)(*lp).val_x.val.pixel_val;
+                    break;
+                case ABS_WITH_PERCENT:
+                    child_pos.x = horizontal_margin_ + (*lp).val_x.val.percent_val * (size.width - 2*horizontal_margin_);
+                    break;
+                case REF_PREV_X_INC:
+                    {
+                        child_pos.x = prev_pos.x + (*lp).padding;
+                        break;
+                    }
+                case REF_PREV_X_DEC:
+                    {
+                        child_pos.x = prev_pos.x - (*lp).padding;
+                        break;
+                    }
+                case REL_FLOW:
+                    child_pos.x = curr_pos.x + (*lp).padding;
+                    break;
+                }
+
+                if (!(*lp).wrap)
+                {
+                    curr_pos.x = child_pos.x + child_size.width;
+                }
+
+                switch ((*lp).val_y.t)
+                {
+                case PARENT_CENTER:
+                    {
+                        if (child_size.height > vertical_height - 2*vertical_margin_)
+                        {
+                            vertical_height += child_size.height - (vertical_height - 2*vertical_margin_);
+                            height_changed = true;
+                        }
+
+                        child_pos.y = (vertical_height - child_size.height)*0.5f;
+
+                        break;
+                    }
+                case VERTICAL_TOP:
+                    {
+                        if (child_size.height > vertical_height - 2*vertical_margin_)
+                        {
+                            vertical_height += child_size.height - (vertical_height - 2*vertical_margin_);
+                            height_changed = true;
+                        }
+
+                        child_pos.y = vertical_height - (child_size.height + vertical_margin_);
+
+                        break;
+                    }
+                case VERTICAL_BOTTOM:
+                    {
+                        if (child_size.height > vertical_height - 2*vertical_margin_)
+                        {
+                            vertical_height += child_size.height - (vertical_height - 2*vertical_margin_);
+                            height_changed = true;
+                        }
+
+                        child_pos.y = vertical_margin_;
+
+                        break;
+                    }
+                case ABS_WITH_PIXEL:
+                    {
+                        child_pos.y = (float)(*lp).val_y.val.pixel_val;
+                        if (child_pos.y + child_size.height > vertical_height - vertical_margin_)
+                        {
+                            vertical_height = child_pos.y + child_size.height + vertical_margin_;
+                            height_changed = true;
+                        }
+
+                        break;
+                    }
+                case ABS_WITH_PERCENT:
+                    {
+                        child_pos.y = (*lp).val_y.val.percent_val * (vertical_height - 2*vertical_margin_);
+                        if (child_pos.y + child_size.height > vertical_height - vertical_margin_)
+                        {
+                            vertical_height = child_pos.y + child_size.height + vertical_margin_;
+                            height_changed = true;
+                        }
+
+                        break;
+                    }
+                case REF_PREV_Y_INC:
+                    {
+                        child_pos.y = prev_pos.y + (*lp).padding;
+                        if (child_pos.y + child_size.height > + vertical_height - vertical_margin_)
+                        {
+                            vertical_height = child_pos.y + child_size.height + vertical_margin_;
+                            height_changed = true;
+                        }
+
+                        break;
+                    }
+                case REF_PREV_Y_DEC:
+                    {
+                        child_pos.y = prev_pos.y - (child_size.height + (*lp).padding);
+                        if (child_pos.y < vertical_margin_)
+                        {
+                            vertical_height += vertical_margin_-child_pos.y + vertical_margin_;
+                            child_pos.y = vertical_margin_;
+                            height_changed = true;
+                        }
+                        
+                        break;
+                    }                    
+                case REL_FLOW:
+                    {
+                        child_pos.y = curr_pos.y + (*lp).padding;
+                        if (child_pos.y + child_size.height > vertical_height - vertical_margin_)
+                        {
+                            vertical_height = curr_pos.y + child_size.height + vertical_margin_;
+                            height_changed = true;
+                        }
+
+                        break;
+                    }
+
+                    curr_pos.y = child_pos.y + child_size.height;
+                }
+                
+                prev_pos = child_pos;
+
+                (*it).setPosition(child_pos);
+            }
+
+            setContentSize(CCSizeMake(size.width, vertical_height));
+
+            if (height_changed)
+            {
+                requestLayout();
+            }
+        }
+    }
+
+    NdCxListItem *NdCxListItem::itemWithColor(const ccColor3B &color)
+    {
+        NdCxListItem *pRet = new NdCxListItem();
+        pRet->setOpacity(255);
+        pRet->setColor(color);
+        return pRet;
+    }
+
+    bool NdCxListItem::initWithWidthHeight(GLfloat width, GLfloat height)
+    {
+        ccColor3B color = getColor();
+        ccColor4B cl4b = { color.r, color.g, color.b, getOpacity() };
+        return CCLayerColor::initWithColorWidthHeight(cl4b, width, height);
+    }
+
+    void NdCxListItem::setLineColor(const ccColor3B &color)
+    {
+        line_color_ = color;
+    }
+
+    void NdCxListItem::setSelectedColor(const ccColor3B &start_color, const ccColor3B &end_color)
+    {
+        sel_item_start_color_ = start_color;
+        sel_item_end_color_ = end_color;
+    }
+}

extensions/NdControls/NdCxListItem.h

@@ -0,0 +1,60 @@
+#ifndef __NDCX_LIST_ITEM_H_
+#define __NDCX_LIST_ITEM_H_
+
+#include "ControlDefine.h"
+#include "cocos2d.h"
+
+using namespace cocos2d;
+
+namespace NdCxControl {
+
+#define NdCxListItemChild CCNode
+
+class NdCxListItem : public CCLayerColor
+{
+    friend class NdCxList;
+protected:
+    NdCxListItem(void);
+    virtual ~NdCxListItem(void);
+
+public:
+    static NdCxListItem *itemWithColor(const ccColor3B &color);
+
+    CCRect rect(void);
+    void selected(void);
+    void unselected(void);
+    void setItemColor(const ccColor3B &color);
+    void setMargin(CCSize margin);
+    CCSize getMargin(void);
+
+public:
+    void addChild(NdCxListItemChild *child, const LayoutParam &layout);
+    void addChild(NdCxListItemChild *child, const LayoutParam &layout, int tag);
+    NdCxListItemChild *getChildByTag(int tag);
+    void setDrawTopLine(bool value) { draw_top_line_ = value; }
+    void setDrawBottomLine(bool value) { draw_bottom_line_ = value; }
+    
+protected:
+    bool initWithWidthHeight(GLfloat width, GLfloat height);
+    void requestLayout(void);
+    void setLineColor(const ccColor3B &color);
+    void setSelectedColor(const ccColor3B &start_color, const ccColor3B &end_color);
+    void updateColor(void);
+
+    virtual void draw(void);
+    
+private:
+    bool selected_;
+    ccColor3B line_color_;
+    ccColor3B sel_item_start_color_;
+    ccColor3B sel_item_end_color_;
+    bool draw_top_line_;
+    bool draw_bottom_line_;
+    std::map<CCNode *, LayoutParam> layout_info_;
+    float horizontal_margin_;
+    float vertical_margin_;
+};
+
+}
+
+#endif

lua/jni/Android.mk

@@ -0,0 +1,62 @@
+# Copyright (C) 2009 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE    := lua
+LOCAL_SRC_FILES :=../src/lapi.c \
+									../src/lauxlib.c \
+									../src/lbaselib.c \
+									../src/lcode.c \
+									../src/ldblib.c \
+									../src/ldebug.c \
+									../src/ldo.c \
+									../src/ldump.c \
+									../src/lfunc.c \
+									../src/lgc.c \
+									../src/linit.c \
+									../src/liolib.c \
+									../src/llex.c \
+									../src/lmathlib.c \
+									../src/lmem.c \
+									../src/loadlib.c \
+									../src/lobject.c \
+									../src/lopcodes.c \
+									../src/loslib.c \
+									../src/lparser.c \
+									../src/lstate.c \
+									../src/lstring.c \
+									../src/lstrlib.c \
+									../src/ltable.c \
+									../src/ltablib.c \
+									../src/ltm.c \
+									../src/lua.c \
+									../src/luac.c \
+									../src/lundump.c \
+									../src/lvm.c \
+									../src/lzio.c \
+									../src/print.c \
+									../tolua/tolua_event.c \
+									../tolua/tolua_is.c \
+									../tolua/tolua_map.c \
+									../tolua/tolua_push.c \
+									../tolua/tolua_to.c
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/ \
+                    $(LOCAL_PATH)/../src \
+                    $(LOCAL_PATH)/../tolua
+#LOCAL_PRELINK_MODULE := false
+
+include $(BUILD_STATIC_LIBRARY)

lua/lua.vcproj

@@ -0,0 +1,428 @@
+<?xml version="1.0" encoding="gb2312"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="liblua"
+	ProjectGUID="{A9376AC9-4D65-498F-885D-EEC3B41DD6E8}"
+	RootNamespace="lua"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName).win32"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="lua/tolua;./src"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath=".\src\lapi.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lauxlib.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lbaselib.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lcode.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\ldblib.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\ldebug.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\ldo.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\ldump.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lfunc.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lgc.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\linit.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\liolib.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\llex.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lmathlib.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lmem.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\loadlib.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lobject.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lopcodes.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\loslib.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lparser.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lstate.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lstring.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lstrlib.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\ltable.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\ltablib.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\ltm.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lua.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\luac.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lundump.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lvm.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lzio.c"
+				>
+			</File>
+			<File
+				RelativePath=".\src\print.c"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath=".\src\lapi.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lauxlib.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lcode.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\ldebug.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\ldo.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lfunc.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lgc.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\llex.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\llimits.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lmem.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lobject.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lopcodes.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lparser.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lstate.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lstring.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\ltable.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\ltm.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lua.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\luaconf.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lualib.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lundump.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lvm.h"
+				>
+			</File>
+			<File
+				RelativePath=".\src\lzio.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+		<Filter
+			Name="toLua"
+			>
+			<File
+				RelativePath=".\tolua\tolua_event.c"
+				>
+			</File>
+			<File
+				RelativePath=".\tolua\tolua_event.h"
+				>
+			</File>
+			<File
+				RelativePath=".\tolua\tolua_is.c"
+				>
+			</File>
+			<File
+				RelativePath=".\tolua\tolua_map.c"
+				>
+			</File>
+			<File
+				RelativePath=".\tolua\tolua_push.c"
+				>
+			</File>
+			<File
+				RelativePath=".\tolua\tolua_to.c"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

lua/src/Makefile

@@ -0,0 +1,182 @@
+# makefile for building Lua
+# see ../INSTALL for installation instructions
+# see ../Makefile and luaconf.h for further customization
+
+# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
+
+# Your platform. See PLATS for possible values.
+PLAT= none
+
+CC= gcc
+CFLAGS= -O2 -Wall $(MYCFLAGS)
+AR= ar rcu
+RANLIB= ranlib
+RM= rm -f
+LIBS= -lm $(MYLIBS)
+
+MYCFLAGS=
+MYLDFLAGS=
+MYLIBS=
+
+# == END OF USER SETTINGS. NO NEED TO CHANGE ANYTHING BELOW THIS LINE =========
+
+PLATS= aix ansi bsd freebsd generic linux macosx mingw posix solaris
+
+LUA_A=	liblua.a
+CORE_O=	lapi.o lcode.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o lmem.o \
+	lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o ltm.o  \
+	lundump.o lvm.o lzio.o
+LIB_O=	lauxlib.o lbaselib.o ldblib.o liolib.o lmathlib.o loslib.o ltablib.o \
+	lstrlib.o loadlib.o linit.o
+
+LUA_T=	lua
+LUA_O=	lua.o
+
+LUAC_T=	luac
+LUAC_O=	luac.o print.o
+
+ALL_O= $(CORE_O) $(LIB_O) $(LUA_O) $(LUAC_O)
+ALL_T= $(LUA_A) $(LUA_T) $(LUAC_T)
+ALL_A= $(LUA_A)
+
+default: $(PLAT)
+
+all:	$(ALL_T)
+
+o:	$(ALL_O)
+
+a:	$(ALL_A)
+
+$(LUA_A): $(CORE_O) $(LIB_O)
+	$(AR) $@ $?
+	$(RANLIB) $@
+
+$(LUA_T): $(LUA_O) $(LUA_A)
+	$(CC) -o $@ $(MYLDFLAGS) $(LUA_O) $(LUA_A) $(LIBS)
+
+$(LUAC_T): $(LUAC_O) $(LUA_A)
+	$(CC) -o $@ $(MYLDFLAGS) $(LUAC_O) $(LUA_A) $(LIBS)
+
+clean:
+	$(RM) $(ALL_T) $(ALL_O)
+
+depend:
+	@$(CC) $(CFLAGS) -MM l*.c print.c
+
+echo:
+	@echo "PLAT = $(PLAT)"
+	@echo "CC = $(CC)"
+	@echo "CFLAGS = $(CFLAGS)"
+	@echo "AR = $(AR)"
+	@echo "RANLIB = $(RANLIB)"
+	@echo "RM = $(RM)"
+	@echo "MYCFLAGS = $(MYCFLAGS)"
+	@echo "MYLDFLAGS = $(MYLDFLAGS)"
+	@echo "MYLIBS = $(MYLIBS)"
+
+# convenience targets for popular platforms
+
+none:
+	@echo "Please choose a platform:"
+	@echo "   $(PLATS)"
+
+aix:
+	$(MAKE) all CC="xlc" CFLAGS="-O2 -DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-ldl" MYLDFLAGS="-brtl -bexpall"
+
+ansi:
+	$(MAKE) all MYCFLAGS=-DLUA_ANSI
+
+bsd:
+	$(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-Wl,-E"
+
+freebsd:
+	$(MAKE) all MYCFLAGS="-DLUA_USE_LINUX" MYLIBS="-Wl,-E -lreadline"
+
+generic:
+	$(MAKE) all MYCFLAGS=
+
+linux:
+	$(MAKE) all MYCFLAGS=-DLUA_USE_LINUX MYLIBS="-Wl,-E -ldl -lreadline -lhistory -lncurses"
+
+macosx:
+	$(MAKE) all MYCFLAGS=-DLUA_USE_LINUX MYLIBS="-lreadline"
+# use this on Mac OS X 10.3-
+#	$(MAKE) all MYCFLAGS=-DLUA_USE_MACOSX
+
+mingw:
+	$(MAKE) "LUA_A=lua51.dll" "LUA_T=lua.exe" \
+	"AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \
+	"MYCFLAGS=-DLUA_BUILD_AS_DLL" "MYLIBS=" "MYLDFLAGS=-s" lua.exe
+	$(MAKE) "LUAC_T=luac.exe" luac.exe
+
+posix:
+	$(MAKE) all MYCFLAGS=-DLUA_USE_POSIX
+
+solaris:
+	$(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-ldl"
+
+# list targets that do not create files (but not all makes understand .PHONY)
+.PHONY: all $(PLATS) default o a clean depend echo none
+
+# DO NOT DELETE
+
+lapi.o: lapi.c lua.h luaconf.h lapi.h lobject.h llimits.h ldebug.h \
+  lstate.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h \
+  lundump.h lvm.h
+lauxlib.o: lauxlib.c lua.h luaconf.h lauxlib.h
+lbaselib.o: lbaselib.c lua.h luaconf.h lauxlib.h lualib.h
+lcode.o: lcode.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
+  lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h lgc.h \
+  ltable.h
+ldblib.o: ldblib.c lua.h luaconf.h lauxlib.h lualib.h
+ldebug.o: ldebug.c lua.h luaconf.h lapi.h lobject.h llimits.h lcode.h \
+  llex.h lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h \
+  lfunc.h lstring.h lgc.h ltable.h lvm.h
+ldo.o: ldo.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
+  lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lparser.h lstring.h \
+  ltable.h lundump.h lvm.h
+ldump.o: ldump.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h \
+  lzio.h lmem.h lundump.h
+lfunc.o: lfunc.c lua.h luaconf.h lfunc.h lobject.h llimits.h lgc.h lmem.h \
+  lstate.h ltm.h lzio.h
+lgc.o: lgc.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
+  lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h
+linit.o: linit.c lua.h luaconf.h lualib.h lauxlib.h
+liolib.o: liolib.c lua.h luaconf.h lauxlib.h lualib.h
+llex.o: llex.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h ltm.h \
+  lzio.h lmem.h llex.h lparser.h lstring.h lgc.h ltable.h
+lmathlib.o: lmathlib.c lua.h luaconf.h lauxlib.h lualib.h
+lmem.o: lmem.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
+  ltm.h lzio.h lmem.h ldo.h
+loadlib.o: loadlib.c lua.h luaconf.h lauxlib.h lualib.h
+lobject.o: lobject.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h \
+  ltm.h lzio.h lmem.h lstring.h lgc.h lvm.h
+lopcodes.o: lopcodes.c lopcodes.h llimits.h lua.h luaconf.h
+loslib.o: loslib.c lua.h luaconf.h lauxlib.h lualib.h
+lparser.o: lparser.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
+  lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h \
+  lfunc.h lstring.h lgc.h ltable.h
+lstate.o: lstate.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
+  ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h llex.h lstring.h ltable.h
+lstring.o: lstring.c lua.h luaconf.h lmem.h llimits.h lobject.h lstate.h \
+  ltm.h lzio.h lstring.h lgc.h
+lstrlib.o: lstrlib.c lua.h luaconf.h lauxlib.h lualib.h
+ltable.o: ltable.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
+  ltm.h lzio.h lmem.h ldo.h lgc.h ltable.h
+ltablib.o: ltablib.c lua.h luaconf.h lauxlib.h lualib.h
+ltm.o: ltm.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h lzio.h \
+  lmem.h lstring.h lgc.h ltable.h
+lua.o: lua.c lua.h luaconf.h lauxlib.h lualib.h
+luac.o: luac.c lua.h luaconf.h lauxlib.h ldo.h lobject.h llimits.h \
+  lstate.h ltm.h lzio.h lmem.h lfunc.h lopcodes.h lstring.h lgc.h \
+  lundump.h
+lundump.o: lundump.c lua.h luaconf.h ldebug.h lstate.h lobject.h \
+  llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lstring.h lgc.h lundump.h
+lvm.o: lvm.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
+  lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h ltable.h lvm.h
+lzio.o: lzio.c lua.h luaconf.h llimits.h lmem.h lstate.h lobject.h ltm.h \
+  lzio.h
+print.o: print.c ldebug.h lstate.h lua.h luaconf.h lobject.h llimits.h \
+  ltm.h lzio.h lmem.h lopcodes.h lundump.h
+
+# (end of Makefile)

lua/src/lapi.h

@@ -0,0 +1,16 @@
+/*
+** $Id: lapi.h,v 2.2.1.1 2007/12/27 13:02:25 roberto Exp $
+** Auxiliary functions from Lua API
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lapi_h
+#define lapi_h
+
+
+#include "lobject.h"
+
+
+LUAI_FUNC void luaA_pushobject (lua_State *L, const TValue *o);
+
+#endif

lua/src/lauxlib.c

@@ -0,0 +1,652 @@
+/*
+** $Id: lauxlib.c,v 1.159.1.3 2008/01/21 13:20:51 roberto Exp $
+** Auxiliary functions for building Lua libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+/* This file uses only the official API of Lua.
+** Any function declared here could be written as an application function.
+*/
+
+#define lauxlib_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lauxlib.h"
+
+
+#define FREELIST_REF	0	/* free list of references */
+
+
+/* convert a stack index to positive */
+#define abs_index(L, i)		((i) > 0 || (i) <= LUA_REGISTRYINDEX ? (i) : \
+					lua_gettop(L) + (i) + 1)
+
+
+/*
+** {======================================================
+** Error-report functions
+** =======================================================
+*/
+
+
+LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {
+  lua_Debug ar;
+  if (!lua_getstack(L, 0, &ar))  /* no stack frame? */
+    return luaL_error(L, "bad argument #%d (%s)", narg, extramsg);
+  lua_getinfo(L, "n", &ar);
+  if (strcmp(ar.namewhat, "method") == 0) {
+    narg--;  /* do not count `self' */
+    if (narg == 0)  /* error is in the self argument itself? */
+      return luaL_error(L, "calling " LUA_QS " on bad self (%s)",
+                           ar.name, extramsg);
+  }
+  if (ar.name == NULL)
+    ar.name = "?";
+  return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)",
+                        narg, ar.name, extramsg);
+}
+
+
+LUALIB_API int luaL_typerror (lua_State *L, int narg, const char *tname) {
+  const char *msg = lua_pushfstring(L, "%s expected, got %s",
+                                    tname, luaL_typename(L, narg));
+  return luaL_argerror(L, narg, msg);
+}
+
+
+static void tag_error (lua_State *L, int narg, int tag) {
+  luaL_typerror(L, narg, lua_typename(L, tag));
+}
+
+
+LUALIB_API void luaL_where (lua_State *L, int level) {
+  lua_Debug ar;
+  if (lua_getstack(L, level, &ar)) {  /* check function at level */
+    lua_getinfo(L, "Sl", &ar);  /* get info about it */
+    if (ar.currentline > 0) {  /* is there info? */
+      lua_pushfstring(L, "%s:%d: ", ar.short_src, ar.currentline);
+      return;
+    }
+  }
+  lua_pushliteral(L, "");  /* else, no information available... */
+}
+
+
+LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) {
+  va_list argp;
+  va_start(argp, fmt);
+  luaL_where(L, 1);
+  lua_pushvfstring(L, fmt, argp);
+  va_end(argp);
+  lua_concat(L, 2);
+  return lua_error(L);
+}
+
+/* }====================================================== */
+
+
+LUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def,
+                                 const char *const lst[]) {
+  const char *name = (def) ? luaL_optstring(L, narg, def) :
+                             luaL_checkstring(L, narg);
+  int i;
+  for (i=0; lst[i]; i++)
+    if (strcmp(lst[i], name) == 0)
+      return i;
+  return luaL_argerror(L, narg,
+                       lua_pushfstring(L, "invalid option " LUA_QS, name));
+}
+
+
+LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
+  lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get registry.name */
+  if (!lua_isnil(L, -1))  /* name already in use? */
+    return 0;  /* leave previous value on top, but return 0 */
+  lua_pop(L, 1);
+  lua_newtable(L);  /* create metatable */
+  lua_pushvalue(L, -1);
+  lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */
+  return 1;
+}
+
+
+LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {
+  void *p = lua_touserdata(L, ud);
+  if (p != NULL) {  /* value is a userdata? */
+    if (lua_getmetatable(L, ud)) {  /* does it have a metatable? */
+      lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get correct metatable */
+      if (lua_rawequal(L, -1, -2)) {  /* does it have the correct mt? */
+        lua_pop(L, 2);  /* remove both metatables */
+        return p;
+      }
+    }
+  }
+  luaL_typerror(L, ud, tname);  /* else error */
+  return NULL;  /* to avoid warnings */
+}
+
+
+LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *mes) {
+  if (!lua_checkstack(L, space))
+    luaL_error(L, "stack overflow (%s)", mes);
+}
+
+
+LUALIB_API void luaL_checktype (lua_State *L, int narg, int t) {
+  if (lua_type(L, narg) != t)
+    tag_error(L, narg, t);
+}
+
+
+LUALIB_API void luaL_checkany (lua_State *L, int narg) {
+  if (lua_type(L, narg) == LUA_TNONE)
+    luaL_argerror(L, narg, "value expected");
+}
+
+
+LUALIB_API const char *luaL_checklstring (lua_State *L, int narg, size_t *len) {
+  const char *s = lua_tolstring(L, narg, len);
+  if (!s) tag_error(L, narg, LUA_TSTRING);
+  return s;
+}
+
+
+LUALIB_API const char *luaL_optlstring (lua_State *L, int narg,
+                                        const char *def, size_t *len) {
+  if (lua_isnoneornil(L, narg)) {
+    if (len)
+      *len = (def ? strlen(def) : 0);
+    return def;
+  }
+  else return luaL_checklstring(L, narg, len);
+}
+
+
+LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {
+  lua_Number d = lua_tonumber(L, narg);
+  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
+    tag_error(L, narg, LUA_TNUMBER);
+  return d;
+}
+
+
+LUALIB_API lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number def) {
+  return luaL_opt(L, luaL_checknumber, narg, def);
+}
+
+
+LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {
+  lua_Integer d = lua_tointeger(L, narg);
+  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
+    tag_error(L, narg, LUA_TNUMBER);
+  return d;
+}
+
+
+LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int narg,
+                                                      lua_Integer def) {
+  return luaL_opt(L, luaL_checkinteger, narg, def);
+}
+
+
+LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {
+  if (!lua_getmetatable(L, obj))  /* no metatable? */
+    return 0;
+  lua_pushstring(L, event);
+  lua_rawget(L, -2);
+  if (lua_isnil(L, -1)) {
+    lua_pop(L, 2);  /* remove metatable and metafield */
+    return 0;
+  }
+  else {
+    lua_remove(L, -2);  /* remove only metatable */
+    return 1;
+  }
+}
+
+
+LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
+  obj = abs_index(L, obj);
+  if (!luaL_getmetafield(L, obj, event))  /* no metafield? */
+    return 0;
+  lua_pushvalue(L, obj);
+  lua_call(L, 1, 1);
+  return 1;
+}
+
+
+LUALIB_API void (luaL_register) (lua_State *L, const char *libname,
+                                const luaL_Reg *l) {
+  luaI_openlib(L, libname, l, 0);
+}
+
+
+static int libsize (const luaL_Reg *l) {
+  int size = 0;
+  for (; l->name; l++) size++;
+  return size;
+}
+
+
+LUALIB_API void luaI_openlib (lua_State *L, const char *libname,
+                              const luaL_Reg *l, int nup) {
+  if (libname) {
+    int size = libsize(l);
+    /* check whether lib already exists */
+    luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 1);
+    lua_getfield(L, -1, libname);  /* get _LOADED[libname] */
+    if (!lua_istable(L, -1)) {  /* not found? */
+      lua_pop(L, 1);  /* remove previous result */
+      /* try global variable (and create one if it does not exist) */
+      if (luaL_findtable(L, LUA_GLOBALSINDEX, libname, size) != NULL)
+        luaL_error(L, "name conflict for module " LUA_QS, libname);
+      lua_pushvalue(L, -1);
+      lua_setfield(L, -3, libname);  /* _LOADED[libname] = new table */
+    }
+    lua_remove(L, -2);  /* remove _LOADED table */
+    lua_insert(L, -(nup+1));  /* move library table to below upvalues */
+  }
+  for (; l->name; l++) {
+    int i;
+    for (i=0; i<nup; i++)  /* copy upvalues to the top */
+      lua_pushvalue(L, -nup);
+    lua_pushcclosure(L, l->func, nup);
+    lua_setfield(L, -(nup+2), l->name);
+  }
+  lua_pop(L, nup);  /* remove upvalues */
+}
+
+
+
+/*
+** {======================================================
+** getn-setn: size for arrays
+** =======================================================
+*/
+
+#if defined(LUA_COMPAT_GETN)
+
+static int checkint (lua_State *L, int topop) {
+  int n = (lua_type(L, -1) == LUA_TNUMBER) ? lua_tointeger(L, -1) : -1;
+  lua_pop(L, topop);
+  return n;
+}
+
+
+static void getsizes (lua_State *L) {
+  lua_getfield(L, LUA_REGISTRYINDEX, "LUA_SIZES");
+  if (lua_isnil(L, -1)) {  /* no `size' table? */
+    lua_pop(L, 1);  /* remove nil */
+    lua_newtable(L);  /* create it */
+    lua_pushvalue(L, -1);  /* `size' will be its own metatable */
+    lua_setmetatable(L, -2);
+    lua_pushliteral(L, "kv");
+    lua_setfield(L, -2, "__mode");  /* metatable(N).__mode = "kv" */
+    lua_pushvalue(L, -1);
+    lua_setfield(L, LUA_REGISTRYINDEX, "LUA_SIZES");  /* store in register */
+  }
+}
+
+
+LUALIB_API void luaL_setn (lua_State *L, int t, int n) {
+  t = abs_index(L, t);
+  lua_pushliteral(L, "n");
+  lua_rawget(L, t);
+  if (checkint(L, 1) >= 0) {  /* is there a numeric field `n'? */
+    lua_pushliteral(L, "n");  /* use it */
+    lua_pushinteger(L, n);
+    lua_rawset(L, t);
+  }
+  else {  /* use `sizes' */
+    getsizes(L);
+    lua_pushvalue(L, t);
+    lua_pushinteger(L, n);
+    lua_rawset(L, -3);  /* sizes[t] = n */
+    lua_pop(L, 1);  /* remove `sizes' */
+  }
+}
+
+
+LUALIB_API int luaL_getn (lua_State *L, int t) {
+  int n;
+  t = abs_index(L, t);
+  lua_pushliteral(L, "n");  /* try t.n */
+  lua_rawget(L, t);
+  if ((n = checkint(L, 1)) >= 0) return n;
+  getsizes(L);  /* else try sizes[t] */
+  lua_pushvalue(L, t);
+  lua_rawget(L, -2);
+  if ((n = checkint(L, 2)) >= 0) return n;
+  return (int)lua_objlen(L, t);
+}
+
+#endif
+
+/* }====================================================== */
+
+
+
+LUALIB_API const char *luaL_gsub (lua_State *L, const char *s, const char *p,
+                                                               const char *r) {
+  const char *wild;
+  size_t l = strlen(p);
+  luaL_Buffer b;
+  luaL_buffinit(L, &b);
+  while ((wild = strstr(s, p)) != NULL) {
+    luaL_addlstring(&b, s, wild - s);  /* push prefix */
+    luaL_addstring(&b, r);  /* push replacement in place of pattern */
+    s = wild + l;  /* continue after `p' */
+  }
+  luaL_addstring(&b, s);  /* push last suffix */
+  luaL_pushresult(&b);
+  return lua_tostring(L, -1);
+}
+
+
+LUALIB_API const char *luaL_findtable (lua_State *L, int idx,
+                                       const char *fname, int szhint) {
+  const char *e;
+  lua_pushvalue(L, idx);
+  do {
+    e = strchr(fname, '.');
+    if (e == NULL) e = fname + strlen(fname);
+    lua_pushlstring(L, fname, e - fname);
+    lua_rawget(L, -2);
+    if (lua_isnil(L, -1)) {  /* no such field? */
+      lua_pop(L, 1);  /* remove this nil */
+      lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */
+      lua_pushlstring(L, fname, e - fname);
+      lua_pushvalue(L, -2);
+      lua_settable(L, -4);  /* set new table into field */
+    }
+    else if (!lua_istable(L, -1)) {  /* field has a non-table value? */
+      lua_pop(L, 2);  /* remove table and value */
+      return fname;  /* return problematic part of the name */
+    }
+    lua_remove(L, -2);  /* remove previous table */
+    fname = e + 1;
+  } while (*e == '.');
+  return NULL;
+}
+
+
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+
+#define bufflen(B)	((B)->p - (B)->buffer)
+#define bufffree(B)	((size_t)(LUAL_BUFFERSIZE - bufflen(B)))
+
+#define LIMIT	(LUA_MINSTACK/2)
+
+
+static int emptybuffer (luaL_Buffer *B) {
+  size_t l = bufflen(B);
+  if (l == 0) return 0;  /* put nothing on stack */
+  else {
+    lua_pushlstring(B->L, B->buffer, l);
+    B->p = B->buffer;
+    B->lvl++;
+    return 1;
+  }
+}
+
+
+static void adjuststack (luaL_Buffer *B) {
+  if (B->lvl > 1) {
+    lua_State *L = B->L;
+    int toget = 1;  /* number of levels to concat */
+    size_t toplen = lua_strlen(L, -1);
+    do {
+      size_t l = lua_strlen(L, -(toget+1));
+      if (B->lvl - toget + 1 >= LIMIT || toplen > l) {
+        toplen += l;
+        toget++;
+      }
+      else break;
+    } while (toget < B->lvl);
+    lua_concat(L, toget);
+    B->lvl = B->lvl - toget + 1;
+  }
+}
+
+
+LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) {
+  if (emptybuffer(B))
+    adjuststack(B);
+  return B->buffer;
+}
+
+
+LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
+  while (l--)
+    luaL_addchar(B, *s++);
+}
+
+
+LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) {
+  luaL_addlstring(B, s, strlen(s));
+}
+
+
+LUALIB_API void luaL_pushresult (luaL_Buffer *B) {
+  emptybuffer(B);
+  lua_concat(B->L, B->lvl);
+  B->lvl = 1;
+}
+
+
+LUALIB_API void luaL_addvalue (luaL_Buffer *B) {
+  lua_State *L = B->L;
+  size_t vl;
+  const char *s = lua_tolstring(L, -1, &vl);
+  if (vl <= bufffree(B)) {  /* fit into buffer? */
+    memcpy(B->p, s, vl);  /* put it there */
+    B->p += vl;
+    lua_pop(L, 1);  /* remove from stack */
+  }
+  else {
+    if (emptybuffer(B))
+      lua_insert(L, -2);  /* put buffer before new value */
+    B->lvl++;  /* add new value into B stack */
+    adjuststack(B);
+  }
+}
+
+
+LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {
+  B->L = L;
+  B->p = B->buffer;
+  B->lvl = 0;
+}
+
+/* }====================================================== */
+
+
+LUALIB_API int luaL_ref (lua_State *L, int t) {
+  int ref;
+  t = abs_index(L, t);
+  if (lua_isnil(L, -1)) {
+    lua_pop(L, 1);  /* remove from stack */
+    return LUA_REFNIL;  /* `nil' has a unique fixed reference */
+  }
+  lua_rawgeti(L, t, FREELIST_REF);  /* get first free element */
+  ref = (int)lua_tointeger(L, -1);  /* ref = t[FREELIST_REF] */
+  lua_pop(L, 1);  /* remove it from stack */
+  if (ref != 0) {  /* any free element? */
+    lua_rawgeti(L, t, ref);  /* remove it from list */
+    lua_rawseti(L, t, FREELIST_REF);  /* (t[FREELIST_REF] = t[ref]) */
+  }
+  else {  /* no free elements */
+    ref = (int)lua_objlen(L, t);
+    ref++;  /* create new reference */
+  }
+  lua_rawseti(L, t, ref);
+  return ref;
+}
+
+
+LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {
+  if (ref >= 0) {
+    t = abs_index(L, t);
+    lua_rawgeti(L, t, FREELIST_REF);
+    lua_rawseti(L, t, ref);  /* t[ref] = t[FREELIST_REF] */
+    lua_pushinteger(L, ref);
+    lua_rawseti(L, t, FREELIST_REF);  /* t[FREELIST_REF] = ref */
+  }
+}
+
+
+
+/*
+** {======================================================
+** Load functions
+** =======================================================
+*/
+
+typedef struct LoadF {
+  int extraline;
+  FILE *f;
+  char buff[LUAL_BUFFERSIZE];
+} LoadF;
+
+
+static const char *getF (lua_State *L, void *ud, size_t *size) {
+  LoadF *lf = (LoadF *)ud;
+  (void)L;
+  if (lf->extraline) {
+    lf->extraline = 0;
+    *size = 1;
+    return "\n";
+  }
+  if (feof(lf->f)) return NULL;
+  *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f);
+  return (*size > 0) ? lf->buff : NULL;
+}
+
+
+static int errfile (lua_State *L, const char *what, int fnameindex) {
+  const char *serr = strerror(errno);
+  const char *filename = lua_tostring(L, fnameindex) + 1;
+  lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);
+  lua_remove(L, fnameindex);
+  return LUA_ERRFILE;
+}
+
+
+LUALIB_API int luaL_loadfile (lua_State *L, const char *filename) {
+  LoadF lf;
+  int status, readstatus;
+  int c;
+  int fnameindex = lua_gettop(L) + 1;  /* index of filename on the stack */
+  lf.extraline = 0;
+  if (filename == NULL) {
+    lua_pushliteral(L, "=stdin");
+    lf.f = stdin;
+  }
+  else {
+    lua_pushfstring(L, "@%s", filename);
+    lf.f = fopen(filename, "r");
+    if (lf.f == NULL) return errfile(L, "open", fnameindex);
+  }
+  c = getc(lf.f);
+  if (c == '#') {  /* Unix exec. file? */
+    lf.extraline = 1;
+    while ((c = getc(lf.f)) != EOF && c != '\n') ;  /* skip first line */
+    if (c == '\n') c = getc(lf.f);
+  }
+  if (c == LUA_SIGNATURE[0] && filename) {  /* binary file? */
+    lf.f = freopen(filename, "rb", lf.f);  /* reopen in binary mode */
+    if (lf.f == NULL) return errfile(L, "reopen", fnameindex);
+    /* skip eventual `#!...' */
+   while ((c = getc(lf.f)) != EOF && c != LUA_SIGNATURE[0]) ;
+    lf.extraline = 0;
+  }
+  ungetc(c, lf.f);
+  status = lua_load(L, getF, &lf, lua_tostring(L, -1));
+  readstatus = ferror(lf.f);
+  if (filename) fclose(lf.f);  /* close file (even in case of errors) */
+  if (readstatus) {
+    lua_settop(L, fnameindex);  /* ignore results from `lua_load' */
+    return errfile(L, "read", fnameindex);
+  }
+  lua_remove(L, fnameindex);
+  return status;
+}
+
+
+typedef struct LoadS {
+  const char *s;
+  size_t size;
+} LoadS;
+
+
+static const char *getS (lua_State *L, void *ud, size_t *size) {
+  LoadS *ls = (LoadS *)ud;
+  (void)L;
+  if (ls->size == 0) return NULL;
+  *size = ls->size;
+  ls->size = 0;
+  return ls->s;
+}
+
+
+LUALIB_API int luaL_loadbuffer (lua_State *L, const char *buff, size_t size,
+                                const char *name) {
+  LoadS ls;
+  ls.s = buff;
+  ls.size = size;
+  return lua_load(L, getS, &ls, name);
+}
+
+
+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s) {
+  return luaL_loadbuffer(L, s, strlen(s), s);
+}
+
+
+
+/* }====================================================== */
+
+
+static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
+  (void)ud;
+  (void)osize;
+  if (nsize == 0) {
+    free(ptr);
+    return NULL;
+  }
+  else
+    return realloc(ptr, nsize);
+}
+
+
+static int panic (lua_State *L) {
+  (void)L;  /* to avoid warnings */
+  fprintf(stderr, "PANIC: unprotected error in call to Lua API (%s)\n",
+                   lua_tostring(L, -1));
+  return 0;
+}
+
+
+LUALIB_API lua_State *luaL_newstate (void) {
+  lua_State *L = lua_newstate(l_alloc, NULL);
+  if (L) lua_atpanic(L, &panic);
+  return L;
+}
+

lua/src/lauxlib.h

@@ -0,0 +1,174 @@
+/*
+** $Id: lauxlib.h,v 1.88.1.1 2007/12/27 13:02:25 roberto Exp $
+** Auxiliary functions for building Lua libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lauxlib_h
+#define lauxlib_h
+
+
+#include <stddef.h>
+#include <stdio.h>
+
+#include "lua.h"
+
+
+#if defined(LUA_COMPAT_GETN)
+LUALIB_API int (luaL_getn) (lua_State *L, int t);
+LUALIB_API void (luaL_setn) (lua_State *L, int t, int n);
+#else
+#define luaL_getn(L,i)          ((int)lua_objlen(L, i))
+#define luaL_setn(L,i,j)        ((void)0)  /* no op! */
+#endif
+
+#if defined(LUA_COMPAT_OPENLIB)
+#define luaI_openlib	luaL_openlib
+#endif
+
+
+/* extra error code for `luaL_load' */
+#define LUA_ERRFILE     (LUA_ERRERR+1)
+
+
+typedef struct luaL_Reg {
+  const char *name;
+  lua_CFunction func;
+} luaL_Reg;
+
+
+
+LUALIB_API void (luaI_openlib) (lua_State *L, const char *libname,
+                                const luaL_Reg *l, int nup);
+LUALIB_API void (luaL_register) (lua_State *L, const char *libname,
+                                const luaL_Reg *l);
+LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_typerror) (lua_State *L, int narg, const char *tname);
+LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
+                                                          size_t *l);
+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
+                                          const char *def, size_t *l);
+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
+
+LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
+                                          lua_Integer def);
+
+LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
+LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
+LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
+
+LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
+LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
+
+LUALIB_API void (luaL_where) (lua_State *L, int lvl);
+LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
+
+LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
+                                   const char *const lst[]);
+
+LUALIB_API int (luaL_ref) (lua_State *L, int t);
+LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
+
+LUALIB_API int (luaL_loadfile) (lua_State *L, const char *filename);
+LUALIB_API int (luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz,
+                                  const char *name);
+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
+
+LUALIB_API lua_State *(luaL_newstate) (void);
+
+
+LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
+                                                  const char *r);
+
+LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx,
+                                         const char *fname, int szhint);
+
+
+
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define luaL_argcheck(L, cond,numarg,extramsg)	\
+		((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
+#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
+#define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
+#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
+#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
+#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
+#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
+
+#define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
+
+#define luaL_dofile(L, fn) \
+	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_dostring(L, s) \
+	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))
+
+#define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+
+
+typedef struct luaL_Buffer {
+  char *p;			/* current position in buffer */
+  int lvl;  /* number of strings in the stack (level) */
+  lua_State *L;
+  char buffer[LUAL_BUFFERSIZE];
+} luaL_Buffer;
+
+#define luaL_addchar(B,c) \
+  ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \
+   (*(B)->p++ = (char)(c)))
+
+/* compatibility only */
+#define luaL_putchar(B,c)	luaL_addchar(B,c)
+
+#define luaL_addsize(B,n)	((B)->p += (n))
+
+LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
+LUALIB_API char *(luaL_prepbuffer) (luaL_Buffer *B);
+LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
+LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
+LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
+
+
+/* }====================================================== */
+
+
+/* compatibility with ref system */
+
+/* pre-defined references */
+#define LUA_NOREF       (-2)
+#define LUA_REFNIL      (-1)
+
+#define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \
+      (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0))
+
+#define lua_unref(L,ref)        luaL_unref(L, LUA_REGISTRYINDEX, (ref))
+
+#define lua_getref(L,ref)       lua_rawgeti(L, LUA_REGISTRYINDEX, (ref))
+
+
+#define luaL_reg	luaL_Reg
+
+#endif
+
+

lua/src/lbaselib.c

@@ -0,0 +1,653 @@
+/*
+** $Id: lbaselib.c,v 1.191.1.6 2008/02/14 16:46:22 roberto Exp $
+** Basic library
+** See Copyright Notice in lua.h
+*/
+
+
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define lbaselib_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "lualib.h"
+
+
+
+
+/*
+** If your system does not support `stdout', you can just remove this function.
+** If you need, you can define your own `print' function, following this
+** model but changing `fputs' to put the strings at a proper place
+** (a console window or a log file, for instance).
+*/
+static int luaB_print (lua_State *L) {
+  int n = lua_gettop(L);  /* number of arguments */
+  int i;
+  lua_getglobal(L, "tostring");
+  for (i=1; i<=n; i++) {
+    const char *s;
+    lua_pushvalue(L, -1);  /* function to be called */
+    lua_pushvalue(L, i);   /* value to print */
+    lua_call(L, 1, 1);
+    s = lua_tostring(L, -1);  /* get result */
+    if (s == NULL)
+      return luaL_error(L, LUA_QL("tostring") " must return a string to "
+                           LUA_QL("print"));
+    if (i>1) fputs("\t", stdout);
+    fputs(s, stdout);
+    lua_pop(L, 1);  /* pop result */
+  }
+  fputs("\n", stdout);
+  return 0;
+}
+
+
+static int luaB_tonumber (lua_State *L) {
+  int base = luaL_optint(L, 2, 10);
+  if (base == 10) {  /* standard conversion */
+    luaL_checkany(L, 1);
+    if (lua_isnumber(L, 1)) {
+      lua_pushnumber(L, lua_tonumber(L, 1));
+      return 1;
+    }
+  }
+  else {
+    const char *s1 = luaL_checkstring(L, 1);
+    char *s2;
+    unsigned long n;
+    luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
+    n = strtoul(s1, &s2, base);
+    if (s1 != s2) {  /* at least one valid digit? */
+      while (isspace((unsigned char)(*s2))) s2++;  /* skip trailing spaces */
+      if (*s2 == '\0') {  /* no invalid trailing characters? */
+        lua_pushnumber(L, (lua_Number)n);
+        return 1;
+      }
+    }
+  }
+  lua_pushnil(L);  /* else not a number */
+  return 1;
+}
+
+
+static int luaB_error (lua_State *L) {
+  int level = luaL_optint(L, 2, 1);
+  lua_settop(L, 1);
+  if (lua_isstring(L, 1) && level > 0) {  /* add extra information? */
+    luaL_where(L, level);
+    lua_pushvalue(L, 1);
+    lua_concat(L, 2);
+  }
+  return lua_error(L);
+}
+
+
+static int luaB_getmetatable (lua_State *L) {
+  luaL_checkany(L, 1);
+  if (!lua_getmetatable(L, 1)) {
+    lua_pushnil(L);
+    return 1;  /* no metatable */
+  }
+  luaL_getmetafield(L, 1, "__metatable");
+  return 1;  /* returns either __metatable field (if present) or metatable */
+}
+
+
+static int luaB_setmetatable (lua_State *L) {
+  int t = lua_type(L, 2);
+  luaL_checktype(L, 1, LUA_TTABLE);
+  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
+                    "nil or table expected");
+  if (luaL_getmetafield(L, 1, "__metatable"))
+    luaL_error(L, "cannot change a protected metatable");
+  lua_settop(L, 2);
+  lua_setmetatable(L, 1);
+  return 1;
+}
+
+
+static void getfunc (lua_State *L, int opt) {
+  if (lua_isfunction(L, 1)) lua_pushvalue(L, 1);
+  else {
+    lua_Debug ar;
+    int level = opt ? luaL_optint(L, 1, 1) : luaL_checkint(L, 1);
+    luaL_argcheck(L, level >= 0, 1, "level must be non-negative");
+    if (lua_getstack(L, level, &ar) == 0)
+      luaL_argerror(L, 1, "invalid level");
+    lua_getinfo(L, "f", &ar);
+    if (lua_isnil(L, -1))
+      luaL_error(L, "no function environment for tail call at level %d",
+                    level);
+  }
+}
+
+
+static int luaB_getfenv (lua_State *L) {
+  getfunc(L, 1);
+  if (lua_iscfunction(L, -1))  /* is a C function? */
+    lua_pushvalue(L, LUA_GLOBALSINDEX);  /* return the thread's global env. */
+  else
+    lua_getfenv(L, -1);
+  return 1;
+}
+
+
+static int luaB_setfenv (lua_State *L) {
+  luaL_checktype(L, 2, LUA_TTABLE);
+  getfunc(L, 0);
+  lua_pushvalue(L, 2);
+  if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0) {
+    /* change environment of current thread */
+    lua_pushthread(L);
+    lua_insert(L, -2);
+    lua_setfenv(L, -2);
+    return 0;
+  }
+  else if (lua_iscfunction(L, -2) || lua_setfenv(L, -2) == 0)
+    luaL_error(L,
+          LUA_QL("setfenv") " cannot change environment of given object");
+  return 1;
+}
+
+
+static int luaB_rawequal (lua_State *L) {
+  luaL_checkany(L, 1);
+  luaL_checkany(L, 2);
+  lua_pushboolean(L, lua_rawequal(L, 1, 2));
+  return 1;
+}
+
+
+static int luaB_rawget (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  luaL_checkany(L, 2);
+  lua_settop(L, 2);
+  lua_rawget(L, 1);
+  return 1;
+}
+
+static int luaB_rawset (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  luaL_checkany(L, 2);
+  luaL_checkany(L, 3);
+  lua_settop(L, 3);
+  lua_rawset(L, 1);
+  return 1;
+}
+
+
+static int luaB_gcinfo (lua_State *L) {
+  lua_pushinteger(L, lua_getgccount(L));
+  return 1;
+}
+
+
+static int luaB_collectgarbage (lua_State *L) {
+  static const char *const opts[] = {"stop", "restart", "collect",
+    "count", "step", "setpause", "setstepmul", NULL};
+  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
+    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL};
+  int o = luaL_checkoption(L, 1, "collect", opts);
+  int ex = luaL_optint(L, 2, 0);
+  int res = lua_gc(L, optsnum[o], ex);
+  switch (optsnum[o]) {
+    case LUA_GCCOUNT: {
+      int b = lua_gc(L, LUA_GCCOUNTB, 0);
+      lua_pushnumber(L, res + ((lua_Number)b/1024));
+      return 1;
+    }
+    case LUA_GCSTEP: {
+      lua_pushboolean(L, res);
+      return 1;
+    }
+    default: {
+      lua_pushnumber(L, res);
+      return 1;
+    }
+  }
+}
+
+
+static int luaB_type (lua_State *L) {
+  luaL_checkany(L, 1);
+  lua_pushstring(L, luaL_typename(L, 1));
+  return 1;
+}
+
+
+static int luaB_next (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  lua_settop(L, 2);  /* create a 2nd argument if there isn't one */
+  if (lua_next(L, 1))
+    return 2;
+  else {
+    lua_pushnil(L);
+    return 1;
+  }
+}
+
+
+static int luaB_pairs (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
+  lua_pushvalue(L, 1);  /* state, */
+  lua_pushnil(L);  /* and initial value */
+  return 3;
+}
+
+
+static int ipairsaux (lua_State *L) {
+  int i = luaL_checkint(L, 2);
+  luaL_checktype(L, 1, LUA_TTABLE);
+  i++;  /* next value */
+  lua_pushinteger(L, i);
+  lua_rawgeti(L, 1, i);
+  return (lua_isnil(L, -1)) ? 0 : 2;
+}
+
+
+static int luaB_ipairs (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */
+  lua_pushvalue(L, 1);  /* state, */
+  lua_pushinteger(L, 0);  /* and initial value */
+  return 3;
+}
+
+
+static int load_aux (lua_State *L, int status) {
+  if (status == 0)  /* OK? */
+    return 1;
+  else {
+    lua_pushnil(L);
+    lua_insert(L, -2);  /* put before error message */
+    return 2;  /* return nil plus error message */
+  }
+}
+
+
+static int luaB_loadstring (lua_State *L) {
+  size_t l;
+  const char *s = luaL_checklstring(L, 1, &l);
+  const char *chunkname = luaL_optstring(L, 2, s);
+  return load_aux(L, luaL_loadbuffer(L, s, l, chunkname));
+}
+
+
+static int luaB_loadfile (lua_State *L) {
+  const char *fname = luaL_optstring(L, 1, NULL);
+  return load_aux(L, luaL_loadfile(L, fname));
+}
+
+
+/*
+** Reader for generic `load' function: `lua_load' uses the
+** stack for internal stuff, so the reader cannot change the
+** stack top. Instead, it keeps its resulting string in a
+** reserved slot inside the stack.
+*/
+static const char *generic_reader (lua_State *L, void *ud, size_t *size) {
+  (void)ud;  /* to avoid warnings */
+  luaL_checkstack(L, 2, "too many nested functions");
+  lua_pushvalue(L, 1);  /* get function */
+  lua_call(L, 0, 1);  /* call it */
+  if (lua_isnil(L, -1)) {
+    *size = 0;
+    return NULL;
+  }
+  else if (lua_isstring(L, -1)) {
+    lua_replace(L, 3);  /* save string in a reserved stack slot */
+    return lua_tolstring(L, 3, size);
+  }
+  else luaL_error(L, "reader function must return a string");
+  return NULL;  /* to avoid warnings */
+}
+
+
+static int luaB_load (lua_State *L) {
+  int status;
+  const char *cname = luaL_optstring(L, 2, "=(load)");
+  luaL_checktype(L, 1, LUA_TFUNCTION);
+  lua_settop(L, 3);  /* function, eventual name, plus one reserved slot */
+  status = lua_load(L, generic_reader, NULL, cname);
+  return load_aux(L, status);
+}
+
+
+static int luaB_dofile (lua_State *L) {
+  const char *fname = luaL_optstring(L, 1, NULL);
+  int n = lua_gettop(L);
+  if (luaL_loadfile(L, fname) != 0) lua_error(L);
+  lua_call(L, 0, LUA_MULTRET);
+  return lua_gettop(L) - n;
+}
+
+
+static int luaB_assert (lua_State *L) {
+  luaL_checkany(L, 1);
+  if (!lua_toboolean(L, 1))
+    return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
+  return lua_gettop(L);
+}
+
+
+static int luaB_unpack (lua_State *L) {
+  int i, e, n;
+  luaL_checktype(L, 1, LUA_TTABLE);
+  i = luaL_optint(L, 2, 1);
+  e = luaL_opt(L, luaL_checkint, 3, luaL_getn(L, 1));
+  if (i > e) return 0;  /* empty range */
+  n = e - i + 1;  /* number of elements */
+  if (n <= 0 || !lua_checkstack(L, n))  /* n <= 0 means arith. overflow */
+    return luaL_error(L, "too many results to unpack");
+  lua_rawgeti(L, 1, i);  /* push arg[i] (avoiding overflow problems) */
+  while (i++ < e)  /* push arg[i + 1...e] */
+    lua_rawgeti(L, 1, i);
+  return n;
+}
+
+
+static int luaB_select (lua_State *L) {
+  int n = lua_gettop(L);
+  if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {
+    lua_pushinteger(L, n-1);
+    return 1;
+  }
+  else {
+    int i = luaL_checkint(L, 1);
+    if (i < 0) i = n + i;
+    else if (i > n) i = n;
+    luaL_argcheck(L, 1 <= i, 1, "index out of range");
+    return n - i;
+  }
+}
+
+
+static int luaB_pcall (lua_State *L) {
+  int status;
+  luaL_checkany(L, 1);
+  status = lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0);
+  lua_pushboolean(L, (status == 0));
+  lua_insert(L, 1);
+  return lua_gettop(L);  /* return status + all results */
+}
+
+
+static int luaB_xpcall (lua_State *L) {
+  int status;
+  luaL_checkany(L, 2);
+  lua_settop(L, 2);
+  lua_insert(L, 1);  /* put error function under function to be called */
+  status = lua_pcall(L, 0, LUA_MULTRET, 1);
+  lua_pushboolean(L, (status == 0));
+  lua_replace(L, 1);
+  return lua_gettop(L);  /* return status + all results */
+}
+
+
+static int luaB_tostring (lua_State *L) {
+  luaL_checkany(L, 1);
+  if (luaL_callmeta(L, 1, "__tostring"))  /* is there a metafield? */
+    return 1;  /* use its value */
+  switch (lua_type(L, 1)) {
+    case LUA_TNUMBER:
+      lua_pushstring(L, lua_tostring(L, 1));
+      break;
+    case LUA_TSTRING:
+      lua_pushvalue(L, 1);
+      break;
+    case LUA_TBOOLEAN:
+      lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false"));
+      break;
+    case LUA_TNIL:
+      lua_pushliteral(L, "nil");
+      break;
+    default:
+      lua_pushfstring(L, "%s: %p", luaL_typename(L, 1), lua_topointer(L, 1));
+      break;
+  }
+  return 1;
+}
+
+
+static int luaB_newproxy (lua_State *L) {
+  lua_settop(L, 1);
+  lua_newuserdata(L, 0);  /* create proxy */
+  if (lua_toboolean(L, 1) == 0)
+    return 1;  /* no metatable */
+  else if (lua_isboolean(L, 1)) {
+    lua_newtable(L);  /* create a new metatable `m' ... */
+    lua_pushvalue(L, -1);  /* ... and mark `m' as a valid metatable */
+    lua_pushboolean(L, 1);
+    lua_rawset(L, lua_upvalueindex(1));  /* weaktable[m] = true */
+  }
+  else {
+    int validproxy = 0;  /* to check if weaktable[metatable(u)] == true */
+    if (lua_getmetatable(L, 1)) {
+      lua_rawget(L, lua_upvalueindex(1));
+      validproxy = lua_toboolean(L, -1);
+      lua_pop(L, 1);  /* remove value */
+    }
+    luaL_argcheck(L, validproxy, 1, "boolean or proxy expected");
+    lua_getmetatable(L, 1);  /* metatable is valid; get it */
+  }
+  lua_setmetatable(L, 2);
+  return 1;
+}
+
+
+static const luaL_Reg base_funcs[] = {
+  {"assert", luaB_assert},
+  {"collectgarbage", luaB_collectgarbage},
+  {"dofile", luaB_dofile},
+  {"error", luaB_error},
+  {"gcinfo", luaB_gcinfo},
+  {"getfenv", luaB_getfenv},
+  {"getmetatable", luaB_getmetatable},
+  {"loadfile", luaB_loadfile},
+  {"load", luaB_load},
+  {"loadstring", luaB_loadstring},
+  {"next", luaB_next},
+  {"pcall", luaB_pcall},
+  {"print", luaB_print},
+  {"rawequal", luaB_rawequal},
+  {"rawget", luaB_rawget},
+  {"rawset", luaB_rawset},
+  {"select", luaB_select},
+  {"setfenv", luaB_setfenv},
+  {"setmetatable", luaB_setmetatable},
+  {"tonumber", luaB_tonumber},
+  {"tostring", luaB_tostring},
+  {"type", luaB_type},
+  {"unpack", luaB_unpack},
+  {"xpcall", luaB_xpcall},
+  {NULL, NULL}
+};
+
+
+/*
+** {======================================================
+** Coroutine library
+** =======================================================
+*/
+
+#define CO_RUN	0	/* running */
+#define CO_SUS	1	/* suspended */
+#define CO_NOR	2	/* 'normal' (it resumed another coroutine) */
+#define CO_DEAD	3
+
+static const char *const statnames[] =
+    {"running", "suspended", "normal", "dead"};
+
+static int costatus (lua_State *L, lua_State *co) {
+  if (L == co) return CO_RUN;
+  switch (lua_status(co)) {
+    case LUA_YIELD:
+      return CO_SUS;
+    case 0: {
+      lua_Debug ar;
+      if (lua_getstack(co, 0, &ar) > 0)  /* does it have frames? */
+        return CO_NOR;  /* it is running */
+      else if (lua_gettop(co) == 0)
+          return CO_DEAD;
+      else
+        return CO_SUS;  /* initial state */
+    }
+    default:  /* some error occured */
+      return CO_DEAD;
+  }
+}
+
+
+static int luaB_costatus (lua_State *L) {
+  lua_State *co = lua_tothread(L, 1);
+  luaL_argcheck(L, co, 1, "coroutine expected");
+  lua_pushstring(L, statnames[costatus(L, co)]);
+  return 1;
+}
+
+
+static int auxresume (lua_State *L, lua_State *co, int narg) {
+  int status = costatus(L, co);
+  if (!lua_checkstack(co, narg))
+    luaL_error(L, "too many arguments to resume");
+  if (status != CO_SUS) {
+    lua_pushfstring(L, "cannot resume %s coroutine", statnames[status]);
+    return -1;  /* error flag */
+  }
+  lua_xmove(L, co, narg);
+  lua_setlevel(L, co);
+  status = lua_resume(co, narg);
+  if (status == 0 || status == LUA_YIELD) {
+    int nres = lua_gettop(co);
+    if (!lua_checkstack(L, nres + 1))
+      luaL_error(L, "too many results to resume");
+    lua_xmove(co, L, nres);  /* move yielded values */
+    return nres;
+  }
+  else {
+    lua_xmove(co, L, 1);  /* move error message */
+    return -1;  /* error flag */
+  }
+}
+
+
+static int luaB_coresume (lua_State *L) {
+  lua_State *co = lua_tothread(L, 1);
+  int r;
+  luaL_argcheck(L, co, 1, "coroutine expected");
+  r = auxresume(L, co, lua_gettop(L) - 1);
+  if (r < 0) {
+    lua_pushboolean(L, 0);
+    lua_insert(L, -2);
+    return 2;  /* return false + error message */
+  }
+  else {
+    lua_pushboolean(L, 1);
+    lua_insert(L, -(r + 1));
+    return r + 1;  /* return true + `resume' returns */
+  }
+}
+
+
+static int luaB_auxwrap (lua_State *L) {
+  lua_State *co = lua_tothread(L, lua_upvalueindex(1));
+  int r = auxresume(L, co, lua_gettop(L));
+  if (r < 0) {
+    if (lua_isstring(L, -1)) {  /* error object is a string? */
+      luaL_where(L, 1);  /* add extra info */
+      lua_insert(L, -2);
+      lua_concat(L, 2);
+    }
+    lua_error(L);  /* propagate error */
+  }
+  return r;
+}
+
+
+static int luaB_cocreate (lua_State *L) {
+  lua_State *NL = lua_newthread(L);
+  luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), 1,
+    "Lua function expected");
+  lua_pushvalue(L, 1);  /* move function to top */
+  lua_xmove(L, NL, 1);  /* move function from L to NL */
+  return 1;
+}
+
+
+static int luaB_cowrap (lua_State *L) {
+  luaB_cocreate(L);
+  lua_pushcclosure(L, luaB_auxwrap, 1);
+  return 1;
+}
+
+
+static int luaB_yield (lua_State *L) {
+  return lua_yield(L, lua_gettop(L));
+}
+
+
+static int luaB_corunning (lua_State *L) {
+  if (lua_pushthread(L))
+    lua_pushnil(L);  /* main thread is not a coroutine */
+  return 1;
+}
+
+
+static const luaL_Reg co_funcs[] = {
+  {"create", luaB_cocreate},
+  {"resume", luaB_coresume},
+  {"running", luaB_corunning},
+  {"status", luaB_costatus},
+  {"wrap", luaB_cowrap},
+  {"yield", luaB_yield},
+  {NULL, NULL}
+};
+
+/* }====================================================== */
+
+
+static void auxopen (lua_State *L, const char *name,
+                     lua_CFunction f, lua_CFunction u) {
+  lua_pushcfunction(L, u);
+  lua_pushcclosure(L, f, 1);
+  lua_setfield(L, -2, name);
+}
+
+
+static void base_open (lua_State *L) {
+  /* set global _G */
+  lua_pushvalue(L, LUA_GLOBALSINDEX);
+  lua_setglobal(L, "_G");
+  /* open lib into global table */
+  luaL_register(L, "_G", base_funcs);
+  lua_pushliteral(L, LUA_VERSION);
+  lua_setglobal(L, "_VERSION");  /* set global _VERSION */
+  /* `ipairs' and `pairs' need auxliliary functions as upvalues */
+  auxopen(L, "ipairs", luaB_ipairs, ipairsaux);
+  auxopen(L, "pairs", luaB_pairs, luaB_next);
+  /* `newproxy' needs a weaktable as upvalue */
+  lua_createtable(L, 0, 1);  /* new table `w' */
+  lua_pushvalue(L, -1);  /* `w' will be its own metatable */
+  lua_setmetatable(L, -2);
+  lua_pushliteral(L, "kv");
+  lua_setfield(L, -2, "__mode");  /* metatable(w).__mode = "kv" */
+  lua_pushcclosure(L, luaB_newproxy, 1);
+  lua_setglobal(L, "newproxy");  /* set global `newproxy' */
+}
+
+
+LUALIB_API int luaopen_base (lua_State *L) {
+  base_open(L);
+  luaL_register(L, LUA_COLIBNAME, co_funcs);
+  return 2;
+}
+

lua/src/lcode.c

@@ -0,0 +1,839 @@
+/*
+** $Id: lcode.c,v 2.25.1.3 2007/12/28 15:32:23 roberto Exp $
+** Code generator for Lua
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stdlib.h>
+
+#define lcode_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "lcode.h"
+#include "ldebug.h"
+#include "ldo.h"
+#include "lgc.h"
+#include "llex.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lopcodes.h"
+#include "lparser.h"
+#include "ltable.h"
+
+
+#define hasjumps(e)	((e)->t != (e)->f)
+
+
+static int isnumeral(expdesc *e) {
+  return (e->k == VKNUM && e->t == NO_JUMP && e->f == NO_JUMP);
+}
+
+
+void luaK_nil (FuncState *fs, int from, int n) {
+  Instruction *previous;
+  if (fs->pc > fs->lasttarget) {  /* no jumps to current position? */
+    if (fs->pc == 0) {  /* function start? */
+      if (from >= fs->nactvar)
+        return;  /* positions are already clean */
+    }
+    else {
+      previous = &fs->f->code[fs->pc-1];
+      if (GET_OPCODE(*previous) == OP_LOADNIL) {
+        int pfrom = GETARG_A(*previous);
+        int pto = GETARG_B(*previous);
+        if (pfrom <= from && from <= pto+1) {  /* can connect both? */
+          if (from+n-1 > pto)
+            SETARG_B(*previous, from+n-1);
+          return;
+        }
+      }
+    }
+  }
+  luaK_codeABC(fs, OP_LOADNIL, from, from+n-1, 0);  /* else no optimization */
+}
+
+
+int luaK_jump (FuncState *fs) {
+  int jpc = fs->jpc;  /* save list of jumps to here */
+  int j;
+  fs->jpc = NO_JUMP;
+  j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP);
+  luaK_concat(fs, &j, jpc);  /* keep them on hold */
+  return j;
+}
+
+
+void luaK_ret (FuncState *fs, int first, int nret) {
+  luaK_codeABC(fs, OP_RETURN, first, nret+1, 0);
+}
+
+
+static int condjump (FuncState *fs, OpCode op, int A, int B, int C) {
+  luaK_codeABC(fs, op, A, B, C);
+  return luaK_jump(fs);
+}
+
+
+static void fixjump (FuncState *fs, int pc, int dest) {
+  Instruction *jmp = &fs->f->code[pc];
+  int offset = dest-(pc+1);
+  lua_assert(dest != NO_JUMP);
+  if (abs(offset) > MAXARG_sBx)
+    luaX_syntaxerror(fs->ls, "control structure too long");
+  SETARG_sBx(*jmp, offset);
+}
+
+
+/*
+** returns current `pc' and marks it as a jump target (to avoid wrong
+** optimizations with consecutive instructions not in the same basic block).
+*/
+int luaK_getlabel (FuncState *fs) {
+  fs->lasttarget = fs->pc;
+  return fs->pc;
+}
+
+
+static int getjump (FuncState *fs, int pc) {
+  int offset = GETARG_sBx(fs->f->code[pc]);
+  if (offset == NO_JUMP)  /* point to itself represents end of list */
+    return NO_JUMP;  /* end of list */
+  else
+    return (pc+1)+offset;  /* turn offset into absolute position */
+}
+
+
+static Instruction *getjumpcontrol (FuncState *fs, int pc) {
+  Instruction *pi = &fs->f->code[pc];
+  if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1))))
+    return pi-1;
+  else
+    return pi;
+}
+
+
+/*
+** check whether list has any jump that do not produce a value
+** (or produce an inverted value)
+*/
+static int need_value (FuncState *fs, int list) {
+  for (; list != NO_JUMP; list = getjump(fs, list)) {
+    Instruction i = *getjumpcontrol(fs, list);
+    if (GET_OPCODE(i) != OP_TESTSET) return 1;
+  }
+  return 0;  /* not found */
+}
+
+
+static int patchtestreg (FuncState *fs, int node, int reg) {
+  Instruction *i = getjumpcontrol(fs, node);
+  if (GET_OPCODE(*i) != OP_TESTSET)
+    return 0;  /* cannot patch other instructions */
+  if (reg != NO_REG && reg != GETARG_B(*i))
+    SETARG_A(*i, reg);
+  else  /* no register to put value or register already has the value */
+    *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i));
+
+  return 1;
+}
+
+
+static void removevalues (FuncState *fs, int list) {
+  for (; list != NO_JUMP; list = getjump(fs, list))
+      patchtestreg(fs, list, NO_REG);
+}
+
+
+static void patchlistaux (FuncState *fs, int list, int vtarget, int reg,
+                          int dtarget) {
+  while (list != NO_JUMP) {
+    int next = getjump(fs, list);
+    if (patchtestreg(fs, list, reg))
+      fixjump(fs, list, vtarget);
+    else
+      fixjump(fs, list, dtarget);  /* jump to default target */
+    list = next;
+  }
+}
+
+
+static void dischargejpc (FuncState *fs) {
+  patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc);
+  fs->jpc = NO_JUMP;
+}
+
+
+void luaK_patchlist (FuncState *fs, int list, int target) {
+  if (target == fs->pc)
+    luaK_patchtohere(fs, list);
+  else {
+    lua_assert(target < fs->pc);
+    patchlistaux(fs, list, target, NO_REG, target);
+  }
+}
+
+
+void luaK_patchtohere (FuncState *fs, int list) {
+  luaK_getlabel(fs);
+  luaK_concat(fs, &fs->jpc, list);
+}
+
+
+void luaK_concat (FuncState *fs, int *l1, int l2) {
+  if (l2 == NO_JUMP) return;
+  else if (*l1 == NO_JUMP)
+    *l1 = l2;
+  else {
+    int list = *l1;
+    int next;
+    while ((next = getjump(fs, list)) != NO_JUMP)  /* find last element */
+      list = next;
+    fixjump(fs, list, l2);
+  }
+}
+
+
+void luaK_checkstack (FuncState *fs, int n) {
+  int newstack = fs->freereg + n;
+  if (newstack > fs->f->maxstacksize) {
+    if (newstack >= MAXSTACK)
+      luaX_syntaxerror(fs->ls, "function or expression too complex");
+    fs->f->maxstacksize = cast_byte(newstack);
+  }
+}
+
+
+void luaK_reserveregs (FuncState *fs, int n) {
+  luaK_checkstack(fs, n);
+  fs->freereg += n;
+}
+
+
+static void freereg (FuncState *fs, int reg) {
+  if (!ISK(reg) && reg >= fs->nactvar) {
+    fs->freereg--;
+    lua_assert(reg == fs->freereg);
+  }
+}
+
+
+static void freeexp (FuncState *fs, expdesc *e) {
+  if (e->k == VNONRELOC)
+    freereg(fs, e->u.s.info);
+}
+
+
+static int addk (FuncState *fs, TValue *k, TValue *v) {
+  lua_State *L = fs->L;
+  TValue *idx = luaH_set(L, fs->h, k);
+  Proto *f = fs->f;
+  int oldsize = f->sizek;
+  if (ttisnumber(idx)) {
+    lua_assert(luaO_rawequalObj(&fs->f->k[cast_int(nvalue(idx))], v));
+    return cast_int(nvalue(idx));
+  }
+  else {  /* constant not found; create a new entry */
+    setnvalue(idx, cast_num(fs->nk));
+    luaM_growvector(L, f->k, fs->nk, f->sizek, TValue,
+                    MAXARG_Bx, "constant table overflow");
+    while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
+    setobj(L, &f->k[fs->nk], v);
+    luaC_barrier(L, f, v);
+    return fs->nk++;
+  }
+}
+
+
+int luaK_stringK (FuncState *fs, TString *s) {
+  TValue o;
+  setsvalue(fs->L, &o, s);
+  return addk(fs, &o, &o);
+}
+
+
+int luaK_numberK (FuncState *fs, lua_Number r) {
+  TValue o;
+  setnvalue(&o, r);
+  return addk(fs, &o, &o);
+}
+
+
+static int boolK (FuncState *fs, int b) {
+  TValue o;
+  setbvalue(&o, b);
+  return addk(fs, &o, &o);
+}
+
+
+static int nilK (FuncState *fs) {
+  TValue k, v;
+  setnilvalue(&v);
+  /* cannot use nil as key; instead use table itself to represent nil */
+  sethvalue(fs->L, &k, fs->h);
+  return addk(fs, &k, &v);
+}
+
+
+void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {
+  if (e->k == VCALL) {  /* expression is an open function call? */
+    SETARG_C(getcode(fs, e), nresults+1);
+  }
+  else if (e->k == VVARARG) {
+    SETARG_B(getcode(fs, e), nresults+1);
+    SETARG_A(getcode(fs, e), fs->freereg);
+    luaK_reserveregs(fs, 1);
+  }
+}
+
+
+void luaK_setoneret (FuncState *fs, expdesc *e) {
+  if (e->k == VCALL) {  /* expression is an open function call? */
+    e->k = VNONRELOC;
+    e->u.s.info = GETARG_A(getcode(fs, e));
+  }
+  else if (e->k == VVARARG) {
+    SETARG_B(getcode(fs, e), 2);
+    e->k = VRELOCABLE;  /* can relocate its simple result */
+  }
+}
+
+
+void luaK_dischargevars (FuncState *fs, expdesc *e) {
+  switch (e->k) {
+    case VLOCAL: {
+      e->k = VNONRELOC;
+      break;
+    }
+    case VUPVAL: {
+      e->u.s.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.s.info, 0);
+      e->k = VRELOCABLE;
+      break;
+    }
+    case VGLOBAL: {
+      e->u.s.info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->u.s.info);
+      e->k = VRELOCABLE;
+      break;
+    }
+    case VINDEXED: {
+      freereg(fs, e->u.s.aux);
+      freereg(fs, e->u.s.info);
+      e->u.s.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.s.info, e->u.s.aux);
+      e->k = VRELOCABLE;
+      break;
+    }
+    case VVARARG:
+    case VCALL: {
+      luaK_setoneret(fs, e);
+      break;
+    }
+    default: break;  /* there is one value available (somewhere) */
+  }
+}
+
+
+static int code_label (FuncState *fs, int A, int b, int jump) {
+  luaK_getlabel(fs);  /* those instructions may be jump targets */
+  return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump);
+}
+
+
+static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
+  luaK_dischargevars(fs, e);
+  switch (e->k) {
+    case VNIL: {
+      luaK_nil(fs, reg, 1);
+      break;
+    }
+    case VFALSE:  case VTRUE: {
+      luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);
+      break;
+    }
+    case VK: {
+      luaK_codeABx(fs, OP_LOADK, reg, e->u.s.info);
+      break;
+    }
+    case VKNUM: {
+      luaK_codeABx(fs, OP_LOADK, reg, luaK_numberK(fs, e->u.nval));
+      break;
+    }
+    case VRELOCABLE: {
+      Instruction *pc = &getcode(fs, e);
+      SETARG_A(*pc, reg);
+      break;
+    }
+    case VNONRELOC: {
+      if (reg != e->u.s.info)
+        luaK_codeABC(fs, OP_MOVE, reg, e->u.s.info, 0);
+      break;
+    }
+    default: {
+      lua_assert(e->k == VVOID || e->k == VJMP);
+      return;  /* nothing to do... */
+    }
+  }
+  e->u.s.info = reg;
+  e->k = VNONRELOC;
+}
+
+
+static void discharge2anyreg (FuncState *fs, expdesc *e) {
+  if (e->k != VNONRELOC) {
+    luaK_reserveregs(fs, 1);
+    discharge2reg(fs, e, fs->freereg-1);
+  }
+}
+
+
+static void exp2reg (FuncState *fs, expdesc *e, int reg) {
+  discharge2reg(fs, e, reg);
+  if (e->k == VJMP)
+    luaK_concat(fs, &e->t, e->u.s.info);  /* put this jump in `t' list */
+  if (hasjumps(e)) {
+    int final;  /* position after whole expression */
+    int p_f = NO_JUMP;  /* position of an eventual LOAD false */
+    int p_t = NO_JUMP;  /* position of an eventual LOAD true */
+    if (need_value(fs, e->t) || need_value(fs, e->f)) {
+      int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);
+      p_f = code_label(fs, reg, 0, 1);
+      p_t = code_label(fs, reg, 1, 0);
+      luaK_patchtohere(fs, fj);
+    }
+    final = luaK_getlabel(fs);
+    patchlistaux(fs, e->f, final, reg, p_f);
+    patchlistaux(fs, e->t, final, reg, p_t);
+  }
+  e->f = e->t = NO_JUMP;
+  e->u.s.info = reg;
+  e->k = VNONRELOC;
+}
+
+
+void luaK_exp2nextreg (FuncState *fs, expdesc *e) {
+  luaK_dischargevars(fs, e);
+  freeexp(fs, e);
+  luaK_reserveregs(fs, 1);
+  exp2reg(fs, e, fs->freereg - 1);
+}
+
+
+int luaK_exp2anyreg (FuncState *fs, expdesc *e) {
+  luaK_dischargevars(fs, e);
+  if (e->k == VNONRELOC) {
+    if (!hasjumps(e)) return e->u.s.info;  /* exp is already in a register */
+    if (e->u.s.info >= fs->nactvar) {  /* reg. is not a local? */
+      exp2reg(fs, e, e->u.s.info);  /* put value on it */
+      return e->u.s.info;
+    }
+  }
+  luaK_exp2nextreg(fs, e);  /* default */
+  return e->u.s.info;
+}
+
+
+void luaK_exp2val (FuncState *fs, expdesc *e) {
+  if (hasjumps(e))
+    luaK_exp2anyreg(fs, e);
+  else
+    luaK_dischargevars(fs, e);
+}
+
+
+int luaK_exp2RK (FuncState *fs, expdesc *e) {
+  luaK_exp2val(fs, e);
+  switch (e->k) {
+    case VKNUM:
+    case VTRUE:
+    case VFALSE:
+    case VNIL: {
+      if (fs->nk <= MAXINDEXRK) {  /* constant fit in RK operand? */
+        e->u.s.info = (e->k == VNIL)  ? nilK(fs) :
+                      (e->k == VKNUM) ? luaK_numberK(fs, e->u.nval) :
+                                        boolK(fs, (e->k == VTRUE));
+        e->k = VK;
+        return RKASK(e->u.s.info);
+      }
+      else break;
+    }
+    case VK: {
+      if (e->u.s.info <= MAXINDEXRK)  /* constant fit in argC? */
+        return RKASK(e->u.s.info);
+      else break;
+    }
+    default: break;
+  }
+  /* not a constant in the right range: put it in a register */
+  return luaK_exp2anyreg(fs, e);
+}
+
+
+void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {
+  switch (var->k) {
+    case VLOCAL: {
+      freeexp(fs, ex);
+      exp2reg(fs, ex, var->u.s.info);
+      return;
+    }
+    case VUPVAL: {
+      int e = luaK_exp2anyreg(fs, ex);
+      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.s.info, 0);
+      break;
+    }
+    case VGLOBAL: {
+      int e = luaK_exp2anyreg(fs, ex);
+      luaK_codeABx(fs, OP_SETGLOBAL, e, var->u.s.info);
+      break;
+    }
+    case VINDEXED: {
+      int e = luaK_exp2RK(fs, ex);
+      luaK_codeABC(fs, OP_SETTABLE, var->u.s.info, var->u.s.aux, e);
+      break;
+    }
+    default: {
+      lua_assert(0);  /* invalid var kind to store */
+      break;
+    }
+  }
+  freeexp(fs, ex);
+}
+
+
+void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
+  int func;
+  luaK_exp2anyreg(fs, e);
+  freeexp(fs, e);
+  func = fs->freereg;
+  luaK_reserveregs(fs, 2);
+  luaK_codeABC(fs, OP_SELF, func, e->u.s.info, luaK_exp2RK(fs, key));
+  freeexp(fs, key);
+  e->u.s.info = func;
+  e->k = VNONRELOC;
+}
+
+
+static void invertjump (FuncState *fs, expdesc *e) {
+  Instruction *pc = getjumpcontrol(fs, e->u.s.info);
+  lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&
+                                           GET_OPCODE(*pc) != OP_TEST);
+  SETARG_A(*pc, !(GETARG_A(*pc)));
+}
+
+
+static int jumponcond (FuncState *fs, expdesc *e, int cond) {
+  if (e->k == VRELOCABLE) {
+    Instruction ie = getcode(fs, e);
+    if (GET_OPCODE(ie) == OP_NOT) {
+      fs->pc--;  /* remove previous OP_NOT */
+      return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond);
+    }
+    /* else go through */
+  }
+  discharge2anyreg(fs, e);
+  freeexp(fs, e);
+  return condjump(fs, OP_TESTSET, NO_REG, e->u.s.info, cond);
+}
+
+
+void luaK_goiftrue (FuncState *fs, expdesc *e) {
+  int pc;  /* pc of last jump */
+  luaK_dischargevars(fs, e);
+  switch (e->k) {
+    case VK: case VKNUM: case VTRUE: {
+      pc = NO_JUMP;  /* always true; do nothing */
+      break;
+    }
+    case VFALSE: {
+      pc = luaK_jump(fs);  /* always jump */
+      break;
+    }
+    case VJMP: {
+      invertjump(fs, e);
+      pc = e->u.s.info;
+      break;
+    }
+    default: {
+      pc = jumponcond(fs, e, 0);
+      break;
+    }
+  }
+  luaK_concat(fs, &e->f, pc);  /* insert last jump in `f' list */
+  luaK_patchtohere(fs, e->t);
+  e->t = NO_JUMP;
+}
+
+
+static void luaK_goiffalse (FuncState *fs, expdesc *e) {
+  int pc;  /* pc of last jump */
+  luaK_dischargevars(fs, e);
+  switch (e->k) {
+    case VNIL: case VFALSE: {
+      pc = NO_JUMP;  /* always false; do nothing */
+      break;
+    }
+    case VTRUE: {
+      pc = luaK_jump(fs);  /* always jump */
+      break;
+    }
+    case VJMP: {
+      pc = e->u.s.info;
+      break;
+    }
+    default: {
+      pc = jumponcond(fs, e, 1);
+      break;
+    }
+  }
+  luaK_concat(fs, &e->t, pc);  /* insert last jump in `t' list */
+  luaK_patchtohere(fs, e->f);
+  e->f = NO_JUMP;
+}
+
+
+static void codenot (FuncState *fs, expdesc *e) {
+  luaK_dischargevars(fs, e);
+  switch (e->k) {
+    case VNIL: case VFALSE: {
+      e->k = VTRUE;
+      break;
+    }
+    case VK: case VKNUM: case VTRUE: {
+      e->k = VFALSE;
+      break;
+    }
+    case VJMP: {
+      invertjump(fs, e);
+      break;
+    }
+    case VRELOCABLE:
+    case VNONRELOC: {
+      discharge2anyreg(fs, e);
+      freeexp(fs, e);
+      e->u.s.info = luaK_codeABC(fs, OP_NOT, 0, e->u.s.info, 0);
+      e->k = VRELOCABLE;
+      break;
+    }
+    default: {
+      lua_assert(0);  /* cannot happen */
+      break;
+    }
+  }
+  /* interchange true and false lists */
+  { int temp = e->f; e->f = e->t; e->t = temp; }
+  removevalues(fs, e->f);
+  removevalues(fs, e->t);
+}
+
+
+void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
+  t->u.s.aux = luaK_exp2RK(fs, k);
+  t->k = VINDEXED;
+}
+
+
+static int constfolding (OpCode op, expdesc *e1, expdesc *e2) {
+  lua_Number v1, v2, r;
+  if (!isnumeral(e1) || !isnumeral(e2)) return 0;
+  v1 = e1->u.nval;
+  v2 = e2->u.nval;
+  switch (op) {
+    case OP_ADD: r = luai_numadd(v1, v2); break;
+    case OP_SUB: r = luai_numsub(v1, v2); break;
+    case OP_MUL: r = luai_nummul(v1, v2); break;
+    case OP_DIV:
+      if (v2 == 0) return 0;  /* do not attempt to divide by 0 */
+      r = luai_numdiv(v1, v2); break;
+    case OP_MOD:
+      if (v2 == 0) return 0;  /* do not attempt to divide by 0 */
+      r = luai_nummod(v1, v2); break;
+    case OP_POW: r = luai_numpow(v1, v2); break;
+    case OP_UNM: r = luai_numunm(v1); break;
+    case OP_LEN: return 0;  /* no constant folding for 'len' */
+    default: lua_assert(0); r = 0; break;
+  }
+  if (luai_numisnan(r)) return 0;  /* do not attempt to produce NaN */
+  e1->u.nval = r;
+  return 1;
+}
+
+
+static void codearith (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2) {
+  if (constfolding(op, e1, e2))
+    return;
+  else {
+    int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
+    int o1 = luaK_exp2RK(fs, e1);
+    if (o1 > o2) {
+      freeexp(fs, e1);
+      freeexp(fs, e2);
+    }
+    else {
+      freeexp(fs, e2);
+      freeexp(fs, e1);
+    }
+    e1->u.s.info = luaK_codeABC(fs, op, 0, o1, o2);
+    e1->k = VRELOCABLE;
+  }
+}
+
+
+static void codecomp (FuncState *fs, OpCode op, int cond, expdesc *e1,
+                                                          expdesc *e2) {
+  int o1 = luaK_exp2RK(fs, e1);
+  int o2 = luaK_exp2RK(fs, e2);
+  freeexp(fs, e2);
+  freeexp(fs, e1);
+  if (cond == 0 && op != OP_EQ) {
+    int temp;  /* exchange args to replace by `<' or `<=' */
+    temp = o1; o1 = o2; o2 = temp;  /* o1 <==> o2 */
+    cond = 1;
+  }
+  e1->u.s.info = condjump(fs, op, cond, o1, o2);
+  e1->k = VJMP;
+}
+
+
+void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) {
+  expdesc e2;
+  e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;
+  switch (op) {
+    case OPR_MINUS: {
+      if (!isnumeral(e))
+        luaK_exp2anyreg(fs, e);  /* cannot operate on non-numeric constants */
+      codearith(fs, OP_UNM, e, &e2);
+      break;
+    }
+    case OPR_NOT: codenot(fs, e); break;
+    case OPR_LEN: {
+      luaK_exp2anyreg(fs, e);  /* cannot operate on constants */
+      codearith(fs, OP_LEN, e, &e2);
+      break;
+    }
+    default: lua_assert(0);
+  }
+}
+
+
+void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
+  switch (op) {
+    case OPR_AND: {
+      luaK_goiftrue(fs, v);
+      break;
+    }
+    case OPR_OR: {
+      luaK_goiffalse(fs, v);
+      break;
+    }
+    case OPR_CONCAT: {
+      luaK_exp2nextreg(fs, v);  /* operand must be on the `stack' */
+      break;
+    }
+    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
+    case OPR_MOD: case OPR_POW: {
+      if (!isnumeral(v)) luaK_exp2RK(fs, v);
+      break;
+    }
+    default: {
+      luaK_exp2RK(fs, v);
+      break;
+    }
+  }
+}
+
+
+void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
+  switch (op) {
+    case OPR_AND: {
+      lua_assert(e1->t == NO_JUMP);  /* list must be closed */
+      luaK_dischargevars(fs, e2);
+      luaK_concat(fs, &e2->f, e1->f);
+      *e1 = *e2;
+      break;
+    }
+    case OPR_OR: {
+      lua_assert(e1->f == NO_JUMP);  /* list must be closed */
+      luaK_dischargevars(fs, e2);
+      luaK_concat(fs, &e2->t, e1->t);
+      *e1 = *e2;
+      break;
+    }
+    case OPR_CONCAT: {
+      luaK_exp2val(fs, e2);
+      if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) {
+        lua_assert(e1->u.s.info == GETARG_B(getcode(fs, e2))-1);
+        freeexp(fs, e1);
+        SETARG_B(getcode(fs, e2), e1->u.s.info);
+        e1->k = VRELOCABLE; e1->u.s.info = e2->u.s.info;
+      }
+      else {
+        luaK_exp2nextreg(fs, e2);  /* operand must be on the 'stack' */
+        codearith(fs, OP_CONCAT, e1, e2);
+      }
+      break;
+    }
+    case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;
+    case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;
+    case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;
+    case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;
+    case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;
+    case OPR_POW: codearith(fs, OP_POW, e1, e2); break;
+    case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;
+    case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;
+    case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;
+    case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;
+    case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;
+    case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;
+    default: lua_assert(0);
+  }
+}
+
+
+void luaK_fixline (FuncState *fs, int line) {
+  fs->f->lineinfo[fs->pc - 1] = line;
+}
+
+
+static int luaK_code (FuncState *fs, Instruction i, int line) {
+  Proto *f = fs->f;
+  dischargejpc(fs);  /* `pc' will change */
+  /* put new instruction in code array */
+  luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
+                  MAX_INT, "code size overflow");
+  f->code[fs->pc] = i;
+  /* save corresponding line information */
+  luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
+                  MAX_INT, "code size overflow");
+  f->lineinfo[fs->pc] = line;
+  return fs->pc++;
+}
+
+
+int luaK_codeABC (FuncState *fs, OpCode o, int a, int b, int c) {
+  lua_assert(getOpMode(o) == iABC);
+  lua_assert(getBMode(o) != OpArgN || b == 0);
+  lua_assert(getCMode(o) != OpArgN || c == 0);
+  return luaK_code(fs, CREATE_ABC(o, a, b, c), fs->ls->lastline);
+}
+
+
+int luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc) {
+  lua_assert(getOpMode(o) == iABx || getOpMode(o) == iAsBx);
+  lua_assert(getCMode(o) == OpArgN);
+  return luaK_code(fs, CREATE_ABx(o, a, bc), fs->ls->lastline);
+}
+
+
+void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
+  int c =  (nelems - 1)/LFIELDS_PER_FLUSH + 1;
+  int b = (tostore == LUA_MULTRET) ? 0 : tostore;
+  lua_assert(tostore != 0);
+  if (c <= MAXARG_C)
+    luaK_codeABC(fs, OP_SETLIST, base, b, c);
+  else {
+    luaK_codeABC(fs, OP_SETLIST, base, b, 0);
+    luaK_code(fs, cast(Instruction, c), fs->ls->lastline);
+  }
+  fs->freereg = base + 1;  /* free registers with list values */
+}
+

lua/src/lcode.h

@@ -0,0 +1,76 @@
+/*
+** $Id: lcode.h,v 1.48.1.1 2007/12/27 13:02:25 roberto Exp $
+** Code generator for Lua
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lcode_h
+#define lcode_h
+
+#include "llex.h"
+#include "lobject.h"
+#include "lopcodes.h"
+#include "lparser.h"
+
+
+/*
+** Marks the end of a patch list. It is an invalid value both as an absolute
+** address, and as a list link (would link an element to itself).
+*/
+#define NO_JUMP (-1)
+
+
+/*
+** grep "ORDER OPR" if you change these enums
+*/
+typedef enum BinOpr {
+  OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
+  OPR_CONCAT,
+  OPR_NE, OPR_EQ,
+  OPR_LT, OPR_LE, OPR_GT, OPR_GE,
+  OPR_AND, OPR_OR,
+  OPR_NOBINOPR
+} BinOpr;
+
+
+typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
+
+
+#define getcode(fs,e)	((fs)->f->code[(e)->u.s.info])
+
+#define luaK_codeAsBx(fs,o,A,sBx)	luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
+
+#define luaK_setmultret(fs,e)	luaK_setreturns(fs, e, LUA_MULTRET)
+
+LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
+LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
+LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
+LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
+LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
+LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
+LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
+LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r);
+LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
+LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
+LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
+LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
+LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
+LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
+LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
+LUAI_FUNC int luaK_jump (FuncState *fs);
+LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
+LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
+LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
+LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
+LUAI_FUNC int luaK_getlabel (FuncState *fs);
+LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v);
+LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
+LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2);
+LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
+
+
+#endif

lua/src/ldblib.c

@@ -0,0 +1,397 @@
+/*
+** $Id: ldblib.c,v 1.104.1.3 2008/01/21 13:11:21 roberto Exp $
+** Interface from Lua to its debug API
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define ldblib_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "lualib.h"
+
+
+
+static int db_getregistry (lua_State *L) {
+  lua_pushvalue(L, LUA_REGISTRYINDEX);
+  return 1;
+}
+
+
+static int db_getmetatable (lua_State *L) {
+  luaL_checkany(L, 1);
+  if (!lua_getmetatable(L, 1)) {
+    lua_pushnil(L);  /* no metatable */
+  }
+  return 1;
+}
+
+
+static int db_setmetatable (lua_State *L) {
+  int t = lua_type(L, 2);
+  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
+                    "nil or table expected");
+  lua_settop(L, 2);
+  lua_pushboolean(L, lua_setmetatable(L, 1));
+  return 1;
+}
+
+
+static int db_getfenv (lua_State *L) {
+  lua_getfenv(L, 1);
+  return 1;
+}
+
+
+static int db_setfenv (lua_State *L) {
+  luaL_checktype(L, 2, LUA_TTABLE);
+  lua_settop(L, 2);
+  if (lua_setfenv(L, 1) == 0)
+    luaL_error(L, LUA_QL("setfenv")
+                  " cannot change environment of given object");
+  return 1;
+}
+
+
+static void settabss (lua_State *L, const char *i, const char *v) {
+  lua_pushstring(L, v);
+  lua_setfield(L, -2, i);
+}
+
+
+static void settabsi (lua_State *L, const char *i, int v) {
+  lua_pushinteger(L, v);
+  lua_setfield(L, -2, i);
+}
+
+
+static lua_State *getthread (lua_State *L, int *arg) {
+  if (lua_isthread(L, 1)) {
+    *arg = 1;
+    return lua_tothread(L, 1);
+  }
+  else {
+    *arg = 0;
+    return L;
+  }
+}
+
+
+static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
+  if (L == L1) {
+    lua_pushvalue(L, -2);
+    lua_remove(L, -3);
+  }
+  else
+    lua_xmove(L1, L, 1);
+  lua_setfield(L, -2, fname);
+}
+
+
+static int db_getinfo (lua_State *L) {
+  lua_Debug ar;
+  int arg;
+  lua_State *L1 = getthread(L, &arg);
+  const char *options = luaL_optstring(L, arg+2, "flnSu");
+  if (lua_isnumber(L, arg+1)) {
+    if (!lua_getstack(L1, (int)lua_tointeger(L, arg+1), &ar)) {
+      lua_pushnil(L);  /* level out of range */
+      return 1;
+    }
+  }
+  else if (lua_isfunction(L, arg+1)) {
+    lua_pushfstring(L, ">%s", options);
+    options = lua_tostring(L, -1);
+    lua_pushvalue(L, arg+1);
+    lua_xmove(L, L1, 1);
+  }
+  else
+    return luaL_argerror(L, arg+1, "function or level expected");
+  if (!lua_getinfo(L1, options, &ar))
+    return luaL_argerror(L, arg+2, "invalid option");
+  lua_createtable(L, 0, 2);
+  if (strchr(options, 'S')) {
+    settabss(L, "source", ar.source);
+    settabss(L, "short_src", ar.short_src);
+    settabsi(L, "linedefined", ar.linedefined);
+    settabsi(L, "lastlinedefined", ar.lastlinedefined);
+    settabss(L, "what", ar.what);
+  }
+  if (strchr(options, 'l'))
+    settabsi(L, "currentline", ar.currentline);
+  if (strchr(options, 'u'))
+    settabsi(L, "nups", ar.nups);
+  if (strchr(options, 'n')) {
+    settabss(L, "name", ar.name);
+    settabss(L, "namewhat", ar.namewhat);
+  }
+  if (strchr(options, 'L'))
+    treatstackoption(L, L1, "activelines");
+  if (strchr(options, 'f'))
+    treatstackoption(L, L1, "func");
+  return 1;  /* return table */
+}
+    
+
+static int db_getlocal (lua_State *L) {
+  int arg;
+  lua_State *L1 = getthread(L, &arg);
+  lua_Debug ar;
+  const char *name;
+  if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
+    return luaL_argerror(L, arg+1, "level out of range");
+  name = lua_getlocal(L1, &ar, luaL_checkint(L, arg+2));
+  if (name) {
+    lua_xmove(L1, L, 1);
+    lua_pushstring(L, name);
+    lua_pushvalue(L, -2);
+    return 2;
+  }
+  else {
+    lua_pushnil(L);
+    return 1;
+  }
+}
+
+
+static int db_setlocal (lua_State *L) {
+  int arg;
+  lua_State *L1 = getthread(L, &arg);
+  lua_Debug ar;
+  if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
+    return luaL_argerror(L, arg+1, "level out of range");
+  luaL_checkany(L, arg+3);
+  lua_settop(L, arg+3);
+  lua_xmove(L, L1, 1);
+  lua_pushstring(L, lua_setlocal(L1, &ar, luaL_checkint(L, arg+2)));
+  return 1;
+}
+
+
+static int auxupvalue (lua_State *L, int get) {
+  const char *name;
+  int n = luaL_checkint(L, 2);
+  luaL_checktype(L, 1, LUA_TFUNCTION);
+  if (lua_iscfunction(L, 1)) return 0;  /* cannot touch C upvalues from Lua */
+  name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
+  if (name == NULL) return 0;
+  lua_pushstring(L, name);
+  lua_insert(L, -(get+1));
+  return get + 1;
+}
+
+
+static int db_getupvalue (lua_State *L) {
+  return auxupvalue(L, 1);
+}
+
+
+static int db_setupvalue (lua_State *L) {
+  luaL_checkany(L, 3);
+  return auxupvalue(L, 0);
+}
+
+
+
+static const char KEY_HOOK = 'h';
+
+
+static void hookf (lua_State *L, lua_Debug *ar) {
+  static const char *const hooknames[] =
+    {"call", "return", "line", "count", "tail return"};
+  lua_pushlightuserdata(L, (void *)&KEY_HOOK);
+  lua_rawget(L, LUA_REGISTRYINDEX);
+  lua_pushlightuserdata(L, L);
+  lua_rawget(L, -2);
+  if (lua_isfunction(L, -1)) {
+    lua_pushstring(L, hooknames[(int)ar->event]);
+    if (ar->currentline >= 0)
+      lua_pushinteger(L, ar->currentline);
+    else lua_pushnil(L);
+    lua_assert(lua_getinfo(L, "lS", ar));
+    lua_call(L, 2, 0);
+  }
+}
+
+
+static int makemask (const char *smask, int count) {
+  int mask = 0;
+  if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
+  if (strchr(smask, 'r')) mask |= LUA_MASKRET;
+  if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
+  if (count > 0) mask |= LUA_MASKCOUNT;
+  return mask;
+}
+
+
+static char *unmakemask (int mask, char *smask) {
+  int i = 0;
+  if (mask & LUA_MASKCALL) smask[i++] = 'c';
+  if (mask & LUA_MASKRET) smask[i++] = 'r';
+  if (mask & LUA_MASKLINE) smask[i++] = 'l';
+  smask[i] = '\0';
+  return smask;
+}
+
+
+static void gethooktable (lua_State *L) {
+  lua_pushlightuserdata(L, (void *)&KEY_HOOK);
+  lua_rawget(L, LUA_REGISTRYINDEX);
+  if (!lua_istable(L, -1)) {
+    lua_pop(L, 1);
+    lua_createtable(L, 0, 1);
+    lua_pushlightuserdata(L, (void *)&KEY_HOOK);
+    lua_pushvalue(L, -2);
+    lua_rawset(L, LUA_REGISTRYINDEX);
+  }
+}
+
+
+static int db_sethook (lua_State *L) {
+  int arg, mask, count;
+  lua_Hook func;
+  lua_State *L1 = getthread(L, &arg);
+  if (lua_isnoneornil(L, arg+1)) {
+    lua_settop(L, arg+1);
+    func = NULL; mask = 0; count = 0;  /* turn off hooks */
+  }
+  else {
+    const char *smask = luaL_checkstring(L, arg+2);
+    luaL_checktype(L, arg+1, LUA_TFUNCTION);
+    count = luaL_optint(L, arg+3, 0);
+    func = hookf; mask = makemask(smask, count);
+  }
+  gethooktable(L);
+  lua_pushlightuserdata(L, L1);
+  lua_pushvalue(L, arg+1);
+  lua_rawset(L, -3);  /* set new hook */
+  lua_pop(L, 1);  /* remove hook table */
+  lua_sethook(L1, func, mask, count);  /* set hooks */
+  return 0;
+}
+
+
+static int db_gethook (lua_State *L) {
+  int arg;
+  lua_State *L1 = getthread(L, &arg);
+  char buff[5];
+  int mask = lua_gethookmask(L1);
+  lua_Hook hook = lua_gethook(L1);
+  if (hook != NULL && hook != hookf)  /* external hook? */
+    lua_pushliteral(L, "external hook");
+  else {
+    gethooktable(L);
+    lua_pushlightuserdata(L, L1);
+    lua_rawget(L, -2);   /* get hook */
+    lua_remove(L, -2);  /* remove hook table */
+  }
+  lua_pushstring(L, unmakemask(mask, buff));
+  lua_pushinteger(L, lua_gethookcount(L1));
+  return 3;
+}
+
+
+static int db_debug (lua_State *L) {
+  for (;;) {
+    char buffer[250];
+    fputs("lua_debug> ", stderr);
+    if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
+        strcmp(buffer, "cont\n") == 0)
+      return 0;
+    if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
+        lua_pcall(L, 0, 0, 0)) {
+      fputs(lua_tostring(L, -1), stderr);
+      fputs("\n", stderr);
+    }
+    lua_settop(L, 0);  /* remove eventual returns */
+  }
+}
+
+
+#define LEVELS1	12	/* size of the first part of the stack */
+#define LEVELS2	10	/* size of the second part of the stack */
+
+static int db_errorfb (lua_State *L) {
+  int level;
+  int firstpart = 1;  /* still before eventual `...' */
+  int arg;
+  lua_State *L1 = getthread(L, &arg);
+  lua_Debug ar;
+  if (lua_isnumber(L, arg+2)) {
+    level = (int)lua_tointeger(L, arg+2);
+    lua_pop(L, 1);
+  }
+  else
+    level = (L == L1) ? 1 : 0;  /* level 0 may be this own function */
+  if (lua_gettop(L) == arg)
+    lua_pushliteral(L, "");
+  else if (!lua_isstring(L, arg+1)) return 1;  /* message is not a string */
+  else lua_pushliteral(L, "\n");
+  lua_pushliteral(L, "stack traceback:");
+  while (lua_getstack(L1, level++, &ar)) {
+    if (level > LEVELS1 && firstpart) {
+      /* no more than `LEVELS2' more levels? */
+      if (!lua_getstack(L1, level+LEVELS2, &ar))
+        level--;  /* keep going */
+      else {
+        lua_pushliteral(L, "\n\t...");  /* too many levels */
+        while (lua_getstack(L1, level+LEVELS2, &ar))  /* find last levels */
+          level++;
+      }
+      firstpart = 0;
+      continue;
+    }
+    lua_pushliteral(L, "\n\t");
+    lua_getinfo(L1, "Snl", &ar);
+    lua_pushfstring(L, "%s:", ar.short_src);
+    if (ar.currentline > 0)
+      lua_pushfstring(L, "%d:", ar.currentline);
+    if (*ar.namewhat != '\0')  /* is there a name? */
+        lua_pushfstring(L, " in function " LUA_QS, ar.name);
+    else {
+      if (*ar.what == 'm')  /* main? */
+        lua_pushfstring(L, " in main chunk");
+      else if (*ar.what == 'C' || *ar.what == 't')
+        lua_pushliteral(L, " ?");  /* C function or tail call */
+      else
+        lua_pushfstring(L, " in function <%s:%d>",
+                           ar.short_src, ar.linedefined);
+    }
+    lua_concat(L, lua_gettop(L) - arg);
+  }
+  lua_concat(L, lua_gettop(L) - arg);
+  return 1;
+}
+
+
+static const luaL_Reg dblib[] = {
+  {"debug", db_debug},
+  {"getfenv", db_getfenv},
+  {"gethook", db_gethook},
+  {"getinfo", db_getinfo},
+  {"getlocal", db_getlocal},
+  {"getregistry", db_getregistry},
+  {"getmetatable", db_getmetatable},
+  {"getupvalue", db_getupvalue},
+  {"setfenv", db_setfenv},
+  {"sethook", db_sethook},
+  {"setlocal", db_setlocal},
+  {"setmetatable", db_setmetatable},
+  {"setupvalue", db_setupvalue},
+  {"traceback", db_errorfb},
+  {NULL, NULL}
+};
+
+
+LUALIB_API int luaopen_debug (lua_State *L) {
+  luaL_register(L, LUA_DBLIBNAME, dblib);
+  return 1;
+}
+

lua/src/ldebug.c

@@ -0,0 +1,638 @@
+/*
+** $Id: ldebug.c,v 2.29.1.6 2008/05/08 16:56:26 roberto Exp $
+** Debug Interface
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <string.h>
+
+
+#define ldebug_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "lapi.h"
+#include "lcode.h"
+#include "ldebug.h"
+#include "ldo.h"
+#include "lfunc.h"
+#include "lobject.h"
+#include "lopcodes.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "ltm.h"
+#include "lvm.h"
+
+
+
+static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name);
+
+
+static int currentpc (lua_State *L, CallInfo *ci) {
+  if (!isLua(ci)) return -1;  /* function is not a Lua function? */
+  if (ci == L->ci)
+    ci->savedpc = L->savedpc;
+  return pcRel(ci->savedpc, ci_func(ci)->l.p);
+}
+
+
+static int currentline (lua_State *L, CallInfo *ci) {
+  int pc = currentpc(L, ci);
+  if (pc < 0)
+    return -1;  /* only active lua functions have current-line information */
+  else
+    return getline(ci_func(ci)->l.p, pc);
+}
+
+
+/*
+** this function can be called asynchronous (e.g. during a signal)
+*/
+LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
+  if (func == NULL || mask == 0) {  /* turn off hooks? */
+    mask = 0;
+    func = NULL;
+  }
+  L->hook = func;
+  L->basehookcount = count;
+  resethookcount(L);
+  L->hookmask = cast_byte(mask);
+  return 1;
+}
+
+
+LUA_API lua_Hook lua_gethook (lua_State *L) {
+  return L->hook;
+}
+
+
+LUA_API int lua_gethookmask (lua_State *L) {
+  return L->hookmask;
+}
+
+
+LUA_API int lua_gethookcount (lua_State *L) {
+  return L->basehookcount;
+}
+
+
+LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
+  int status;
+  CallInfo *ci;
+  lua_lock(L);
+  for (ci = L->ci; level > 0 && ci > L->base_ci; ci--) {
+    level--;
+    if (f_isLua(ci))  /* Lua function? */
+      level -= ci->tailcalls;  /* skip lost tail calls */
+  }
+  if (level == 0 && ci > L->base_ci) {  /* level found? */
+    status = 1;
+    ar->i_ci = cast_int(ci - L->base_ci);
+  }
+  else if (level < 0) {  /* level is of a lost tail call? */
+    status = 1;
+    ar->i_ci = 0;
+  }
+  else status = 0;  /* no such level */
+  lua_unlock(L);
+  return status;
+}
+
+
+static Proto *getluaproto (CallInfo *ci) {
+  return (isLua(ci) ? ci_func(ci)->l.p : NULL);
+}
+
+
+static const char *findlocal (lua_State *L, CallInfo *ci, int n) {
+  const char *name;
+  Proto *fp = getluaproto(ci);
+  if (fp && (name = luaF_getlocalname(fp, n, currentpc(L, ci))) != NULL)
+    return name;  /* is a local variable in a Lua function */
+  else {
+    StkId limit = (ci == L->ci) ? L->top : (ci+1)->func;
+    if (limit - ci->base >= n && n > 0)  /* is 'n' inside 'ci' stack? */
+      return "(*temporary)";
+    else
+      return NULL;
+  }
+}
+
+
+LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
+  CallInfo *ci = L->base_ci + ar->i_ci;
+  const char *name = findlocal(L, ci, n);
+  lua_lock(L);
+  if (name)
+      luaA_pushobject(L, ci->base + (n - 1));
+  lua_unlock(L);
+  return name;
+}
+
+
+LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
+  CallInfo *ci = L->base_ci + ar->i_ci;
+  const char *name = findlocal(L, ci, n);
+  lua_lock(L);
+  if (name)
+      setobjs2s(L, ci->base + (n - 1), L->top - 1);
+  L->top--;  /* pop value */
+  lua_unlock(L);
+  return name;
+}
+
+
+static void funcinfo (lua_Debug *ar, Closure *cl) {
+  if (cl->c.isC) {
+    ar->source = "=[C]";
+    ar->linedefined = -1;
+    ar->lastlinedefined = -1;
+    ar->what = "C";
+  }
+  else {
+    ar->source = getstr(cl->l.p->source);
+    ar->linedefined = cl->l.p->linedefined;
+    ar->lastlinedefined = cl->l.p->lastlinedefined;
+    ar->what = (ar->linedefined == 0) ? "main" : "Lua";
+  }
+  luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
+}
+
+
+static void info_tailcall (lua_Debug *ar) {
+  ar->name = ar->namewhat = "";
+  ar->what = "tail";
+  ar->lastlinedefined = ar->linedefined = ar->currentline = -1;
+  ar->source = "=(tail call)";
+  luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
+  ar->nups = 0;
+}
+
+
+static void collectvalidlines (lua_State *L, Closure *f) {
+  if (f == NULL || f->c.isC) {
+    setnilvalue(L->top);
+  }
+  else {
+    Table *t = luaH_new(L, 0, 0);
+    int *lineinfo = f->l.p->lineinfo;
+    int i;
+    for (i=0; i<f->l.p->sizelineinfo; i++)
+      setbvalue(luaH_setnum(L, t, lineinfo[i]), 1);
+    sethvalue(L, L->top, t); 
+  }
+  incr_top(L);
+}
+
+
+static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,
+                    Closure *f, CallInfo *ci) {
+  int status = 1;
+  if (f == NULL) {
+    info_tailcall(ar);
+    return status;
+  }
+  for (; *what; what++) {
+    switch (*what) {
+      case 'S': {
+        funcinfo(ar, f);
+        break;
+      }
+      case 'l': {
+        ar->currentline = (ci) ? currentline(L, ci) : -1;
+        break;
+      }
+      case 'u': {
+        ar->nups = f->c.nupvalues;
+        break;
+      }
+      case 'n': {
+        ar->namewhat = (ci) ? getfuncname(L, ci, &ar->name) : NULL;
+        if (ar->namewhat == NULL) {
+          ar->namewhat = "";  /* not found */
+          ar->name = NULL;
+        }
+        break;
+      }
+      case 'L':
+      case 'f':  /* handled by lua_getinfo */
+        break;
+      default: status = 0;  /* invalid option */
+    }
+  }
+  return status;
+}
+
+
+LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
+  int status;
+  Closure *f = NULL;
+  CallInfo *ci = NULL;
+  lua_lock(L);
+  if (*what == '>') {
+    StkId func = L->top - 1;
+    luai_apicheck(L, ttisfunction(func));
+    what++;  /* skip the '>' */
+    f = clvalue(func);
+    L->top--;  /* pop function */
+  }
+  else if (ar->i_ci != 0) {  /* no tail call? */
+    ci = L->base_ci + ar->i_ci;
+    lua_assert(ttisfunction(ci->func));
+    f = clvalue(ci->func);
+  }
+  status = auxgetinfo(L, what, ar, f, ci);
+  if (strchr(what, 'f')) {
+    if (f == NULL) setnilvalue(L->top);
+    else setclvalue(L, L->top, f);
+    incr_top(L);
+  }
+  if (strchr(what, 'L'))
+    collectvalidlines(L, f);
+  lua_unlock(L);
+  return status;
+}
+
+
+/*
+** {======================================================
+** Symbolic Execution and code checker
+** =======================================================
+*/
+
+#define check(x)		if (!(x)) return 0;
+
+#define checkjump(pt,pc)	check(0 <= pc && pc < pt->sizecode)
+
+#define checkreg(pt,reg)	check((reg) < (pt)->maxstacksize)
+
+
+
+static int precheck (const Proto *pt) {
+  check(pt->maxstacksize <= MAXSTACK);
+  check(pt->numparams+(pt->is_vararg & VARARG_HASARG) <= pt->maxstacksize);
+  check(!(pt->is_vararg & VARARG_NEEDSARG) ||
+              (pt->is_vararg & VARARG_HASARG));
+  check(pt->sizeupvalues <= pt->nups);
+  check(pt->sizelineinfo == pt->sizecode || pt->sizelineinfo == 0);
+  check(pt->sizecode > 0 && GET_OPCODE(pt->code[pt->sizecode-1]) == OP_RETURN);
+  return 1;
+}
+
+
+#define checkopenop(pt,pc)	luaG_checkopenop((pt)->code[(pc)+1])
+
+int luaG_checkopenop (Instruction i) {
+  switch (GET_OPCODE(i)) {
+    case OP_CALL:
+    case OP_TAILCALL:
+    case OP_RETURN:
+    case OP_SETLIST: {
+      check(GETARG_B(i) == 0);
+      return 1;
+    }
+    default: return 0;  /* invalid instruction after an open call */
+  }
+}
+
+
+static int checkArgMode (const Proto *pt, int r, enum OpArgMask mode) {
+  switch (mode) {
+    case OpArgN: check(r == 0); break;
+    case OpArgU: break;
+    case OpArgR: checkreg(pt, r); break;
+    case OpArgK:
+      check(ISK(r) ? INDEXK(r) < pt->sizek : r < pt->maxstacksize);
+      break;
+  }
+  return 1;
+}
+
+
+static Instruction symbexec (const Proto *pt, int lastpc, int reg) {
+  int pc;
+  int last;  /* stores position of last instruction that changed `reg' */
+  last = pt->sizecode-1;  /* points to final return (a `neutral' instruction) */
+  check(precheck(pt));
+  for (pc = 0; pc < lastpc; pc++) {
+    Instruction i = pt->code[pc];
+    OpCode op = GET_OPCODE(i);
+    int a = GETARG_A(i);
+    int b = 0;
+    int c = 0;
+    check(op < NUM_OPCODES);
+    checkreg(pt, a);
+    switch (getOpMode(op)) {
+      case iABC: {
+        b = GETARG_B(i);
+        c = GETARG_C(i);
+        check(checkArgMode(pt, b, getBMode(op)));
+        check(checkArgMode(pt, c, getCMode(op)));
+        break;
+      }
+      case iABx: {
+        b = GETARG_Bx(i);
+        if (getBMode(op) == OpArgK) check(b < pt->sizek);
+        break;
+      }
+      case iAsBx: {
+        b = GETARG_sBx(i);
+        if (getBMode(op) == OpArgR) {
+          int dest = pc+1+b;
+          check(0 <= dest && dest < pt->sizecode);
+          if (dest > 0) {
+            int j;
+            /* check that it does not jump to a setlist count; this
+               is tricky, because the count from a previous setlist may
+               have the same value of an invalid setlist; so, we must
+               go all the way back to the first of them (if any) */
+            for (j = 0; j < dest; j++) {
+              Instruction d = pt->code[dest-1-j];
+              if (!(GET_OPCODE(d) == OP_SETLIST && GETARG_C(d) == 0)) break;
+            }
+            /* if 'j' is even, previous value is not a setlist (even if
+               it looks like one) */
+            check((j&1) == 0);
+          }
+        }
+        break;
+      }
+    }
+    if (testAMode(op)) {
+      if (a == reg) last = pc;  /* change register `a' */
+    }
+    if (testTMode(op)) {
+      check(pc+2 < pt->sizecode);  /* check skip */
+      check(GET_OPCODE(pt->code[pc+1]) == OP_JMP);
+    }
+    switch (op) {
+      case OP_LOADBOOL: {
+        if (c == 1) {  /* does it jump? */
+          check(pc+2 < pt->sizecode);  /* check its jump */
+          check(GET_OPCODE(pt->code[pc+1]) != OP_SETLIST ||
+                GETARG_C(pt->code[pc+1]) != 0);
+        }
+        break;
+      }
+      case OP_LOADNIL: {
+        if (a <= reg && reg <= b)
+          last = pc;  /* set registers from `a' to `b' */
+        break;
+      }
+      case OP_GETUPVAL:
+      case OP_SETUPVAL: {
+        check(b < pt->nups);
+        break;
+      }
+      case OP_GETGLOBAL:
+      case OP_SETGLOBAL: {
+        check(ttisstring(&pt->k[b]));
+        break;
+      }
+      case OP_SELF: {
+        checkreg(pt, a+1);
+        if (reg == a+1) last = pc;
+        break;
+      }
+      case OP_CONCAT: {
+        check(b < c);  /* at least two operands */
+        break;
+      }
+      case OP_TFORLOOP: {
+        check(c >= 1);  /* at least one result (control variable) */
+        checkreg(pt, a+2+c);  /* space for results */
+        if (reg >= a+2) last = pc;  /* affect all regs above its base */
+        break;
+      }
+      case OP_FORLOOP:
+      case OP_FORPREP:
+        checkreg(pt, a+3);
+        /* go through */
+      case OP_JMP: {
+        int dest = pc+1+b;
+        /* not full check and jump is forward and do not skip `lastpc'? */
+        if (reg != NO_REG && pc < dest && dest <= lastpc)
+          pc += b;  /* do the jump */
+        break;
+      }
+      case OP_CALL:
+      case OP_TAILCALL: {
+        if (b != 0) {
+          checkreg(pt, a+b-1);
+        }
+        c--;  /* c = num. returns */
+        if (c == LUA_MULTRET) {
+          check(checkopenop(pt, pc));
+        }
+        else if (c != 0)
+          checkreg(pt, a+c-1);
+        if (reg >= a) last = pc;  /* affect all registers above base */
+        break;
+      }
+      case OP_RETURN: {
+        b--;  /* b = num. returns */
+        if (b > 0) checkreg(pt, a+b-1);
+        break;
+      }
+      case OP_SETLIST: {
+        if (b > 0) checkreg(pt, a + b);
+        if (c == 0) {
+          pc++;
+          check(pc < pt->sizecode - 1);
+        }
+        break;
+      }
+      case OP_CLOSURE: {
+        int nup, j;
+        check(b < pt->sizep);
+        nup = pt->p[b]->nups;
+        check(pc + nup < pt->sizecode);
+        for (j = 1; j <= nup; j++) {
+          OpCode op1 = GET_OPCODE(pt->code[pc + j]);
+          check(op1 == OP_GETUPVAL || op1 == OP_MOVE);
+        }
+        if (reg != NO_REG)  /* tracing? */
+          pc += nup;  /* do not 'execute' these pseudo-instructions */
+        break;
+      }
+      case OP_VARARG: {
+        check((pt->is_vararg & VARARG_ISVARARG) &&
+             !(pt->is_vararg & VARARG_NEEDSARG));
+        b--;
+        if (b == LUA_MULTRET) check(checkopenop(pt, pc));
+        checkreg(pt, a+b-1);
+        break;
+      }
+      default: break;
+    }
+  }
+  return pt->code[last];
+}
+
+#undef check
+#undef checkjump
+#undef checkreg
+
+/* }====================================================== */
+
+
+int luaG_checkcode (const Proto *pt) {
+  return (symbexec(pt, pt->sizecode, NO_REG) != 0);
+}
+
+
+static const char *kname (Proto *p, int c) {
+  if (ISK(c) && ttisstring(&p->k[INDEXK(c)]))
+    return svalue(&p->k[INDEXK(c)]);
+  else
+    return "?";
+}
+
+
+static const char *getobjname (lua_State *L, CallInfo *ci, int stackpos,
+                               const char **name) {
+  if (isLua(ci)) {  /* a Lua function? */
+    Proto *p = ci_func(ci)->l.p;
+    int pc = currentpc(L, ci);
+    Instruction i;
+    *name = luaF_getlocalname(p, stackpos+1, pc);
+    if (*name)  /* is a local? */
+      return "local";
+    i = symbexec(p, pc, stackpos);  /* try symbolic execution */
+    lua_assert(pc != -1);
+    switch (GET_OPCODE(i)) {
+      case OP_GETGLOBAL: {
+        int g = GETARG_Bx(i);  /* global index */
+        lua_assert(ttisstring(&p->k[g]));
+        *name = svalue(&p->k[g]);
+        return "global";
+      }
+      case OP_MOVE: {
+        int a = GETARG_A(i);
+        int b = GETARG_B(i);  /* move from `b' to `a' */
+        if (b < a)
+          return getobjname(L, ci, b, name);  /* get name for `b' */
+        break;
+      }
+      case OP_GETTABLE: {
+        int k = GETARG_C(i);  /* key index */
+        *name = kname(p, k);
+        return "field";
+      }
+      case OP_GETUPVAL: {
+        int u = GETARG_B(i);  /* upvalue index */
+        *name = p->upvalues ? getstr(p->upvalues[u]) : "?";
+        return "upvalue";
+      }
+      case OP_SELF: {
+        int k = GETARG_C(i);  /* key index */
+        *name = kname(p, k);
+        return "method";
+      }
+      default: break;
+    }
+  }
+  return NULL;  /* no useful name found */
+}
+
+
+static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
+  Instruction i;
+  if ((isLua(ci) && ci->tailcalls > 0) || !isLua(ci - 1))
+    return NULL;  /* calling function is not Lua (or is unknown) */
+  ci--;  /* calling function */
+  i = ci_func(ci)->l.p->code[currentpc(L, ci)];
+  if (GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL ||
+      GET_OPCODE(i) == OP_TFORLOOP)
+    return getobjname(L, ci, GETARG_A(i), name);
+  else
+    return NULL;  /* no useful name can be found */
+}
+
+
+/* only ANSI way to check whether a pointer points to an array */
+static int isinstack (CallInfo *ci, const TValue *o) {
+  StkId p;
+  for (p = ci->base; p < ci->top; p++)
+    if (o == p) return 1;
+  return 0;
+}
+
+
+void luaG_typeerror (lua_State *L, const TValue *o, const char *op) {
+  const char *name = NULL;
+  const char *t = luaT_typenames[ttype(o)];
+  const char *kind = (isinstack(L->ci, o)) ?
+                         getobjname(L, L->ci, cast_int(o - L->base), &name) :
+                         NULL;
+  if (kind)
+    luaG_runerror(L, "attempt to %s %s " LUA_QS " (a %s value)",
+                op, kind, name, t);
+  else
+    luaG_runerror(L, "attempt to %s a %s value", op, t);
+}
+
+
+void luaG_concaterror (lua_State *L, StkId p1, StkId p2) {
+  if (ttisstring(p1) || ttisnumber(p1)) p1 = p2;
+  lua_assert(!ttisstring(p1) && !ttisnumber(p1));
+  luaG_typeerror(L, p1, "concatenate");
+}
+
+
+void luaG_aritherror (lua_State *L, const TValue *p1, const TValue *p2) {
+  TValue temp;
+  if (luaV_tonumber(p1, &temp) == NULL)
+    p2 = p1;  /* first operand is wrong */
+  luaG_typeerror(L, p2, "perform arithmetic on");
+}
+
+
+int luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
+  const char *t1 = luaT_typenames[ttype(p1)];
+  const char *t2 = luaT_typenames[ttype(p2)];
+  if (t1[2] == t2[2])
+    luaG_runerror(L, "attempt to compare two %s values", t1);
+  else
+    luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
+  return 0;
+}
+
+
+static void addinfo (lua_State *L, const char *msg) {
+  CallInfo *ci = L->ci;
+  if (isLua(ci)) {  /* is Lua code? */
+    char buff[LUA_IDSIZE];  /* add file:line information */
+    int line = currentline(L, ci);
+    luaO_chunkid(buff, getstr(getluaproto(ci)->source), LUA_IDSIZE);
+    luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);
+  }
+}
+
+
+void luaG_errormsg (lua_State *L) {
+  if (L->errfunc != 0) {  /* is there an error handling function? */
+    StkId errfunc = restorestack(L, L->errfunc);
+    if (!ttisfunction(errfunc)) luaD_throw(L, LUA_ERRERR);
+    setobjs2s(L, L->top, L->top - 1);  /* move argument */
+    setobjs2s(L, L->top - 1, errfunc);  /* push function */
+    incr_top(L);
+    luaD_call(L, L->top - 2, 1);  /* call it */
+  }
+  luaD_throw(L, LUA_ERRRUN);
+}
+
+
+void luaG_runerror (lua_State *L, const char *fmt, ...) {
+  va_list argp;
+  va_start(argp, fmt);
+  addinfo(L, luaO_pushvfstring(L, fmt, argp));
+  va_end(argp);
+  luaG_errormsg(L);
+}
+

lua/src/ldebug.h

@@ -0,0 +1,33 @@
+/*
+** $Id: ldebug.h,v 2.3.1.1 2007/12/27 13:02:25 roberto Exp $
+** Auxiliary functions from Debug Interface module
+** See Copyright Notice in lua.h
+*/
+
+#ifndef ldebug_h
+#define ldebug_h
+
+
+#include "lstate.h"
+
+
+#define pcRel(pc, p)	(cast(int, (pc) - (p)->code) - 1)
+
+#define getline(f,pc)	(((f)->lineinfo) ? (f)->lineinfo[pc] : 0)
+
+#define resethookcount(L)	(L->hookcount = L->basehookcount)
+
+
+LUAI_FUNC void luaG_typeerror (lua_State *L, const TValue *o,
+                                             const char *opname);
+LUAI_FUNC void luaG_concaterror (lua_State *L, StkId p1, StkId p2);
+LUAI_FUNC void luaG_aritherror (lua_State *L, const TValue *p1,
+                                              const TValue *p2);
+LUAI_FUNC int luaG_ordererror (lua_State *L, const TValue *p1,
+                                             const TValue *p2);
+LUAI_FUNC void luaG_runerror (lua_State *L, const char *fmt, ...);
+LUAI_FUNC void luaG_errormsg (lua_State *L);
+LUAI_FUNC int luaG_checkcode (const Proto *pt);
+LUAI_FUNC int luaG_checkopenop (Instruction i);
+
+#endif

lua/src/ldo.c

@@ -0,0 +1,518 @@
+/*
+** $Id: ldo.c,v 2.38.1.3 2008/01/18 22:31:22 roberto Exp $
+** Stack and Call structure of Lua
+** See Copyright Notice in lua.h
+*/
+
+
+#include <setjmp.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define ldo_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "ldebug.h"
+#include "ldo.h"
+#include "lfunc.h"
+#include "lgc.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lopcodes.h"
+#include "lparser.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "ltm.h"
+#include "lundump.h"
+#include "lvm.h"
+#include "lzio.h"
+
+
+
+
+/*
+** {======================================================
+** Error-recovery functions
+** =======================================================
+*/
+
+
+/* chain list of long jump buffers */
+struct lua_longjmp {
+  struct lua_longjmp *previous;
+  luai_jmpbuf b;
+  volatile int status;  /* error code */
+};
+
+
+void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) {
+  switch (errcode) {
+    case LUA_ERRMEM: {
+      setsvalue2s(L, oldtop, luaS_newliteral(L, MEMERRMSG));
+      break;
+    }
+    case LUA_ERRERR: {
+      setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));
+      break;
+    }
+    case LUA_ERRSYNTAX:
+    case LUA_ERRRUN: {
+      setobjs2s(L, oldtop, L->top - 1);  /* error message on current top */
+      break;
+    }
+  }
+  L->top = oldtop + 1;
+}
+
+
+static void restore_stack_limit (lua_State *L) {
+  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
+  if (L->size_ci > LUAI_MAXCALLS) {  /* there was an overflow? */
+    int inuse = cast_int(L->ci - L->base_ci);
+    if (inuse + 1 < LUAI_MAXCALLS)  /* can `undo' overflow? */
+      luaD_reallocCI(L, LUAI_MAXCALLS);
+  }
+}
+
+
+static void resetstack (lua_State *L, int status) {
+  L->ci = L->base_ci;
+  L->base = L->ci->base;
+  luaF_close(L, L->base);  /* close eventual pending closures */
+  luaD_seterrorobj(L, status, L->base);
+  L->nCcalls = L->baseCcalls;
+  L->allowhook = 1;
+  restore_stack_limit(L);
+  L->errfunc = 0;
+  L->errorJmp = NULL;
+}
+
+
+void luaD_throw (lua_State *L, int errcode) {
+  if (L->errorJmp) {
+    L->errorJmp->status = errcode;
+    LUAI_THROW(L, L->errorJmp);
+  }
+  else {
+    L->status = cast_byte(errcode);
+    if (G(L)->panic) {
+      resetstack(L, errcode);
+      lua_unlock(L);
+      G(L)->panic(L);
+    }
+    exit(EXIT_FAILURE);
+  }
+}
+
+
+int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
+  struct lua_longjmp lj;
+  lj.status = 0;
+  lj.previous = L->errorJmp;  /* chain new error handler */
+  L->errorJmp = &lj;
+  LUAI_TRY(L, &lj,
+    (*f)(L, ud);
+  );
+  L->errorJmp = lj.previous;  /* restore old error handler */
+  return lj.status;
+}
+
+/* }====================================================== */
+
+
+static void correctstack (lua_State *L, TValue *oldstack) {
+  CallInfo *ci;
+  GCObject *up;
+  L->top = (L->top - oldstack) + L->stack;
+  for (up = L->openupval; up != NULL; up = up->gch.next)
+    gco2uv(up)->v = (gco2uv(up)->v - oldstack) + L->stack;
+  for (ci = L->base_ci; ci <= L->ci; ci++) {
+    ci->top = (ci->top - oldstack) + L->stack;
+    ci->base = (ci->base - oldstack) + L->stack;
+    ci->func = (ci->func - oldstack) + L->stack;
+  }
+  L->base = (L->base - oldstack) + L->stack;
+}
+
+
+void luaD_reallocstack (lua_State *L, int newsize) {
+  TValue *oldstack = L->stack;
+  int realsize = newsize + 1 + EXTRA_STACK;
+  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
+  luaM_reallocvector(L, L->stack, L->stacksize, realsize, TValue);
+  L->stacksize = realsize;
+  L->stack_last = L->stack+newsize;
+  correctstack(L, oldstack);
+}
+
+
+void luaD_reallocCI (lua_State *L, int newsize) {
+  CallInfo *oldci = L->base_ci;
+  luaM_reallocvector(L, L->base_ci, L->size_ci, newsize, CallInfo);
+  L->size_ci = newsize;
+  L->ci = (L->ci - oldci) + L->base_ci;
+  L->end_ci = L->base_ci + L->size_ci - 1;
+}
+
+
+void luaD_growstack (lua_State *L, int n) {
+  if (n <= L->stacksize)  /* double size is enough? */
+    luaD_reallocstack(L, 2*L->stacksize);
+  else
+    luaD_reallocstack(L, L->stacksize + n);
+}
+
+
+static CallInfo *growCI (lua_State *L) {
+  if (L->size_ci > LUAI_MAXCALLS)  /* overflow while handling overflow? */
+    luaD_throw(L, LUA_ERRERR);
+  else {
+    luaD_reallocCI(L, 2*L->size_ci);
+    if (L->size_ci > LUAI_MAXCALLS)
+      luaG_runerror(L, "stack overflow");
+  }
+  return ++L->ci;
+}
+
+
+void luaD_callhook (lua_State *L, int event, int line) {
+  lua_Hook hook = L->hook;
+  if (hook && L->allowhook) {
+    ptrdiff_t top = savestack(L, L->top);
+    ptrdiff_t ci_top = savestack(L, L->ci->top);
+    lua_Debug ar;
+    ar.event = event;
+    ar.currentline = line;
+    if (event == LUA_HOOKTAILRET)
+      ar.i_ci = 0;  /* tail call; no debug information about it */
+    else
+      ar.i_ci = cast_int(L->ci - L->base_ci);
+    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
+    L->ci->top = L->top + LUA_MINSTACK;
+    lua_assert(L->ci->top <= L->stack_last);
+    L->allowhook = 0;  /* cannot call hooks inside a hook */
+    lua_unlock(L);
+    (*hook)(L, &ar);
+    lua_lock(L);
+    lua_assert(!L->allowhook);
+    L->allowhook = 1;
+    L->ci->top = restorestack(L, ci_top);
+    L->top = restorestack(L, top);
+  }
+}
+
+
+static StkId adjust_varargs (lua_State *L, Proto *p, int actual) {
+  int i;
+  int nfixargs = p->numparams;
+  Table *htab = NULL;
+  StkId base, fixed;
+  for (; actual < nfixargs; ++actual)
+    setnilvalue(L->top++);
+#if defined(LUA_COMPAT_VARARG)
+  if (p->is_vararg & VARARG_NEEDSARG) { /* compat. with old-style vararg? */
+    int nvar = actual - nfixargs;  /* number of extra arguments */
+    lua_assert(p->is_vararg & VARARG_HASARG);
+    luaC_checkGC(L);
+    htab = luaH_new(L, nvar, 1);  /* create `arg' table */
+    for (i=0; i<nvar; i++)  /* put extra arguments into `arg' table */
+      setobj2n(L, luaH_setnum(L, htab, i+1), L->top - nvar + i);
+    /* store counter in field `n' */
+    setnvalue(luaH_setstr(L, htab, luaS_newliteral(L, "n")), cast_num(nvar));
+  }
+#endif
+  /* move fixed parameters to final position */
+  fixed = L->top - actual;  /* first fixed argument */
+  base = L->top;  /* final position of first argument */
+  for (i=0; i<nfixargs; i++) {
+    setobjs2s(L, L->top++, fixed+i);
+    setnilvalue(fixed+i);
+  }
+  /* add `arg' parameter */
+  if (htab) {
+    sethvalue(L, L->top++, htab);
+    lua_assert(iswhite(obj2gco(htab)));
+  }
+  return base;
+}
+
+
+static StkId tryfuncTM (lua_State *L, StkId func) {
+  const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL);
+  StkId p;
+  ptrdiff_t funcr = savestack(L, func);
+  if (!ttisfunction(tm))
+    luaG_typeerror(L, func, "call");
+  /* Open a hole inside the stack at `func' */
+  for (p = L->top; p > func; p--) setobjs2s(L, p, p-1);
+  incr_top(L);
+  func = restorestack(L, funcr);  /* previous call may change stack */
+  setobj2s(L, func, tm);  /* tag method is the new function to be called */
+  return func;
+}
+
+
+
+#define inc_ci(L) \
+  ((L->ci == L->end_ci) ? growCI(L) : \
+   (condhardstacktests(luaD_reallocCI(L, L->size_ci)), ++L->ci))
+
+
+int luaD_precall (lua_State *L, StkId func, int nresults) {
+  LClosure *cl;
+  ptrdiff_t funcr;
+  if (!ttisfunction(func)) /* `func' is not a function? */
+    func = tryfuncTM(L, func);  /* check the `function' tag method */
+  funcr = savestack(L, func);
+  cl = &clvalue(func)->l;
+  L->ci->savedpc = L->savedpc;
+  if (!cl->isC) {  /* Lua function? prepare its call */
+    CallInfo *ci;
+    StkId st, base;
+    Proto *p = cl->p;
+    luaD_checkstack(L, p->maxstacksize);
+    func = restorestack(L, funcr);
+    if (!p->is_vararg) {  /* no varargs? */
+      base = func + 1;
+      if (L->top > base + p->numparams)
+        L->top = base + p->numparams;
+    }
+    else {  /* vararg function */
+      int nargs = cast_int(L->top - func) - 1;
+      base = adjust_varargs(L, p, nargs);
+      func = restorestack(L, funcr);  /* previous call may change the stack */
+    }
+    ci = inc_ci(L);  /* now `enter' new function */
+    ci->func = func;
+    L->base = ci->base = base;
+    ci->top = L->base + p->maxstacksize;
+    lua_assert(ci->top <= L->stack_last);
+    L->savedpc = p->code;  /* starting point */
+    ci->tailcalls = 0;
+    ci->nresults = nresults;
+    for (st = L->top; st < ci->top; st++)
+      setnilvalue(st);
+    L->top = ci->top;
+    if (L->hookmask & LUA_MASKCALL) {
+      L->savedpc++;  /* hooks assume 'pc' is already incremented */
+      luaD_callhook(L, LUA_HOOKCALL, -1);
+      L->savedpc--;  /* correct 'pc' */
+    }
+    return PCRLUA;
+  }
+  else {  /* if is a C function, call it */
+    CallInfo *ci;
+    int n;
+    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
+    ci = inc_ci(L);  /* now `enter' new function */
+    ci->func = restorestack(L, funcr);
+    L->base = ci->base = ci->func + 1;
+    ci->top = L->top + LUA_MINSTACK;
+    lua_assert(ci->top <= L->stack_last);
+    ci->nresults = nresults;
+    if (L->hookmask & LUA_MASKCALL)
+      luaD_callhook(L, LUA_HOOKCALL, -1);
+    lua_unlock(L);
+    n = (*curr_func(L)->c.f)(L);  /* do the actual call */
+    lua_lock(L);
+    if (n < 0)  /* yielding? */
+      return PCRYIELD;
+    else {
+      luaD_poscall(L, L->top - n);
+      return PCRC;
+    }
+  }
+}
+
+
+static StkId callrethooks (lua_State *L, StkId firstResult) {
+  ptrdiff_t fr = savestack(L, firstResult);  /* next call may change stack */
+  luaD_callhook(L, LUA_HOOKRET, -1);
+  if (f_isLua(L->ci)) {  /* Lua function? */
+    while ((L->hookmask & LUA_MASKRET) && L->ci->tailcalls--) /* tail calls */
+      luaD_callhook(L, LUA_HOOKTAILRET, -1);
+  }
+  return restorestack(L, fr);
+}
+
+
+int luaD_poscall (lua_State *L, StkId firstResult) {
+  StkId res;
+  int wanted, i;
+  CallInfo *ci;
+  if (L->hookmask & LUA_MASKRET)
+    firstResult = callrethooks(L, firstResult);
+  ci = L->ci--;
+  res = ci->func;  /* res == final position of 1st result */
+  wanted = ci->nresults;
+  L->base = (ci - 1)->base;  /* restore base */
+  L->savedpc = (ci - 1)->savedpc;  /* restore savedpc */
+  /* move results to correct place */
+  for (i = wanted; i != 0 && firstResult < L->top; i--)
+    setobjs2s(L, res++, firstResult++);
+  while (i-- > 0)
+    setnilvalue(res++);
+  L->top = res;
+  return (wanted - LUA_MULTRET);  /* 0 iff wanted == LUA_MULTRET */
+}
+
+
+/*
+** Call a function (C or Lua). The function to be called is at *func.
+** The arguments are on the stack, right after the function.
+** When returns, all the results are on the stack, starting at the original
+** function position.
+*/ 
+void luaD_call (lua_State *L, StkId func, int nResults) {
+  if (++L->nCcalls >= LUAI_MAXCCALLS) {
+    if (L->nCcalls == LUAI_MAXCCALLS)
+      luaG_runerror(L, "C stack overflow");
+    else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
+      luaD_throw(L, LUA_ERRERR);  /* error while handing stack error */
+  }
+  if (luaD_precall(L, func, nResults) == PCRLUA)  /* is a Lua function? */
+    luaV_execute(L, 1);  /* call it */
+  L->nCcalls--;
+  luaC_checkGC(L);
+}
+
+
+static void resume (lua_State *L, void *ud) {
+  StkId firstArg = cast(StkId, ud);
+  CallInfo *ci = L->ci;
+  if (L->status == 0) {  /* start coroutine? */
+    lua_assert(ci == L->base_ci && firstArg > L->base);
+    if (luaD_precall(L, firstArg - 1, LUA_MULTRET) != PCRLUA)
+      return;
+  }
+  else {  /* resuming from previous yield */
+    lua_assert(L->status == LUA_YIELD);
+    L->status = 0;
+    if (!f_isLua(ci)) {  /* `common' yield? */
+      /* finish interrupted execution of `OP_CALL' */
+      lua_assert(GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_CALL ||
+                 GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_TAILCALL);
+      if (luaD_poscall(L, firstArg))  /* complete it... */
+        L->top = L->ci->top;  /* and correct top if not multiple results */
+    }
+    else  /* yielded inside a hook: just continue its execution */
+      L->base = L->ci->base;
+  }
+  luaV_execute(L, cast_int(L->ci - L->base_ci));
+}
+
+
+static int resume_error (lua_State *L, const char *msg) {
+  L->top = L->ci->base;
+  setsvalue2s(L, L->top, luaS_new(L, msg));
+  incr_top(L);
+  lua_unlock(L);
+  return LUA_ERRRUN;
+}
+
+
+LUA_API int lua_resume (lua_State *L, int nargs) {
+  int status;
+  lua_lock(L);
+  if (L->status != LUA_YIELD && (L->status != 0 || L->ci != L->base_ci))
+      return resume_error(L, "cannot resume non-suspended coroutine");
+  if (L->nCcalls >= LUAI_MAXCCALLS)
+    return resume_error(L, "C stack overflow");
+  luai_userstateresume(L, nargs);
+  lua_assert(L->errfunc == 0);
+  L->baseCcalls = ++L->nCcalls;
+  status = luaD_rawrunprotected(L, resume, L->top - nargs);
+  if (status != 0) {  /* error? */
+    L->status = cast_byte(status);  /* mark thread as `dead' */
+    luaD_seterrorobj(L, status, L->top);
+    L->ci->top = L->top;
+  }
+  else {
+    lua_assert(L->nCcalls == L->baseCcalls);
+    status = L->status;
+  }
+  --L->nCcalls;
+  lua_unlock(L);
+  return status;
+}
+
+
+LUA_API int lua_yield (lua_State *L, int nresults) {
+  luai_userstateyield(L, nresults);
+  lua_lock(L);
+  if (L->nCcalls > L->baseCcalls)
+    luaG_runerror(L, "attempt to yield across metamethod/C-call boundary");
+  L->base = L->top - nresults;  /* protect stack slots below */
+  L->status = LUA_YIELD;
+  lua_unlock(L);
+  return -1;
+}
+
+
+int luaD_pcall (lua_State *L, Pfunc func, void *u,
+                ptrdiff_t old_top, ptrdiff_t ef) {
+  int status;
+  unsigned short oldnCcalls = L->nCcalls;
+  ptrdiff_t old_ci = saveci(L, L->ci);
+  lu_byte old_allowhooks = L->allowhook;
+  ptrdiff_t old_errfunc = L->errfunc;
+  L->errfunc = ef;
+  status = luaD_rawrunprotected(L, func, u);
+  if (status != 0) {  /* an error occurred? */
+    StkId oldtop = restorestack(L, old_top);
+    luaF_close(L, oldtop);  /* close eventual pending closures */
+    luaD_seterrorobj(L, status, oldtop);
+    L->nCcalls = oldnCcalls;
+    L->ci = restoreci(L, old_ci);
+    L->base = L->ci->base;
+    L->savedpc = L->ci->savedpc;
+    L->allowhook = old_allowhooks;
+    restore_stack_limit(L);
+  }
+  L->errfunc = old_errfunc;
+  return status;
+}
+
+
+
+/*
+** Execute a protected parser.
+*/
+struct SParser {  /* data to `f_parser' */
+  ZIO *z;
+  Mbuffer buff;  /* buffer to be used by the scanner */
+  const char *name;
+};
+
+static void f_parser (lua_State *L, void *ud) {
+  int i;
+  Proto *tf;
+  Closure *cl;
+  struct SParser *p = cast(struct SParser *, ud);
+  int c = luaZ_lookahead(p->z);
+  luaC_checkGC(L);
+  tf = ((c == LUA_SIGNATURE[0]) ? luaU_undump : luaY_parser)(L, p->z,
+                                                             &p->buff, p->name);
+  cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));
+  cl->l.p = tf;
+  for (i = 0; i < tf->nups; i++)  /* initialize eventual upvalues */
+    cl->l.upvals[i] = luaF_newupval(L);
+  setclvalue(L, L->top, cl);
+  incr_top(L);
+}
+
+
+int luaD_protectedparser (lua_State *L, ZIO *z, const char *name) {
+  struct SParser p;
+  int status;
+  p.z = z; p.name = name;
+  luaZ_initbuffer(L, &p.buff);
+  status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);
+  luaZ_freebuffer(L, &p.buff);
+  return status;
+}
+
+

lua/src/ldo.h

@@ -0,0 +1,57 @@
+/*
+** $Id: ldo.h,v 2.7.1.1 2007/12/27 13:02:25 roberto Exp $
+** Stack and Call structure of Lua
+** See Copyright Notice in lua.h
+*/
+
+#ifndef ldo_h
+#define ldo_h
+
+
+#include "lobject.h"
+#include "lstate.h"
+#include "lzio.h"
+
+
+#define luaD_checkstack(L,n)	\
+  if ((char *)L->stack_last - (char *)L->top <= (n)*(int)sizeof(TValue)) \
+    luaD_growstack(L, n); \
+  else condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1));
+
+
+#define incr_top(L) {luaD_checkstack(L,1); L->top++;}
+
+#define savestack(L,p)		((char *)(p) - (char *)L->stack)
+#define restorestack(L,n)	((TValue *)((char *)L->stack + (n)))
+
+#define saveci(L,p)		((char *)(p) - (char *)L->base_ci)
+#define restoreci(L,n)		((CallInfo *)((char *)L->base_ci + (n)))
+
+
+/* results from luaD_precall */
+#define PCRLUA		0	/* initiated a call to a Lua function */
+#define PCRC		1	/* did a call to a C function */
+#define PCRYIELD	2	/* C funtion yielded */
+
+
+/* type of protected functions, to be ran by `runprotected' */
+typedef void (*Pfunc) (lua_State *L, void *ud);
+
+LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name);
+LUAI_FUNC void luaD_callhook (lua_State *L, int event, int line);
+LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults);
+LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);
+LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
+                                        ptrdiff_t oldtop, ptrdiff_t ef);
+LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult);
+LUAI_FUNC void luaD_reallocCI (lua_State *L, int newsize);
+LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
+LUAI_FUNC void luaD_growstack (lua_State *L, int n);
+
+LUAI_FUNC void luaD_throw (lua_State *L, int errcode);
+LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
+
+LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop);
+
+#endif
+

lua/src/ldump.c

@@ -0,0 +1,164 @@
+/*
+** $Id: ldump.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
+** save precompiled Lua chunks
+** See Copyright Notice in lua.h
+*/
+
+#include <stddef.h>
+
+#define ldump_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "lobject.h"
+#include "lstate.h"
+#include "lundump.h"
+
+typedef struct {
+ lua_State* L;
+ lua_Writer writer;
+ void* data;
+ int strip;
+ int status;
+} DumpState;
+
+#define DumpMem(b,n,size,D)	DumpBlock(b,(n)*(size),D)
+#define DumpVar(x,D)	 	DumpMem(&x,1,sizeof(x),D)
+
+static void DumpBlock(const void* b, size_t size, DumpState* D)
+{
+ if (D->status==0)
+ {
+  lua_unlock(D->L);
+  D->status=(*D->writer)(D->L,b,size,D->data);
+  lua_lock(D->L);
+ }
+}
+
+static void DumpChar(int y, DumpState* D)
+{
+ char x=(char)y;
+ DumpVar(x,D);
+}
+
+static void DumpInt(int x, DumpState* D)
+{
+ DumpVar(x,D);
+}
+
+static void DumpNumber(lua_Number x, DumpState* D)
+{
+ DumpVar(x,D);
+}
+
+static void DumpVector(const void* b, int n, size_t size, DumpState* D)
+{
+ DumpInt(n,D);
+ DumpMem(b,n,size,D);
+}
+
+static void DumpString(const TString* s, DumpState* D)
+{
+ if (s==NULL || getstr(s)==NULL)
+ {
+  size_t size=0;
+  DumpVar(size,D);
+ }
+ else
+ {
+  size_t size=s->tsv.len+1;		/* include trailing '\0' */
+  DumpVar(size,D);
+  DumpBlock(getstr(s),size,D);
+ }
+}
+
+#define DumpCode(f,D)	 DumpVector(f->code,f->sizecode,sizeof(Instruction),D)
+
+static void DumpFunction(const Proto* f, const TString* p, DumpState* D);
+
+static void DumpConstants(const Proto* f, DumpState* D)
+{
+ int i,n=f->sizek;
+ DumpInt(n,D);
+ for (i=0; i<n; i++)
+ {
+  const TValue* o=&f->k[i];
+  DumpChar(ttype(o),D);
+  switch (ttype(o))
+  {
+   case LUA_TNIL:
+	break;
+   case LUA_TBOOLEAN:
+	DumpChar(bvalue(o),D);
+	break;
+   case LUA_TNUMBER:
+	DumpNumber(nvalue(o),D);
+	break;
+   case LUA_TSTRING:
+	DumpString(rawtsvalue(o),D);
+	break;
+   default:
+	lua_assert(0);			/* cannot happen */
+	break;
+  }
+ }
+ n=f->sizep;
+ DumpInt(n,D);
+ for (i=0; i<n; i++) DumpFunction(f->p[i],f->source,D);
+}
+
+static void DumpDebug(const Proto* f, DumpState* D)
+{
+ int i,n;
+ n= (D->strip) ? 0 : f->sizelineinfo;
+ DumpVector(f->lineinfo,n,sizeof(int),D);
+ n= (D->strip) ? 0 : f->sizelocvars;
+ DumpInt(n,D);
+ for (i=0; i<n; i++)
+ {
+  DumpString(f->locvars[i].varname,D);
+  DumpInt(f->locvars[i].startpc,D);
+  DumpInt(f->locvars[i].endpc,D);
+ }
+ n= (D->strip) ? 0 : f->sizeupvalues;
+ DumpInt(n,D);
+ for (i=0; i<n; i++) DumpString(f->upvalues[i],D);
+}
+
+static void DumpFunction(const Proto* f, const TString* p, DumpState* D)
+{
+ DumpString((f->source==p || D->strip) ? NULL : f->source,D);
+ DumpInt(f->linedefined,D);
+ DumpInt(f->lastlinedefined,D);
+ DumpChar(f->nups,D);
+ DumpChar(f->numparams,D);
+ DumpChar(f->is_vararg,D);
+ DumpChar(f->maxstacksize,D);
+ DumpCode(f,D);
+ DumpConstants(f,D);
+ DumpDebug(f,D);
+}
+
+static void DumpHeader(DumpState* D)
+{
+ char h[LUAC_HEADERSIZE];
+ luaU_header(h);
+ DumpBlock(h,LUAC_HEADERSIZE,D);
+}
+
+/*
+** dump Lua function as precompiled chunk
+*/
+int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
+{
+ DumpState D;
+ D.L=L;
+ D.writer=w;
+ D.data=data;
+ D.strip=strip;
+ D.status=0;
+ DumpHeader(&D);
+ DumpFunction(f,NULL,&D);
+ return D.status;
+}

lua/src/lfunc.c

@@ -0,0 +1,174 @@
+/*
+** $Id: lfunc.c,v 2.12.1.2 2007/12/28 14:58:43 roberto Exp $
+** Auxiliary functions to manipulate prototypes and closures
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stddef.h>
+
+#define lfunc_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "lfunc.h"
+#include "lgc.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lstate.h"
+
+
+
+Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e) {
+  Closure *c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems)));
+  luaC_link(L, obj2gco(c), LUA_TFUNCTION);
+  c->c.isC = 1;
+  c->c.env = e;
+  c->c.nupvalues = cast_byte(nelems);
+  return c;
+}
+
+
+Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e) {
+  Closure *c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems)));
+  luaC_link(L, obj2gco(c), LUA_TFUNCTION);
+  c->l.isC = 0;
+  c->l.env = e;
+  c->l.nupvalues = cast_byte(nelems);
+  while (nelems--) c->l.upvals[nelems] = NULL;
+  return c;
+}
+
+
+UpVal *luaF_newupval (lua_State *L) {
+  UpVal *uv = luaM_new(L, UpVal);
+  luaC_link(L, obj2gco(uv), LUA_TUPVAL);
+  uv->v = &uv->u.value;
+  setnilvalue(uv->v);
+  return uv;
+}
+
+
+UpVal *luaF_findupval (lua_State *L, StkId level) {
+  global_State *g = G(L);
+  GCObject **pp = &L->openupval;
+  UpVal *p;
+  UpVal *uv;
+  while (*pp != NULL && (p = ngcotouv(*pp))->v >= level) {
+    lua_assert(p->v != &p->u.value);
+    if (p->v == level) {  /* found a corresponding upvalue? */
+      if (isdead(g, obj2gco(p)))  /* is it dead? */
+        changewhite(obj2gco(p));  /* ressurect it */
+      return p;
+    }
+    pp = &p->next;
+  }
+  uv = luaM_new(L, UpVal);  /* not found: create a new one */
+  uv->tt = LUA_TUPVAL;
+  uv->marked = luaC_white(g);
+  uv->v = level;  /* current value lives in the stack */
+  uv->next = *pp;  /* chain it in the proper position */
+  *pp = obj2gco(uv);
+  uv->u.l.prev = &g->uvhead;  /* double link it in `uvhead' list */
+  uv->u.l.next = g->uvhead.u.l.next;
+  uv->u.l.next->u.l.prev = uv;
+  g->uvhead.u.l.next = uv;
+  lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
+  return uv;
+}
+
+
+static void unlinkupval (UpVal *uv) {
+  lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
+  uv->u.l.next->u.l.prev = uv->u.l.prev;  /* remove from `uvhead' list */
+  uv->u.l.prev->u.l.next = uv->u.l.next;
+}
+
+
+void luaF_freeupval (lua_State *L, UpVal *uv) {
+  if (uv->v != &uv->u.value)  /* is it open? */
+    unlinkupval(uv);  /* remove from open list */
+  luaM_free(L, uv);  /* free upvalue */
+}
+
+
+void luaF_close (lua_State *L, StkId level) {
+  UpVal *uv;
+  global_State *g = G(L);
+  while (L->openupval != NULL && (uv = ngcotouv(L->openupval))->v >= level) {
+    GCObject *o = obj2gco(uv);
+    lua_assert(!isblack(o) && uv->v != &uv->u.value);
+    L->openupval = uv->next;  /* remove from `open' list */
+    if (isdead(g, o))
+      luaF_freeupval(L, uv);  /* free upvalue */
+    else {
+      unlinkupval(uv);
+      setobj(L, &uv->u.value, uv->v);
+      uv->v = &uv->u.value;  /* now current value lives here */
+      luaC_linkupval(L, uv);  /* link upvalue into `gcroot' list */
+    }
+  }
+}
+
+
+Proto *luaF_newproto (lua_State *L) {
+  Proto *f = luaM_new(L, Proto);
+  luaC_link(L, obj2gco(f), LUA_TPROTO);
+  f->k = NULL;
+  f->sizek = 0;
+  f->p = NULL;
+  f->sizep = 0;
+  f->code = NULL;
+  f->sizecode = 0;
+  f->sizelineinfo = 0;
+  f->sizeupvalues = 0;
+  f->nups = 0;
+  f->upvalues = NULL;
+  f->numparams = 0;
+  f->is_vararg = 0;
+  f->maxstacksize = 0;
+  f->lineinfo = NULL;
+  f->sizelocvars = 0;
+  f->locvars = NULL;
+  f->linedefined = 0;
+  f->lastlinedefined = 0;
+  f->source = NULL;
+  return f;
+}
+
+
+void luaF_freeproto (lua_State *L, Proto *f) {
+  luaM_freearray(L, f->code, f->sizecode, Instruction);
+  luaM_freearray(L, f->p, f->sizep, Proto *);
+  luaM_freearray(L, f->k, f->sizek, TValue);
+  luaM_freearray(L, f->lineinfo, f->sizelineinfo, int);
+  luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar);
+  luaM_freearray(L, f->upvalues, f->sizeupvalues, TString *);
+  luaM_free(L, f);
+}
+
+
+void luaF_freeclosure (lua_State *L, Closure *c) {
+  int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) :
+                          sizeLclosure(c->l.nupvalues);
+  luaM_freemem(L, c, size);
+}
+
+
+/*
+** Look for n-th local variable at line `line' in function `func'.
+** Returns NULL if not found.
+*/
+const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
+  int i;
+  for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
+    if (pc < f->locvars[i].endpc) {  /* is variable active? */
+      local_number--;
+      if (local_number == 0)
+        return getstr(f->locvars[i].varname);
+    }
+  }
+  return NULL;  /* not found */
+}
+

lua/src/lfunc.h

@@ -0,0 +1,34 @@
+/*
+** $Id: lfunc.h,v 2.4.1.1 2007/12/27 13:02:25 roberto Exp $
+** Auxiliary functions to manipulate prototypes and closures
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lfunc_h
+#define lfunc_h
+
+
+#include "lobject.h"
+
+
+#define sizeCclosure(n)	(cast(int, sizeof(CClosure)) + \
+                         cast(int, sizeof(TValue)*((n)-1)))
+
+#define sizeLclosure(n)	(cast(int, sizeof(LClosure)) + \
+                         cast(int, sizeof(TValue *)*((n)-1)))
+
+
+LUAI_FUNC Proto *luaF_newproto (lua_State *L);
+LUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e);
+LUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e);
+LUAI_FUNC UpVal *luaF_newupval (lua_State *L);
+LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
+LUAI_FUNC void luaF_close (lua_State *L, StkId level);
+LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);
+LUAI_FUNC void luaF_freeclosure (lua_State *L, Closure *c);
+LUAI_FUNC void luaF_freeupval (lua_State *L, UpVal *uv);
+LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
+                                         int pc);
+
+
+#endif

lua/src/lgc.c

@@ -0,0 +1,711 @@
+/*
+** $Id: lgc.c,v 2.38.1.1 2007/12/27 13:02:25 roberto Exp $
+** Garbage Collector
+** See Copyright Notice in lua.h
+*/
+
+#include <string.h>
+
+#define lgc_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "ldebug.h"
+#include "ldo.h"
+#include "lfunc.h"
+#include "lgc.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "ltm.h"
+
+
+#define GCSTEPSIZE	1024u
+#define GCSWEEPMAX	40
+#define GCSWEEPCOST	10
+#define GCFINALIZECOST	100
+
+
+#define maskmarks	cast_byte(~(bitmask(BLACKBIT)|WHITEBITS))
+
+#define makewhite(g,x)	\
+   ((x)->gch.marked = cast_byte(((x)->gch.marked & maskmarks) | luaC_white(g)))
+
+#define white2gray(x)	reset2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)
+#define black2gray(x)	resetbit((x)->gch.marked, BLACKBIT)
+
+#define stringmark(s)	reset2bits((s)->tsv.marked, WHITE0BIT, WHITE1BIT)
+
+
+#define isfinalized(u)		testbit((u)->marked, FINALIZEDBIT)
+#define markfinalized(u)	l_setbit((u)->marked, FINALIZEDBIT)
+
+
+#define KEYWEAK         bitmask(KEYWEAKBIT)
+#define VALUEWEAK       bitmask(VALUEWEAKBIT)
+
+
+
+#define markvalue(g,o) { checkconsistency(o); \
+  if (iscollectable(o) && iswhite(gcvalue(o))) reallymarkobject(g,gcvalue(o)); }
+
+#define markobject(g,t) { if (iswhite(obj2gco(t))) \
+		reallymarkobject(g, obj2gco(t)); }
+
+
+#define setthreshold(g)  (g->GCthreshold = (g->estimate/100) * g->gcpause)
+
+
+static void removeentry (Node *n) {
+  lua_assert(ttisnil(gval(n)));
+  if (iscollectable(gkey(n)))
+    setttype(gkey(n), LUA_TDEADKEY);  /* dead key; remove it */
+}
+
+
+static void reallymarkobject (global_State *g, GCObject *o) {
+  lua_assert(iswhite(o) && !isdead(g, o));
+  white2gray(o);
+  switch (o->gch.tt) {
+    case LUA_TSTRING: {
+      return;
+    }
+    case LUA_TUSERDATA: {
+      Table *mt = gco2u(o)->metatable;
+      gray2black(o);  /* udata are never gray */
+      if (mt) markobject(g, mt);
+      markobject(g, gco2u(o)->env);
+      return;
+    }
+    case LUA_TUPVAL: {
+      UpVal *uv = gco2uv(o);
+      markvalue(g, uv->v);
+      if (uv->v == &uv->u.value)  /* closed? */
+        gray2black(o);  /* open upvalues are never black */
+      return;
+    }
+    case LUA_TFUNCTION: {
+      gco2cl(o)->c.gclist = g->gray;
+      g->gray = o;
+      break;
+    }
+    case LUA_TTABLE: {
+      gco2h(o)->gclist = g->gray;
+      g->gray = o;
+      break;
+    }
+    case LUA_TTHREAD: {
+      gco2th(o)->gclist = g->gray;
+      g->gray = o;
+      break;
+    }
+    case LUA_TPROTO: {
+      gco2p(o)->gclist = g->gray;
+      g->gray = o;
+      break;
+    }
+    default: lua_assert(0);
+  }
+}
+
+
+static void marktmu (global_State *g) {
+  GCObject *u = g->tmudata;
+  if (u) {
+    do {
+      u = u->gch.next;
+      makewhite(g, u);  /* may be marked, if left from previous GC */
+      reallymarkobject(g, u);
+    } while (u != g->tmudata);
+  }
+}
+
+
+/* move `dead' udata that need finalization to list `tmudata' */
+size_t luaC_separateudata (lua_State *L, int all) {
+  global_State *g = G(L);
+  size_t deadmem = 0;
+  GCObject **p = &g->mainthread->next;
+  GCObject *curr;
+  while ((curr = *p) != NULL) {
+    if (!(iswhite(curr) || all) || isfinalized(gco2u(curr)))
+      p = &curr->gch.next;  /* don't bother with them */
+    else if (fasttm(L, gco2u(curr)->metatable, TM_GC) == NULL) {
+      markfinalized(gco2u(curr));  /* don't need finalization */
+      p = &curr->gch.next;
+    }
+    else {  /* must call its gc method */
+      deadmem += sizeudata(gco2u(curr));
+      markfinalized(gco2u(curr));
+      *p = curr->gch.next;
+      /* link `curr' at the end of `tmudata' list */
+      if (g->tmudata == NULL)  /* list is empty? */
+        g->tmudata = curr->gch.next = curr;  /* creates a circular list */
+      else {
+        curr->gch.next = g->tmudata->gch.next;
+        g->tmudata->gch.next = curr;
+        g->tmudata = curr;
+      }
+    }
+  }
+  return deadmem;
+}
+
+
+static int traversetable (global_State *g, Table *h) {
+  int i;
+  int weakkey = 0;
+  int weakvalue = 0;
+  const TValue *mode;
+  if (h->metatable)
+    markobject(g, h->metatable);
+  mode = gfasttm(g, h->metatable, TM_MODE);
+  if (mode && ttisstring(mode)) {  /* is there a weak mode? */
+    weakkey = (strchr(svalue(mode), 'k') != NULL);
+    weakvalue = (strchr(svalue(mode), 'v') != NULL);
+    if (weakkey || weakvalue) {  /* is really weak? */
+      h->marked &= ~(KEYWEAK | VALUEWEAK);  /* clear bits */
+      h->marked |= cast_byte((weakkey << KEYWEAKBIT) |
+                             (weakvalue << VALUEWEAKBIT));
+      h->gclist = g->weak;  /* must be cleared after GC, ... */
+      g->weak = obj2gco(h);  /* ... so put in the appropriate list */
+    }
+  }
+  if (weakkey && weakvalue) return 1;
+  if (!weakvalue) {
+    i = h->sizearray;
+    while (i--)
+      markvalue(g, &h->array[i]);
+  }
+  i = sizenode(h);
+  while (i--) {
+    Node *n = gnode(h, i);
+    lua_assert(ttype(gkey(n)) != LUA_TDEADKEY || ttisnil(gval(n)));
+    if (ttisnil(gval(n)))
+      removeentry(n);  /* remove empty entries */
+    else {
+      lua_assert(!ttisnil(gkey(n)));
+      if (!weakkey) markvalue(g, gkey(n));
+      if (!weakvalue) markvalue(g, gval(n));
+    }
+  }
+  return weakkey || weakvalue;
+}
+
+
+/*
+** All marks are conditional because a GC may happen while the
+** prototype is still being created
+*/
+static void traverseproto (global_State *g, Proto *f) {
+  int i;
+  if (f->source) stringmark(f->source);
+  for (i=0; i<f->sizek; i++)  /* mark literals */
+    markvalue(g, &f->k[i]);
+  for (i=0; i<f->sizeupvalues; i++) {  /* mark upvalue names */
+    if (f->upvalues[i])
+      stringmark(f->upvalues[i]);
+  }
+  for (i=0; i<f->sizep; i++) {  /* mark nested protos */
+    if (f->p[i])
+      markobject(g, f->p[i]);
+  }
+  for (i=0; i<f->sizelocvars; i++) {  /* mark local-variable names */
+    if (f->locvars[i].varname)
+      stringmark(f->locvars[i].varname);
+  }
+}
+
+
+
+static void traverseclosure (global_State *g, Closure *cl) {
+  markobject(g, cl->c.env);
+  if (cl->c.isC) {
+    int i;
+    for (i=0; i<cl->c.nupvalues; i++)  /* mark its upvalues */
+      markvalue(g, &cl->c.upvalue[i]);
+  }
+  else {
+    int i;
+    lua_assert(cl->l.nupvalues == cl->l.p->nups);
+    markobject(g, cl->l.p);
+    for (i=0; i<cl->l.nupvalues; i++)  /* mark its upvalues */
+      markobject(g, cl->l.upvals[i]);
+  }
+}
+
+
+static void checkstacksizes (lua_State *L, StkId max) {
+  int ci_used = cast_int(L->ci - L->base_ci);  /* number of `ci' in use */
+  int s_used = cast_int(max - L->stack);  /* part of stack in use */
+  if (L->size_ci > LUAI_MAXCALLS)  /* handling overflow? */
+    return;  /* do not touch the stacks */
+  if (4*ci_used < L->size_ci && 2*BASIC_CI_SIZE < L->size_ci)
+    luaD_reallocCI(L, L->size_ci/2);  /* still big enough... */
+  condhardstacktests(luaD_reallocCI(L, ci_used + 1));
+  if (4*s_used < L->stacksize &&
+      2*(BASIC_STACK_SIZE+EXTRA_STACK) < L->stacksize)
+    luaD_reallocstack(L, L->stacksize/2);  /* still big enough... */
+  condhardstacktests(luaD_reallocstack(L, s_used));
+}
+
+
+static void traversestack (global_State *g, lua_State *l) {
+  StkId o, lim;
+  CallInfo *ci;
+  markvalue(g, gt(l));
+  lim = l->top;
+  for (ci = l->base_ci; ci <= l->ci; ci++) {
+    lua_assert(ci->top <= l->stack_last);
+    if (lim < ci->top) lim = ci->top;
+  }
+  for (o = l->stack; o < l->top; o++)
+    markvalue(g, o);
+  for (; o <= lim; o++)
+    setnilvalue(o);
+  checkstacksizes(l, lim);
+}
+
+
+/*
+** traverse one gray object, turning it to black.
+** Returns `quantity' traversed.
+*/
+static l_mem propagatemark (global_State *g) {
+  GCObject *o = g->gray;
+  lua_assert(isgray(o));
+  gray2black(o);
+  switch (o->gch.tt) {
+    case LUA_TTABLE: {
+      Table *h = gco2h(o);
+      g->gray = h->gclist;
+      if (traversetable(g, h))  /* table is weak? */
+        black2gray(o);  /* keep it gray */
+      return sizeof(Table) + sizeof(TValue) * h->sizearray +
+                             sizeof(Node) * sizenode(h);
+    }
+    case LUA_TFUNCTION: {
+      Closure *cl = gco2cl(o);
+      g->gray = cl->c.gclist;
+      traverseclosure(g, cl);
+      return (cl->c.isC) ? sizeCclosure(cl->c.nupvalues) :
+                           sizeLclosure(cl->l.nupvalues);
+    }
+    case LUA_TTHREAD: {
+      lua_State *th = gco2th(o);
+      g->gray = th->gclist;
+      th->gclist = g->grayagain;
+      g->grayagain = o;
+      black2gray(o);
+      traversestack(g, th);
+      return sizeof(lua_State) + sizeof(TValue) * th->stacksize +
+                                 sizeof(CallInfo) * th->size_ci;
+    }
+    case LUA_TPROTO: {
+      Proto *p = gco2p(o);
+      g->gray = p->gclist;
+      traverseproto(g, p);
+      return sizeof(Proto) + sizeof(Instruction) * p->sizecode +
+                             sizeof(Proto *) * p->sizep +
+                             sizeof(TValue) * p->sizek + 
+                             sizeof(int) * p->sizelineinfo +
+                             sizeof(LocVar) * p->sizelocvars +
+                             sizeof(TString *) * p->sizeupvalues;
+    }
+    default: lua_assert(0); return 0;
+  }
+}
+
+
+static size_t propagateall (global_State *g) {
+  size_t m = 0;
+  while (g->gray) m += propagatemark(g);
+  return m;
+}
+
+
+/*
+** The next function tells whether a key or value can be cleared from
+** a weak table. Non-collectable objects are never removed from weak
+** tables. Strings behave as `values', so are never removed too. for
+** other objects: if really collected, cannot keep them; for userdata
+** being finalized, keep them in keys, but not in values
+*/
+static int iscleared (const TValue *o, int iskey) {
+  if (!iscollectable(o)) return 0;
+  if (ttisstring(o)) {
+    stringmark(rawtsvalue(o));  /* strings are `values', so are never weak */
+    return 0;
+  }
+  return iswhite(gcvalue(o)) ||
+    (ttisuserdata(o) && (!iskey && isfinalized(uvalue(o))));
+}
+
+
+/*
+** clear collected entries from weaktables
+*/
+static void cleartable (GCObject *l) {
+  while (l) {
+    Table *h = gco2h(l);
+    int i = h->sizearray;
+    lua_assert(testbit(h->marked, VALUEWEAKBIT) ||
+               testbit(h->marked, KEYWEAKBIT));
+    if (testbit(h->marked, VALUEWEAKBIT)) {
+      while (i--) {
+        TValue *o = &h->array[i];
+        if (iscleared(o, 0))  /* value was collected? */
+          setnilvalue(o);  /* remove value */
+      }
+    }
+    i = sizenode(h);
+    while (i--) {
+      Node *n = gnode(h, i);
+      if (!ttisnil(gval(n)) &&  /* non-empty entry? */
+          (iscleared(key2tval(n), 1) || iscleared(gval(n), 0))) {
+        setnilvalue(gval(n));  /* remove value ... */
+        removeentry(n);  /* remove entry from table */
+      }
+    }
+    l = h->gclist;
+  }
+}
+
+
+static void freeobj (lua_State *L, GCObject *o) {
+  switch (o->gch.tt) {
+    case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
+    case LUA_TFUNCTION: luaF_freeclosure(L, gco2cl(o)); break;
+    case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break;
+    case LUA_TTABLE: luaH_free(L, gco2h(o)); break;
+    case LUA_TTHREAD: {
+      lua_assert(gco2th(o) != L && gco2th(o) != G(L)->mainthread);
+      luaE_freethread(L, gco2th(o));
+      break;
+    }
+    case LUA_TSTRING: {
+      G(L)->strt.nuse--;
+      luaM_freemem(L, o, sizestring(gco2ts(o)));
+      break;
+    }
+    case LUA_TUSERDATA: {
+      luaM_freemem(L, o, sizeudata(gco2u(o)));
+      break;
+    }
+    default: lua_assert(0);
+  }
+}
+
+
+
+#define sweepwholelist(L,p)	sweeplist(L,p,MAX_LUMEM)
+
+
+static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
+  GCObject *curr;
+  global_State *g = G(L);
+  int deadmask = otherwhite(g);
+  while ((curr = *p) != NULL && count-- > 0) {
+    if (curr->gch.tt == LUA_TTHREAD)  /* sweep open upvalues of each thread */
+      sweepwholelist(L, &gco2th(curr)->openupval);
+    if ((curr->gch.marked ^ WHITEBITS) & deadmask) {  /* not dead? */
+      lua_assert(!isdead(g, curr) || testbit(curr->gch.marked, FIXEDBIT));
+      makewhite(g, curr);  /* make it white (for next cycle) */
+      p = &curr->gch.next;
+    }
+    else {  /* must erase `curr' */
+      lua_assert(isdead(g, curr) || deadmask == bitmask(SFIXEDBIT));
+      *p = curr->gch.next;
+      if (curr == g->rootgc)  /* is the first element of the list? */
+        g->rootgc = curr->gch.next;  /* adjust first */
+      freeobj(L, curr);
+    }
+  }
+  return p;
+}
+
+
+static void checkSizes (lua_State *L) {
+  global_State *g = G(L);
+  /* check size of string hash */
+  if (g->strt.nuse < cast(lu_int32, g->strt.size/4) &&
+      g->strt.size > MINSTRTABSIZE*2)
+    luaS_resize(L, g->strt.size/2);  /* table is too big */
+  /* check size of buffer */
+  if (luaZ_sizebuffer(&g->buff) > LUA_MINBUFFER*2) {  /* buffer too big? */
+    size_t newsize = luaZ_sizebuffer(&g->buff) / 2;
+    luaZ_resizebuffer(L, &g->buff, newsize);
+  }
+}
+
+
+static void GCTM (lua_State *L) {
+  global_State *g = G(L);
+  GCObject *o = g->tmudata->gch.next;  /* get first element */
+  Udata *udata = rawgco2u(o);
+  const TValue *tm;
+  /* remove udata from `tmudata' */
+  if (o == g->tmudata)  /* last element? */
+    g->tmudata = NULL;
+  else
+    g->tmudata->gch.next = udata->uv.next;
+  udata->uv.next = g->mainthread->next;  /* return it to `root' list */
+  g->mainthread->next = o;
+  makewhite(g, o);
+  tm = fasttm(L, udata->uv.metatable, TM_GC);
+  if (tm != NULL) {
+    lu_byte oldah = L->allowhook;
+    lu_mem oldt = g->GCthreshold;
+    L->allowhook = 0;  /* stop debug hooks during GC tag method */
+    g->GCthreshold = 2*g->totalbytes;  /* avoid GC steps */
+    setobj2s(L, L->top, tm);
+    setuvalue(L, L->top+1, udata);
+    L->top += 2;
+    luaD_call(L, L->top - 2, 0);
+    L->allowhook = oldah;  /* restore hooks */
+    g->GCthreshold = oldt;  /* restore threshold */
+  }
+}
+
+
+/*
+** Call all GC tag methods
+*/
+void luaC_callGCTM (lua_State *L) {
+  while (G(L)->tmudata)
+    GCTM(L);
+}
+
+
+void luaC_freeall (lua_State *L) {
+  global_State *g = G(L);
+  int i;
+  g->currentwhite = WHITEBITS | bitmask(SFIXEDBIT);  /* mask to collect all elements */
+  sweepwholelist(L, &g->rootgc);
+  for (i = 0; i < g->strt.size; i++)  /* free all string lists */
+    sweepwholelist(L, &g->strt.hash[i]);
+}
+
+
+static void markmt (global_State *g) {
+  int i;
+  for (i=0; i<NUM_TAGS; i++)
+    if (g->mt[i]) markobject(g, g->mt[i]);
+}
+
+
+/* mark root set */
+static void markroot (lua_State *L) {
+  global_State *g = G(L);
+  g->gray = NULL;
+  g->grayagain = NULL;
+  g->weak = NULL;
+  markobject(g, g->mainthread);
+  /* make global table be traversed before main stack */
+  markvalue(g, gt(g->mainthread));
+  markvalue(g, registry(L));
+  markmt(g);
+  g->gcstate = GCSpropagate;
+}
+
+
+static void remarkupvals (global_State *g) {
+  UpVal *uv;
+  for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) {
+    lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
+    if (isgray(obj2gco(uv)))
+      markvalue(g, uv->v);
+  }
+}
+
+
+static void atomic (lua_State *L) {
+  global_State *g = G(L);
+  size_t udsize;  /* total size of userdata to be finalized */
+  /* remark occasional upvalues of (maybe) dead threads */
+  remarkupvals(g);
+  /* traverse objects cautch by write barrier and by 'remarkupvals' */
+  propagateall(g);
+  /* remark weak tables */
+  g->gray = g->weak;
+  g->weak = NULL;
+  lua_assert(!iswhite(obj2gco(g->mainthread)));
+  markobject(g, L);  /* mark running thread */
+  markmt(g);  /* mark basic metatables (again) */
+  propagateall(g);
+  /* remark gray again */
+  g->gray = g->grayagain;
+  g->grayagain = NULL;
+  propagateall(g);
+  udsize = luaC_separateudata(L, 0);  /* separate userdata to be finalized */
+  marktmu(g);  /* mark `preserved' userdata */
+  udsize += propagateall(g);  /* remark, to propagate `preserveness' */
+  cleartable(g->weak);  /* remove collected objects from weak tables */
+  /* flip current white */
+  g->currentwhite = cast_byte(otherwhite(g));
+  g->sweepstrgc = 0;
+  g->sweepgc = &g->rootgc;
+  g->gcstate = GCSsweepstring;
+  g->estimate = g->totalbytes - udsize;  /* first estimate */
+}
+
+
+static l_mem singlestep (lua_State *L) {
+  global_State *g = G(L);
+  /*lua_checkmemory(L);*/
+  switch (g->gcstate) {
+    case GCSpause: {
+      markroot(L);  /* start a new collection */
+      return 0;
+    }
+    case GCSpropagate: {
+      if (g->gray)
+        return propagatemark(g);
+      else {  /* no more `gray' objects */
+        atomic(L);  /* finish mark phase */
+        return 0;
+      }
+    }
+    case GCSsweepstring: {
+      lu_mem old = g->totalbytes;
+      sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);
+      if (g->sweepstrgc >= g->strt.size)  /* nothing more to sweep? */
+        g->gcstate = GCSsweep;  /* end sweep-string phase */
+      lua_assert(old >= g->totalbytes);
+      g->estimate -= old - g->totalbytes;
+      return GCSWEEPCOST;
+    }
+    case GCSsweep: {
+      lu_mem old = g->totalbytes;
+      g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
+      if (*g->sweepgc == NULL) {  /* nothing more to sweep? */
+        checkSizes(L);
+        g->gcstate = GCSfinalize;  /* end sweep phase */
+      }
+      lua_assert(old >= g->totalbytes);
+      g->estimate -= old - g->totalbytes;
+      return GCSWEEPMAX*GCSWEEPCOST;
+    }
+    case GCSfinalize: {
+      if (g->tmudata) {
+        GCTM(L);
+        if (g->estimate > GCFINALIZECOST)
+          g->estimate -= GCFINALIZECOST;
+        return GCFINALIZECOST;
+      }
+      else {
+        g->gcstate = GCSpause;  /* end collection */
+        g->gcdept = 0;
+        return 0;
+      }
+    }
+    default: lua_assert(0); return 0;
+  }
+}
+
+
+void luaC_step (lua_State *L) {
+  global_State *g = G(L);
+  l_mem lim = (GCSTEPSIZE/100) * g->gcstepmul;
+  if (lim == 0)
+    lim = (MAX_LUMEM-1)/2;  /* no limit */
+  g->gcdept += g->totalbytes - g->GCthreshold;
+  do {
+    lim -= singlestep(L);
+    if (g->gcstate == GCSpause)
+      break;
+  } while (lim > 0);
+  if (g->gcstate != GCSpause) {
+    if (g->gcdept < GCSTEPSIZE)
+      g->GCthreshold = g->totalbytes + GCSTEPSIZE;  /* - lim/g->gcstepmul;*/
+    else {
+      g->gcdept -= GCSTEPSIZE;
+      g->GCthreshold = g->totalbytes;
+    }
+  }
+  else {
+    lua_assert(g->totalbytes >= g->estimate);
+    setthreshold(g);
+  }
+}
+
+
+void luaC_fullgc (lua_State *L) {
+  global_State *g = G(L);
+  if (g->gcstate <= GCSpropagate) {
+    /* reset sweep marks to sweep all elements (returning them to white) */
+    g->sweepstrgc = 0;
+    g->sweepgc = &g->rootgc;
+    /* reset other collector lists */
+    g->gray = NULL;
+    g->grayagain = NULL;
+    g->weak = NULL;
+    g->gcstate = GCSsweepstring;
+  }
+  lua_assert(g->gcstate != GCSpause && g->gcstate != GCSpropagate);
+  /* finish any pending sweep phase */
+  while (g->gcstate != GCSfinalize) {
+    lua_assert(g->gcstate == GCSsweepstring || g->gcstate == GCSsweep);
+    singlestep(L);
+  }
+  markroot(L);
+  while (g->gcstate != GCSpause) {
+    singlestep(L);
+  }
+  setthreshold(g);
+}
+
+
+void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v) {
+  global_State *g = G(L);
+  lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
+  lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
+  lua_assert(ttype(&o->gch) != LUA_TTABLE);
+  /* must keep invariant? */
+  if (g->gcstate == GCSpropagate)
+    reallymarkobject(g, v);  /* restore invariant */
+  else  /* don't mind */
+    makewhite(g, o);  /* mark as white just to avoid other barriers */
+}
+
+
+void luaC_barrierback (lua_State *L, Table *t) {
+  global_State *g = G(L);
+  GCObject *o = obj2gco(t);
+  lua_assert(isblack(o) && !isdead(g, o));
+  lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
+  black2gray(o);  /* make table gray (again) */
+  t->gclist = g->grayagain;
+  g->grayagain = o;
+}
+
+
+void luaC_link (lua_State *L, GCObject *o, lu_byte tt) {
+  global_State *g = G(L);
+  o->gch.next = g->rootgc;
+  g->rootgc = o;
+  o->gch.marked = luaC_white(g);
+  o->gch.tt = tt;
+}
+
+
+void luaC_linkupval (lua_State *L, UpVal *uv) {
+  global_State *g = G(L);
+  GCObject *o = obj2gco(uv);
+  o->gch.next = g->rootgc;  /* link upvalue into `rootgc' list */
+  g->rootgc = o;
+  if (isgray(o)) { 
+    if (g->gcstate == GCSpropagate) {
+      gray2black(o);  /* closed upvalues need barrier */
+      luaC_barrier(L, uv, uv->v);
+    }
+    else {  /* sweep phase: sweep it (turning it into white) */
+      makewhite(g, o);
+      lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
+    }
+  }
+}
+

lua/src/lgc.h

@@ -0,0 +1,110 @@
+/*
+** $Id: lgc.h,v 2.15.1.1 2007/12/27 13:02:25 roberto Exp $
+** Garbage Collector
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lgc_h
+#define lgc_h
+
+
+#include "lobject.h"
+
+
+/*
+** Possible states of the Garbage Collector
+*/
+#define GCSpause	0
+#define GCSpropagate	1
+#define GCSsweepstring	2
+#define GCSsweep	3
+#define GCSfinalize	4
+
+
+/*
+** some userful bit tricks
+*/
+#define resetbits(x,m)	((x) &= cast(lu_byte, ~(m)))
+#define setbits(x,m)	((x) |= (m))
+#define testbits(x,m)	((x) & (m))
+#define bitmask(b)	(1<<(b))
+#define bit2mask(b1,b2)	(bitmask(b1) | bitmask(b2))
+#define l_setbit(x,b)	setbits(x, bitmask(b))
+#define resetbit(x,b)	resetbits(x, bitmask(b))
+#define testbit(x,b)	testbits(x, bitmask(b))
+#define set2bits(x,b1,b2)	setbits(x, (bit2mask(b1, b2)))
+#define reset2bits(x,b1,b2)	resetbits(x, (bit2mask(b1, b2)))
+#define test2bits(x,b1,b2)	testbits(x, (bit2mask(b1, b2)))
+
+
+
+/*
+** Layout for bit use in `marked' field:
+** bit 0 - object is white (type 0)
+** bit 1 - object is white (type 1)
+** bit 2 - object is black
+** bit 3 - for userdata: has been finalized
+** bit 3 - for tables: has weak keys
+** bit 4 - for tables: has weak values
+** bit 5 - object is fixed (should not be collected)
+** bit 6 - object is "super" fixed (only the main thread)
+*/
+
+
+#define WHITE0BIT	0
+#define WHITE1BIT	1
+#define BLACKBIT	2
+#define FINALIZEDBIT	3
+#define KEYWEAKBIT	3
+#define VALUEWEAKBIT	4
+#define FIXEDBIT	5
+#define SFIXEDBIT	6
+#define WHITEBITS	bit2mask(WHITE0BIT, WHITE1BIT)
+
+
+#define iswhite(x)      test2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)
+#define isblack(x)      testbit((x)->gch.marked, BLACKBIT)
+#define isgray(x)	(!isblack(x) && !iswhite(x))
+
+#define otherwhite(g)	(g->currentwhite ^ WHITEBITS)
+#define isdead(g,v)	((v)->gch.marked & otherwhite(g) & WHITEBITS)
+
+#define changewhite(x)	((x)->gch.marked ^= WHITEBITS)
+#define gray2black(x)	l_setbit((x)->gch.marked, BLACKBIT)
+
+#define valiswhite(x)	(iscollectable(x) && iswhite(gcvalue(x)))
+
+#define luaC_white(g)	cast(lu_byte, (g)->currentwhite & WHITEBITS)
+
+
+#define luaC_checkGC(L) { \
+  condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1)); \
+  if (G(L)->totalbytes >= G(L)->GCthreshold) \
+	luaC_step(L); }
+
+
+#define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p)))  \
+	luaC_barrierf(L,obj2gco(p),gcvalue(v)); }
+
+#define luaC_barriert(L,t,v) { if (valiswhite(v) && isblack(obj2gco(t)))  \
+	luaC_barrierback(L,t); }
+
+#define luaC_objbarrier(L,p,o)  \
+	{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \
+		luaC_barrierf(L,obj2gco(p),obj2gco(o)); }
+
+#define luaC_objbarriert(L,t,o)  \
+   { if (iswhite(obj2gco(o)) && isblack(obj2gco(t))) luaC_barrierback(L,t); }
+
+LUAI_FUNC size_t luaC_separateudata (lua_State *L, int all);
+LUAI_FUNC void luaC_callGCTM (lua_State *L);
+LUAI_FUNC void luaC_freeall (lua_State *L);
+LUAI_FUNC void luaC_step (lua_State *L);
+LUAI_FUNC void luaC_fullgc (lua_State *L);
+LUAI_FUNC void luaC_link (lua_State *L, GCObject *o, lu_byte tt);
+LUAI_FUNC void luaC_linkupval (lua_State *L, UpVal *uv);
+LUAI_FUNC void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v);
+LUAI_FUNC void luaC_barrierback (lua_State *L, Table *t);
+
+
+#endif

lua/src/linit.c

@@ -0,0 +1,38 @@
+/*
+** $Id: linit.c,v 1.14.1.1 2007/12/27 13:02:25 roberto Exp $
+** Initialization of libraries for lua.c
+** See Copyright Notice in lua.h
+*/
+
+
+#define linit_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lualib.h"
+#include "lauxlib.h"
+
+
+static const luaL_Reg lualibs[] = {
+  {"", luaopen_base},
+  {LUA_LOADLIBNAME, luaopen_package},
+  {LUA_TABLIBNAME, luaopen_table},
+  {LUA_IOLIBNAME, luaopen_io},
+  {LUA_OSLIBNAME, luaopen_os},
+  {LUA_STRLIBNAME, luaopen_string},
+  {LUA_MATHLIBNAME, luaopen_math},
+  {LUA_DBLIBNAME, luaopen_debug},
+  {NULL, NULL}
+};
+
+
+LUALIB_API void luaL_openlibs (lua_State *L) {
+  const luaL_Reg *lib = lualibs;
+  for (; lib->func; lib++) {
+    lua_pushcfunction(L, lib->func);
+    lua_pushstring(L, lib->name);
+    lua_call(L, 1, 0);
+  }
+}
+

lua/src/liolib.c

@@ -0,0 +1,553 @@
+/*
+** $Id: liolib.c,v 2.73.1.3 2008/01/18 17:47:43 roberto Exp $
+** Standard I/O (and system) library
+** See Copyright Notice in lua.h
+*/
+
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define liolib_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "lualib.h"
+
+
+
+#define IO_INPUT	1
+#define IO_OUTPUT	2
+
+
+static const char *const fnames[] = {"input", "output"};
+
+
+static int pushresult (lua_State *L, int i, const char *filename) {
+  int en = errno;  /* calls to Lua API may change this value */
+  if (i) {
+    lua_pushboolean(L, 1);
+    return 1;
+  }
+  else {
+    lua_pushnil(L);
+    if (filename)
+      lua_pushfstring(L, "%s: %s", filename, strerror(en));
+    else
+      lua_pushfstring(L, "%s", strerror(en));
+    lua_pushinteger(L, en);
+    return 3;
+  }
+}
+
+
+static void fileerror (lua_State *L, int arg, const char *filename) {
+  lua_pushfstring(L, "%s: %s", filename, strerror(errno));
+  luaL_argerror(L, arg, lua_tostring(L, -1));
+}
+
+
+#define tofilep(L)	((FILE **)luaL_checkudata(L, 1, LUA_FILEHANDLE))
+
+
+static int io_type (lua_State *L) {
+  void *ud;
+  luaL_checkany(L, 1);
+  ud = lua_touserdata(L, 1);
+  lua_getfield(L, LUA_REGISTRYINDEX, LUA_FILEHANDLE);
+  if (ud == NULL || !lua_getmetatable(L, 1) || !lua_rawequal(L, -2, -1))
+    lua_pushnil(L);  /* not a file */
+  else if (*((FILE **)ud) == NULL)
+    lua_pushliteral(L, "closed file");
+  else
+    lua_pushliteral(L, "file");
+  return 1;
+}
+
+
+static FILE *tofile (lua_State *L) {
+  FILE **f = tofilep(L);
+  if (*f == NULL)
+    luaL_error(L, "attempt to use a closed file");
+  return *f;
+}
+
+
+
+/*
+** When creating file handles, always creates a `closed' file handle
+** before opening the actual file; so, if there is a memory error, the
+** file is not left opened.
+*/
+static FILE **newfile (lua_State *L) {
+  FILE **pf = (FILE **)lua_newuserdata(L, sizeof(FILE *));
+  *pf = NULL;  /* file handle is currently `closed' */
+  luaL_getmetatable(L, LUA_FILEHANDLE);
+  lua_setmetatable(L, -2);
+  return pf;
+}
+
+
+/*
+** function to (not) close the standard files stdin, stdout, and stderr
+*/
+static int io_noclose (lua_State *L) {
+  lua_pushnil(L);
+  lua_pushliteral(L, "cannot close standard file");
+  return 2;
+}
+
+
+/*
+** function to close 'popen' files
+*/
+static int io_pclose (lua_State *L) {
+  FILE **p = tofilep(L);
+  int ok = lua_pclose(L, *p);
+  *p = NULL;
+  return pushresult(L, ok, NULL);
+}
+
+
+/*
+** function to close regular files
+*/
+static int io_fclose (lua_State *L) {
+  FILE **p = tofilep(L);
+  int ok = (fclose(*p) == 0);
+  *p = NULL;
+  return pushresult(L, ok, NULL);
+}
+
+
+static int aux_close (lua_State *L) {
+  lua_getfenv(L, 1);
+  lua_getfield(L, -1, "__close");
+  return (lua_tocfunction(L, -1))(L);
+}
+
+
+static int io_close (lua_State *L) {
+  if (lua_isnone(L, 1))
+    lua_rawgeti(L, LUA_ENVIRONINDEX, IO_OUTPUT);
+  tofile(L);  /* make sure argument is a file */
+  return aux_close(L);
+}
+
+
+static int io_gc (lua_State *L) {
+  FILE *f = *tofilep(L);
+  /* ignore closed files */
+  if (f != NULL)
+    aux_close(L);
+  return 0;
+}
+
+
+static int io_tostring (lua_State *L) {
+  FILE *f = *tofilep(L);
+  if (f == NULL)
+    lua_pushliteral(L, "file (closed)");
+  else
+    lua_pushfstring(L, "file (%p)", f);
+  return 1;
+}
+
+
+static int io_open (lua_State *L) {
+  const char *filename = luaL_checkstring(L, 1);
+  const char *mode = luaL_optstring(L, 2, "r");
+  FILE **pf = newfile(L);
+  *pf = fopen(filename, mode);
+  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
+}
+
+
+/*
+** this function has a separated environment, which defines the
+** correct __close for 'popen' files
+*/
+static int io_popen (lua_State *L) {
+  const char *filename = luaL_checkstring(L, 1);
+  const char *mode = luaL_optstring(L, 2, "r");
+  FILE **pf = newfile(L);
+  *pf = lua_popen(L, filename, mode);
+  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
+}
+
+
+static int io_tmpfile (lua_State *L) {
+  FILE **pf = newfile(L);
+  *pf = tmpfile();
+  return (*pf == NULL) ? pushresult(L, 0, NULL) : 1;
+}
+
+
+static FILE *getiofile (lua_State *L, int findex) {
+  FILE *f;
+  lua_rawgeti(L, LUA_ENVIRONINDEX, findex);
+  f = *(FILE **)lua_touserdata(L, -1);
+  if (f == NULL)
+    luaL_error(L, "standard %s file is closed", fnames[findex - 1]);
+  return f;
+}
+
+
+static int g_iofile (lua_State *L, int f, const char *mode) {
+  if (!lua_isnoneornil(L, 1)) {
+    const char *filename = lua_tostring(L, 1);
+    if (filename) {
+      FILE **pf = newfile(L);
+      *pf = fopen(filename, mode);
+      if (*pf == NULL)
+        fileerror(L, 1, filename);
+    }
+    else {
+      tofile(L);  /* check that it's a valid file handle */
+      lua_pushvalue(L, 1);
+    }
+    lua_rawseti(L, LUA_ENVIRONINDEX, f);
+  }
+  /* return current value */
+  lua_rawgeti(L, LUA_ENVIRONINDEX, f);
+  return 1;
+}
+
+
+static int io_input (lua_State *L) {
+  return g_iofile(L, IO_INPUT, "r");
+}
+
+
+static int io_output (lua_State *L) {
+  return g_iofile(L, IO_OUTPUT, "w");
+}
+
+
+static int io_readline (lua_State *L);
+
+
+static void aux_lines (lua_State *L, int idx, int toclose) {
+  lua_pushvalue(L, idx);
+  lua_pushboolean(L, toclose);  /* close/not close file when finished */
+  lua_pushcclosure(L, io_readline, 2);
+}
+
+
+static int f_lines (lua_State *L) {
+  tofile(L);  /* check that it's a valid file handle */
+  aux_lines(L, 1, 0);
+  return 1;
+}
+
+
+static int io_lines (lua_State *L) {
+  if (lua_isnoneornil(L, 1)) {  /* no arguments? */
+    /* will iterate over default input */
+    lua_rawgeti(L, LUA_ENVIRONINDEX, IO_INPUT);
+    return f_lines(L);
+  }
+  else {
+    const char *filename = luaL_checkstring(L, 1);
+    FILE **pf = newfile(L);
+    *pf = fopen(filename, "r");
+    if (*pf == NULL)
+      fileerror(L, 1, filename);
+    aux_lines(L, lua_gettop(L), 1);
+    return 1;
+  }
+}
+
+
+/*
+** {======================================================
+** READ
+** =======================================================
+*/
+
+
+static int read_number (lua_State *L, FILE *f) {
+  lua_Number d;
+  if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) {
+    lua_pushnumber(L, d);
+    return 1;
+  }
+  else return 0;  /* read fails */
+}
+
+
+static int test_eof (lua_State *L, FILE *f) {
+  int c = getc(f);
+  ungetc(c, f);
+  lua_pushlstring(L, NULL, 0);
+  return (c != EOF);
+}
+
+
+static int read_line (lua_State *L, FILE *f) {
+  luaL_Buffer b;
+  luaL_buffinit(L, &b);
+  for (;;) {
+    size_t l;
+    char *p = luaL_prepbuffer(&b);
+    if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) {  /* eof? */
+      luaL_pushresult(&b);  /* close buffer */
+      return (lua_objlen(L, -1) > 0);  /* check whether read something */
+    }
+    l = strlen(p);
+    if (l == 0 || p[l-1] != '\n')
+      luaL_addsize(&b, l);
+    else {
+      luaL_addsize(&b, l - 1);  /* do not include `eol' */
+      luaL_pushresult(&b);  /* close buffer */
+      return 1;  /* read at least an `eol' */
+    }
+  }
+}
+
+
+static int read_chars (lua_State *L, FILE *f, size_t n) {
+  size_t rlen;  /* how much to read */
+  size_t nr;  /* number of chars actually read */
+  luaL_Buffer b;
+  luaL_buffinit(L, &b);
+  rlen = LUAL_BUFFERSIZE;  /* try to read that much each time */
+  do {
+    char *p = luaL_prepbuffer(&b);
+    if (rlen > n) rlen = n;  /* cannot read more than asked */
+    nr = fread(p, sizeof(char), rlen, f);
+    luaL_addsize(&b, nr);
+    n -= nr;  /* still have to read `n' chars */
+  } while (n > 0 && nr == rlen);  /* until end of count or eof */
+  luaL_pushresult(&b);  /* close buffer */
+  return (n == 0 || lua_objlen(L, -1) > 0);
+}
+
+
+static int g_read (lua_State *L, FILE *f, int first) {
+  int nargs = lua_gettop(L) - 1;
+  int success;
+  int n;
+  clearerr(f);
+  if (nargs == 0) {  /* no arguments? */
+    success = read_line(L, f);
+    n = first+1;  /* to return 1 result */
+  }
+  else {  /* ensure stack space for all results and for auxlib's buffer */
+    luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
+    success = 1;
+    for (n = first; nargs-- && success; n++) {
+      if (lua_type(L, n) == LUA_TNUMBER) {
+        size_t l = (size_t)lua_tointeger(L, n);
+        success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);
+      }
+      else {
+        const char *p = lua_tostring(L, n);
+        luaL_argcheck(L, p && p[0] == '*', n, "invalid option");
+        switch (p[1]) {
+          case 'n':  /* number */
+            success = read_number(L, f);
+            break;
+          case 'l':  /* line */
+            success = read_line(L, f);
+            break;
+          case 'a':  /* file */
+            read_chars(L, f, ~((size_t)0));  /* read MAX_SIZE_T chars */
+            success = 1; /* always success */
+            break;
+          default:
+            return luaL_argerror(L, n, "invalid format");
+        }
+      }
+    }
+  }
+  if (ferror(f))
+    return pushresult(L, 0, NULL);
+  if (!success) {
+    lua_pop(L, 1);  /* remove last result */
+    lua_pushnil(L);  /* push nil instead */
+  }
+  return n - first;
+}
+
+
+static int io_read (lua_State *L) {
+  return g_read(L, getiofile(L, IO_INPUT), 1);
+}
+
+
+static int f_read (lua_State *L) {
+  return g_read(L, tofile(L), 2);
+}
+
+
+static int io_readline (lua_State *L) {
+  FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1));
+  int sucess;
+  if (f == NULL)  /* file is already closed? */
+    luaL_error(L, "file is already closed");
+  sucess = read_line(L, f);
+  if (ferror(f))
+    return luaL_error(L, "%s", strerror(errno));
+  if (sucess) return 1;
+  else {  /* EOF */
+    if (lua_toboolean(L, lua_upvalueindex(2))) {  /* generator created file? */
+      lua_settop(L, 0);
+      lua_pushvalue(L, lua_upvalueindex(1));
+      aux_close(L);  /* close it */
+    }
+    return 0;
+  }
+}
+
+/* }====================================================== */
+
+
+static int g_write (lua_State *L, FILE *f, int arg) {
+  int nargs = lua_gettop(L) - 1;
+  int status = 1;
+  for (; nargs--; arg++) {
+    if (lua_type(L, arg) == LUA_TNUMBER) {
+      /* optimization: could be done exactly as for strings */
+      status = status &&
+          fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0;
+    }
+    else {
+      size_t l;
+      const char *s = luaL_checklstring(L, arg, &l);
+      status = status && (fwrite(s, sizeof(char), l, f) == l);
+    }
+  }
+  return pushresult(L, status, NULL);
+}
+
+
+static int io_write (lua_State *L) {
+  return g_write(L, getiofile(L, IO_OUTPUT), 1);
+}
+
+
+static int f_write (lua_State *L) {
+  return g_write(L, tofile(L), 2);
+}
+
+
+static int f_seek (lua_State *L) {
+  static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
+  static const char *const modenames[] = {"set", "cur", "end", NULL};
+  FILE *f = tofile(L);
+  int op = luaL_checkoption(L, 2, "cur", modenames);
+  long offset = luaL_optlong(L, 3, 0);
+  op = fseek(f, offset, mode[op]);
+  if (op)
+    return pushresult(L, 0, NULL);  /* error */
+  else {
+    lua_pushinteger(L, ftell(f));
+    return 1;
+  }
+}
+
+
+static int f_setvbuf (lua_State *L) {
+  static const int mode[] = {_IONBF, _IOFBF, _IOLBF};
+  static const char *const modenames[] = {"no", "full", "line", NULL};
+  FILE *f = tofile(L);
+  int op = luaL_checkoption(L, 2, NULL, modenames);
+  lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);
+  int res = setvbuf(f, NULL, mode[op], sz);
+  return pushresult(L, res == 0, NULL);
+}
+
+
+
+static int io_flush (lua_State *L) {
+  return pushresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL);
+}
+
+
+static int f_flush (lua_State *L) {
+  return pushresult(L, fflush(tofile(L)) == 0, NULL);
+}
+
+
+static const luaL_Reg iolib[] = {
+  {"close", io_close},
+  {"flush", io_flush},
+  {"input", io_input},
+  {"lines", io_lines},
+  {"open", io_open},
+  {"output", io_output},
+  {"popen", io_popen},
+  {"read", io_read},
+  {"tmpfile", io_tmpfile},
+  {"type", io_type},
+  {"write", io_write},
+  {NULL, NULL}
+};
+
+
+static const luaL_Reg flib[] = {
+  {"close", io_close},
+  {"flush", f_flush},
+  {"lines", f_lines},
+  {"read", f_read},
+  {"seek", f_seek},
+  {"setvbuf", f_setvbuf},
+  {"write", f_write},
+  {"__gc", io_gc},
+  {"__tostring", io_tostring},
+  {NULL, NULL}
+};
+
+
+static void createmeta (lua_State *L) {
+  luaL_newmetatable(L, LUA_FILEHANDLE);  /* create metatable for file handles */
+  lua_pushvalue(L, -1);  /* push metatable */
+  lua_setfield(L, -2, "__index");  /* metatable.__index = metatable */
+  luaL_register(L, NULL, flib);  /* file methods */
+}
+
+
+static void createstdfile (lua_State *L, FILE *f, int k, const char *fname) {
+  *newfile(L) = f;
+  if (k > 0) {
+    lua_pushvalue(L, -1);
+    lua_rawseti(L, LUA_ENVIRONINDEX, k);
+  }
+  lua_pushvalue(L, -2);  /* copy environment */
+  lua_setfenv(L, -2);  /* set it */
+  lua_setfield(L, -3, fname);
+}
+
+
+static void newfenv (lua_State *L, lua_CFunction cls) {
+  lua_createtable(L, 0, 1);
+  lua_pushcfunction(L, cls);
+  lua_setfield(L, -2, "__close");
+}
+
+
+LUALIB_API int luaopen_io (lua_State *L) {
+  createmeta(L);
+  /* create (private) environment (with fields IO_INPUT, IO_OUTPUT, __close) */
+  newfenv(L, io_fclose);
+  lua_replace(L, LUA_ENVIRONINDEX);
+  /* open library */
+  luaL_register(L, LUA_IOLIBNAME, iolib);
+  /* create (and set) default files */
+  newfenv(L, io_noclose);  /* close function for default files */
+  createstdfile(L, stdin, IO_INPUT, "stdin");
+  createstdfile(L, stdout, IO_OUTPUT, "stdout");
+  createstdfile(L, stderr, 0, "stderr");
+  lua_pop(L, 1);  /* pop environment for default files */
+  lua_getfield(L, -1, "popen");
+  newfenv(L, io_pclose);  /* create environment for 'popen' */
+  lua_setfenv(L, -2);  /* set fenv for 'popen' */
+  lua_pop(L, 1);  /* pop 'popen' */
+  return 1;
+}
+

lua/src/llex.c

@@ -0,0 +1,466 @@
+/*
+** $Id: llex.c,v 2.20.1.1 2007/12/27 13:02:25 roberto Exp $
+** Lexical Analyzer
+** See Copyright Notice in lua.h
+*/
+
+
+#include <ctype.h>
+#include <locale.h>
+#include <string.h>
+
+#define llex_c
+#define LUA_CORE
+
+#include "lua.h"
+
+#include "ldo.h"
+#include "llex.h"
+#include "lobject.h"
+#include "lparser.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "lzio.h"
+
+
+
+#define next(ls) (ls->current = zgetc(ls->z))
+
+
+
+
+#define currIsNewline(ls)	(ls->current == '\n' || ls->current == '\r')
+
+
+/* ORDER RESERVED */
+const char *const luaX_tokens [] = {
+    "and", "break", "do", "else", "elseif",
+    "end", "false", "for", "function", "if",
+    "in", "local", "nil", "not", "or", "repeat",
+    "return", "then", "true", "until", "while",
+    "..", "...", "==", ">=", "<=", "~=",
+    "<number>", "<name>", "<string>", "<eof>",
+    NULL
+};
+
+
+#define save_and_next(ls) (save(ls, ls->current), next(ls))
+
+
+static void save (LexState *ls, int c) {
+  Mbuffer *b = ls->buff;
+  if (b->n + 1 > b->buffsize) {
+    size_t newsize;
+    if (b->buffsize >= MAX_SIZET/2)
+      luaX_lexerror(ls, "lexical element too long", 0);
+    newsize = b->buffsize * 2;
+    luaZ_resizebuffer(ls->L, b, newsize);
+  }
+  b->buffer[b->n++] = cast(char, c);
+}
+
+
+void luaX_init (lua_State *L) {
+  int i;
+  for (i=0; i<NUM_RESERVED; i++) {
+    TString *ts = luaS_new(L, luaX_tokens[i]);
+    luaS_fix(ts);  /* reserved words are never collected */
+    lua_assert(strlen(luaX_tokens[i])+1 <= TOKEN_LEN);
+    ts->tsv.reserved = cast_byte(i+1);  /* reserved word */
+  }
+}
+
+
+#define MAXSRC          80
+
+
+const char *luaX_token2str (LexState *ls, int token) {
+  if (token < FIRST_RESERVED) {
+    lua_assert(token == cast(unsigned char, token));
+    return (iscntrl(token)) ? luaO_pushfstring(ls->L, "char(%d)", token) :
+                              luaO_pushfstring(ls->L, "%c", token);
+  }
+  else
+    return luaX_tokens[token-FIRST_RESERVED];
+}
+
+
+static const char *txtToken (LexState *ls, int token) {
+  switch (token) {
+    case TK_NAME:
+    case TK_STRING:
+    case TK_NUMBER:
+      save(ls, '\0');
+      return luaZ_buffer(ls->buff);
+    default:
+      return luaX_token2str(ls, token);
+  }
+}
+
+
+void luaX_lexerror (LexState *ls, const char *msg, int token) {
+  char buff[MAXSRC];
+  luaO_chunkid(buff, getstr(ls->source), MAXSRC);
+  msg = luaO_pushfstring(ls->L, "%s:%d: %s", buff, ls->linenumber, msg);
+  if (token)
+    luaO_pushfstring(ls->L, "%s near " LUA_QS, msg, txtToken(ls, token));
+  luaD_throw(ls->L, LUA_ERRSYNTAX);
+}
+
+
+void luaX_syntaxerror (LexState *ls, const char *msg) {
+  luaX_lexerror(ls, msg, ls->t.token);
+}
+
+
+TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
+  lua_State *L = ls->L;
+  TString *ts = luaS_newlstr(L, str, l);
+  TValue *o = luaH_setstr(L, ls->fs->h, ts);  /* entry for `str' */
+  if (ttisnil(o))
+    setbvalue(o, 1);  /* make sure `str' will not be collected */
+  return ts;
+}
+
+
+static void inclinenumber (LexState *ls) {
+  int old = ls->current;
+  lua_assert(currIsNewline(ls));
+  next(ls);  /* skip `\n' or `\r' */
+  if (currIsNewline(ls) && ls->current != old)
+    next(ls);  /* skip `\n\r' or `\r\n' */
+  if (++ls->linenumber >= MAX_INT)
+    luaX_syntaxerror(ls, "chunk has too many lines");
+}
+
+
+void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source) {
+  ls->decpoint = '.';
+  ls->L = L;
+  ls->lookahead.token = TK_EOS;  /* no look-ahead token */
+  ls->z = z;
+  ls->fs = NULL;
+  ls->linenumber = 1;
+  ls->lastline = 1;
+  ls->source = source;
+  luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER);  /* initialize buffer */
+  next(ls);  /* read first char */
+}
+
+
+
+/*
+** =======================================================
+** LEXICAL ANALYZER
+** =======================================================
+*/
+
+
+
+static int check_next (LexState *ls, const char *set) {
+  if (!strchr(set, ls->current))
+    return 0;
+  save_and_next(ls);
+  return 1;
+}
+
+
+static void buffreplace (LexState *ls, char from, char to) {
+  size_t n = luaZ_bufflen(ls->buff);
+  char *p = luaZ_buffer(ls->buff);
+  while (n--)
+    if (p[n] == from) p[n] = to;
+}
+
+
+static void trydecpoint (LexState *ls, SemInfo *seminfo) {
+  /* format error: try to update decimal point separator */
+#ifdef ANDROID
+	char old = ls->decpoint;
+	ls->decpoint =  '.';
+#else
+  struct lconv *cv = localeconv();
+  char old = ls->decpoint;
+  ls->decpoint = (cv ? cv->decimal_point[0] : '.');
+#endif
+  buffreplace(ls, old, ls->decpoint);  /* try updated decimal separator */
+  if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r)) {
+    /* format error with correct decimal point: no more options */
+    buffreplace(ls, ls->decpoint, '.');  /* undo change (for error message) */
+    luaX_lexerror(ls, "malformed number", TK_NUMBER);
+  }
+}
+
+
+/* LUA_NUMBER */
+static void read_numeral (LexState *ls, SemInfo *seminfo) {
+  lua_assert(isdigit(ls->current));
+  do {
+    save_and_next(ls);
+  } while (isdigit(ls->current) || ls->current == '.');
+  if (check_next(ls, "Ee"))  /* `E'? */
+    check_next(ls, "+-");  /* optional exponent sign */
+  while (isalnum(ls->current) || ls->current == '_')
+    save_and_next(ls);
+  save(ls, '\0');
+  buffreplace(ls, '.', ls->decpoint);  /* follow locale for decimal point */
+  if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r))  /* format error? */
+    trydecpoint(ls, seminfo); /* try to update decimal point separator */
+}
+
+
+static int skip_sep (LexState *ls) {
+  int count = 0;
+  int s = ls->current;
+  lua_assert(s == '[' || s == ']');
+  save_and_next(ls);
+  while (ls->current == '=') {
+    save_and_next(ls);
+    count++;
+  }
+  return (ls->current == s) ? count : (-count) - 1;
+}
+
+
+static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) {
+  int cont = 0;
+  (void)(cont);  /* avoid warnings when `cont' is not used */
+  save_and_next(ls);  /* skip 2nd `[' */
+  if (currIsNewline(ls))  /* string starts with a newline? */
+    inclinenumber(ls);  /* skip it */
+  for (;;) {
+    switch (ls->current) {
+      case EOZ:
+        luaX_lexerror(ls, (seminfo) ? "unfinished long string" :
+                                   "unfinished long comment", TK_EOS);
+        break;  /* to avoid warnings */
+#if defined(LUA_COMPAT_LSTR)
+      case '[': {
+        if (skip_sep(ls) == sep) {
+          save_and_next(ls);  /* skip 2nd `[' */
+          cont++;
+#if LUA_COMPAT_LSTR == 1
+          if (sep == 0)
+            luaX_lexerror(ls, "nesting of [[...]] is deprecated", '[');
+#endif
+        }
+        break;
+      }
+#endif
+      case ']': {
+        if (skip_sep(ls) == sep) {
+          save_and_next(ls);  /* skip 2nd `]' */
+#if defined(LUA_COMPAT_LSTR) && LUA_COMPAT_LSTR == 2
+          cont--;
+          if (sep == 0 && cont >= 0) break;
+#endif
+          goto endloop;
+        }
+        break;
+      }
+      case '\n':
+      case '\r': {
+        save(ls, '\n');
+        inclinenumber(ls);
+        if (!seminfo) luaZ_resetbuffer(ls->buff);  /* avoid wasting space */
+        break;
+      }
+      default: {
+        if (seminfo) save_and_next(ls);
+        else next(ls);
+      }
+    }
+  } endloop:
+  if (seminfo)
+    seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep),
+                                     luaZ_bufflen(ls->buff) - 2*(2 + sep));
+}
+
+
+static void read_string (LexState *ls, int del, SemInfo *seminfo) {
+  save_and_next(ls);
+  while (ls->current != del) {
+    switch (ls->current) {
+      case EOZ:
+        luaX_lexerror(ls, "unfinished string", TK_EOS);
+        continue;  /* to avoid warnings */
+      case '\n':
+      case '\r':
+        luaX_lexerror(ls, "unfinished string", TK_STRING);
+        continue;  /* to avoid warnings */
+      case '\\': {
+        int c;
+        next(ls);  /* do not save the `\' */
+        switch (ls->current) {
+          case 'a': c = '\a'; break;
+          case 'b': c = '\b'; break;
+          case 'f': c = '\f'; break;
+          case 'n': c = '\n'; break;
+          case 'r': c = '\r'; break;
+          case 't': c = '\t'; break;
+          case 'v': c = '\v'; break;
+          case '\n':  /* go through */
+          case '\r': save(ls, '\n'); inclinenumber(ls); continue;
+          case EOZ: continue;  /* will raise an error next loop */
+          default: {
+            if (!isdigit(ls->current))
+              save_and_next(ls);  /* handles \\, \", \', and \? */
+            else {  /* \xxx */
+              int i = 0;
+              c = 0;
+              do {
+                c = 10*c + (ls->current-'0');
+                next(ls);
+              } while (++i<3 && isdigit(ls->current));
+              if (c > UCHAR_MAX)
+                luaX_lexerror(ls, "escape sequence too large", TK_STRING);
+              save(ls, c);
+            }
+            continue;
+          }
+        }
+        save(ls, c);
+        next(ls);
+        continue;
+      }
+      default:
+        save_and_next(ls);
+    }
+  }
+  save_and_next(ls);  /* skip delimiter */
+  seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1,
+                                   luaZ_bufflen(ls->buff) - 2);
+}
+
+
+static int llex (LexState *ls, SemInfo *seminfo) {
+  luaZ_resetbuffer(ls->buff);
+  for (;;) {
+    switch (ls->current) {
+      case '\n':
+      case '\r': {
+        inclinenumber(ls);
+        continue;
+      }
+      case '-': {
+        next(ls);
+        if (ls->current != '-') return '-';
+        /* else is a comment */
+        next(ls);
+        if (ls->current == '[') {
+          int sep = skip_sep(ls);
+          luaZ_resetbuffer(ls->buff);  /* `skip_sep' may dirty the buffer */
+          if (sep >= 0) {
+            read_long_string(ls, NULL, sep);  /* long comment */
+            luaZ_resetbuffer(ls->buff);
+            continue;
+          }
+        }
+        /* else short comment */
+        while (!currIsNewline(ls) && ls->current != EOZ)
+          next(ls);
+        continue;
+      }
+      case '[': {
+        int sep = skip_sep(ls);
+        if (sep >= 0) {
+          read_long_string(ls, seminfo, sep);
+          return TK_STRING;
+        }
+        else if (sep == -1) return '[';
+        else luaX_lexerror(ls, "invalid long string delimiter", TK_STRING);
+      }
+      case '=': {
+        next(ls);
+        if (ls->current != '=') return '=';
+        else { next(ls); return TK_EQ; }
+      }
+      case '<': {
+        next(ls);
+        if (ls->current != '=') return '<';
+        else { next(ls); return TK_LE; }
+      }
+      case '>': {
+        next(ls);
+        if (ls->current != '=') return '>';
+        else { next(ls); return TK_GE; }
+      }
+      case '~': {
+        next(ls);
+        if (ls->current != '=') return '~';
+        else { next(ls); return TK_NE; }
+      }
+      case '"':
+      case '\'': {
+        read_string(ls, ls->current, seminfo);
+        return TK_STRING;
+      }
+      case '.': {
+        save_and_next(ls);
+        if (check_next(ls, ".")) {
+          if (check_next(ls, "."))
+            return TK_DOTS;   /* ... */
+          else return TK_CONCAT;   /* .. */
+        }
+        else if (!isdigit(ls->current)) return '.';
+        else {
+          read_numeral(ls, seminfo);
+          return TK_NUMBER;
+        }
+      }
+      case EOZ: {
+        return TK_EOS;
+      }
+      default: {
+        if (isspace(ls->current)) {
+          lua_assert(!currIsNewline(ls));
+          next(ls);
+          continue;
+        }
+        else if (isdigit(ls->current)) {
+          read_numeral(ls, seminfo);
+          return TK_NUMBER;
+        }
+        else if (isalpha(ls->current) || ls->current == '_') {
+          /* identifier or reserved word */
+          TString *ts;
+          do {
+            save_and_next(ls);
+          } while (isalnum(ls->current) || ls->current == '_');
+          ts = luaX_newstring(ls, luaZ_buffer(ls->buff),
+                                  luaZ_bufflen(ls->buff));
+          if (ts->tsv.reserved > 0)  /* reserved word? */
+            return ts->tsv.reserved - 1 + FIRST_RESERVED;
+          else {
+            seminfo->ts = ts;
+            return TK_NAME;
+          }
+        }
+        else {
+          int c = ls->current;
+          next(ls);
+          return c;  /* single-char tokens (+ - / ...) */
+        }
+      }
+    }
+  }
+}
+
+
+void luaX_next (LexState *ls) {
+  ls->lastline = ls->linenumber;
+  if (ls->lookahead.token != TK_EOS) {  /* is there a look-ahead token? */
+    ls->t = ls->lookahead;  /* use this one */
+    ls->lookahead.token = TK_EOS;  /* and discharge it */
+  }
+  else
+    ls->t.token = llex(ls, &ls->t.seminfo);  /* read next token */
+}
+
+
+void luaX_lookahead (LexState *ls) {
+  lua_assert(ls->lookahead.token == TK_EOS);
+  ls->lookahead.token = llex(ls, &ls->lookahead.seminfo);
+}
+

lua/src/llex.h

@@ -0,0 +1,81 @@
+/*
+** $Id: llex.h,v 1.58.1.1 2007/12/27 13:02:25 roberto Exp $
+** Lexical Analyzer
+** See Copyright Notice in lua.h
+*/
+
+#ifndef llex_h
+#define llex_h
+
+#include "lobject.h"
+#include "lzio.h"
+
+
+#define FIRST_RESERVED	257
+
+/* maximum length of a reserved word */
+#define TOKEN_LEN	(sizeof("function")/sizeof(char))
+
+
+/*
+* WARNING: if you change the order of this enumeration,
+* grep "ORDER RESERVED"
+*/
+enum RESERVED {
+  /* terminal symbols denoted by reserved words */
+  TK_AND = FIRST_RESERVED, TK_BREAK,
+  TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION,
+  TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
+  TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
+  /* other terminal symbols */
+  TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_NUMBER,
+  TK_NAME, TK_STRING, TK_EOS
+};
+
+/* number of reserved words */
+#define NUM_RESERVED	(cast(int, TK_WHILE-FIRST_RESERVED+1))
+
+
+/* array with token `names' */
+LUAI_DATA const char *const luaX_tokens [];
+
+
+typedef union {
+  lua_Number r;
+  TString *ts;
+} SemInfo;  /* semantics information */
+
+
+typedef struct Token {
+  int token;
+  SemInfo seminfo;
+} Token;
+
+
+typedef struct LexState {
+  int current;  /* current character (charint) */
+  int linenumber;  /* input line counter */
+  int lastline;  /* line of last token `consumed' */
+  Token t;  /* current token */
+  Token lookahead;  /* look ahead token */
+  struct FuncState *fs;  /* `FuncState' is private to the parser */
+  struct lua_State *L;
+  ZIO *z;  /* input stream */
+  Mbuffer *buff;  /* buffer for tokens */
+  TString *source;  /* current source name */
+  char decpoint;  /* locale decimal point */
+} LexState;
+
+
+LUAI_FUNC void luaX_init (lua_State *L);
+LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z,
+                              TString *source);
+LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l);
+LUAI_FUNC void luaX_next (LexState *ls);
+LUAI_FUNC void luaX_lookahead (LexState *ls);
+LUAI_FUNC void luaX_lexerror (LexState *ls, const char *msg, int token);
+LUAI_FUNC void luaX_syntaxerror (LexState *ls, const char *s);
+LUAI_FUNC const char *luaX_token2str (LexState *ls, int token);
+
+
+#endif

lua/src/llimits.h

@@ -0,0 +1,128 @@
+/*
+** $Id: llimits.h,v 1.69.1.1 2007/12/27 13:02:25 roberto Exp $
+** Limits, basic types, and some other `installation-dependent' definitions
+** See Copyright Notice in lua.h
+*/
+
+#ifndef llimits_h
+#define llimits_h
+
+
+#include <limits.h>
+#include <stddef.h>
+
+
+#include "lua.h"
+
+
+typedef LUAI_UINT32 lu_int32;
+
+typedef LUAI_UMEM lu_mem;
+
+typedef LUAI_MEM l_mem;
+
+
+
+/* chars used as small naturals (so that `char' is reserved for characters) */
+typedef unsigned char lu_byte;
+
+
+#define MAX_SIZET	((size_t)(~(size_t)0)-2)
+
+#define MAX_LUMEM	((lu_mem)(~(lu_mem)0)-2)
+
+
+#define MAX_INT (INT_MAX-2)  /* maximum value of an int (-2 for safety) */
+
+/*
+** conversion of pointer to integer
+** this is for hashing only; there is no problem if the integer
+** cannot hold the whole pointer value
+*/
+#define IntPoint(p)  ((unsigned int)(lu_mem)(p))
+
+
+
+/* type to ensure maximum alignment */
+typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
+
+
+/* result of a `usual argument conversion' over lua_Number */
+typedef LUAI_UACNUMBER l_uacNumber;
+
+
+/* internal assertions for in-house debugging */
+#ifdef lua_assert
+
+#define check_exp(c,e)		(lua_assert(c), (e))
+#define api_check(l,e)		lua_assert(e)
+
+#else
+
+#define lua_assert(c)		((void)0)
+#define check_exp(c,e)		(e)
+#define api_check		luai_apicheck
+
+#endif
+
+
+#ifndef UNUSED
+#define UNUSED(x)	((void)(x))	/* to avoid warnings */
+#endif
+
+
+#ifndef cast
+#define cast(t, exp)	((t)(exp))
+#endif
+
+#define cast_byte(i)	cast(lu_byte, (i))
+#define cast_num(i)	cast(lua_Number, (i))
+#define cast_int(i)	cast(int, (i))
+
+
+
+/*
+** type for virtual-machine instructions
+** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
+*/
+typedef lu_int32 Instruction;
+
+
+
+/* maximum stack for a Lua function */
+#define MAXSTACK	250
+
+
+
+/* minimum size for the string table (must be power of 2) */
+#ifndef MINSTRTABSIZE
+#define MINSTRTABSIZE	32
+#endif
+
+
+/* minimum size for string buffer */
+#ifndef LUA_MINBUFFER
+#define LUA_MINBUFFER	32
+#endif
+
+
+#ifndef lua_lock
+#define lua_lock(L)     ((void) 0) 
+#define lua_unlock(L)   ((void) 0)
+#endif
+
+#ifndef luai_threadyield
+#define luai_threadyield(L)     {lua_unlock(L); lua_lock(L);}
+#endif
+
+
+/*
+** macro to control inclusion of some hard tests on stack reallocation
+*/ 
+#ifndef HARDSTACKTESTS
+#define condhardstacktests(x)	((void)0)
+#else
+#define condhardstacktests(x)	x
+#endif
+
+#endif

lua/src/lmathlib.c

@@ -0,0 +1,263 @@
+/*
+** $Id: lmathlib.c,v 1.67.1.1 2007/12/27 13:02:25 roberto Exp $
+** Standard mathematical library
+** See Copyright Notice in lua.h
+*/
+
+
+#include <stdlib.h>
+#include <math.h>
+
+#define lmathlib_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "lualib.h"
+
+
+#undef PI
+#define PI (3.14159265358979323846)
+#define RADIANS_PER_DEGREE (PI/180.0)
+
+
+
+static int math_abs (lua_State *L) {
+  lua_pushnumber(L, fabs(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_sin (lua_State *L) {
+  lua_pushnumber(L, sin(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_sinh (lua_State *L) {
+  lua_pushnumber(L, sinh(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_cos (lua_State *L) {
+  lua_pushnumber(L, cos(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_cosh (lua_State *L) {
+  lua_pushnumber(L, cosh(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_tan (lua_State *L) {
+  lua_pushnumber(L, tan(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_tanh (lua_State *L) {
+  lua_pushnumber(L, tanh(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_asin (lua_State *L) {
+  lua_pushnumber(L, asin(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_acos (lua_State *L) {
+  lua_pushnumber(L, acos(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_atan (lua_State *L) {
+  lua_pushnumber(L, atan(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_atan2 (lua_State *L) {
+  lua_pushnumber(L, atan2(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
+  return 1;
+}
+
+static int math_ceil (lua_State *L) {
+  lua_pushnumber(L, ceil(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_floor (lua_State *L) {
+  lua_pushnumber(L, floor(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_fmod (lua_State *L) {
+  lua_pushnumber(L, fmod(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
+  return 1;
+}
+
+static int math_modf (lua_State *L) {
+  double ip;
+  double fp = modf(luaL_checknumber(L, 1), &ip);
+  lua_pushnumber(L, ip);
+  lua_pushnumber(L, fp);
+  return 2;
+}
+
+static int math_sqrt (lua_State *L) {
+  lua_pushnumber(L, sqrt(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_pow (lua_State *L) {
+  lua_pushnumber(L, pow(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
+  return 1;
+}
+
+static int math_log (lua_State *L) {
+  lua_pushnumber(L, log(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_log10 (lua_State *L) {
+  lua_pushnumber(L, log10(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_exp (lua_State *L) {
+  lua_pushnumber(L, exp(luaL_checknumber(L, 1)));
+  return 1;
+}
+
+static int math_deg (lua_State *L) {
+  lua_pushnumber(L, luaL_checknumber(L, 1)/RADIANS_PER_DEGREE);
+  return 1;
+}
+
+static int math_rad (lua_State *L) {
+  lua_pushnumber(L, luaL_checknumber(L, 1)*RADIANS_PER_DEGREE);
+  return 1;
+}
+
+static int math_frexp (lua_State *L) {
+  int e;
+  lua_pushnumber(L, frexp(luaL_checknumber(L, 1), &e));
+  lua_pushinteger(L, e);
+  return 2;
+}
+
+static int math_ldexp (lua_State *L) {
+  lua_pushnumber(L, ldexp(luaL_checknumber(L, 1), luaL_checkint(L, 2)));
+  return 1;
+}
+
+
+
+static int math_min (lua_State *L) {
+  int n = lua_gettop(L);  /* number of arguments */
+  lua_Number dmin = luaL_checknumber(L, 1);
+  int i;
+  for (i=2; i<=n; i++) {
+    lua_Number d = luaL_checknumber(L, i);
+    if (d < dmin)
+      dmin = d;
+  }
+  lua_pushnumber(L, dmin);
+  return 1;
+}
+
+
+static int math_max (lua_State *L) {
+  int n = lua_gettop(L);  /* number of arguments */
+  lua_Number dmax = luaL_checknumber(L, 1);
+  int i;
+  for (i=2; i<=n; i++) {
+    lua_Number d = luaL_checknumber(L, i);
+    if (d > dmax)
+      dmax = d;
+  }
+  lua_pushnumber(L, dmax);
+  return 1;
+}
+
+
+static int math_random (lua_State *L) {
+  /* the `%' avoids the (rare) case of r==1, and is needed also because on
+     some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */
+  lua_Number r = (lua_Number)(rand()%RAND_MAX) / (lua_Number)RAND_MAX;
+  switch (lua_gettop(L)) {  /* check number of arguments */
+    case 0: {  /* no arguments */
+      lua_pushnumber(L, r);  /* Number between 0 and 1 */
+      break;
+    }
+    case 1: {  /* only upper limit */
+      int u = luaL_checkint(L, 1);
+      luaL_argcheck(L, 1<=u, 1, "interval is empty");
+      lua_pushnumber(L, floor(r*u)+1);  /* int between 1 and `u' */
+      break;
+    }
+    case 2: {  /* lower and upper limits */
+      int l = luaL_checkint(L, 1);
+      int u = luaL_checkint(L, 2);
+      luaL_argcheck(L, l<=u, 2, "interval is empty");
+      lua_pushnumber(L, floor(r*(u-l+1))+l);  /* int between `l' and `u' */
+      break;
+    }
+    default: return luaL_error(L, "wrong number of arguments");
+  }
+  return 1;
+}
+
+
+static int math_randomseed (lua_State *L) {
+  srand(luaL_checkint(L, 1));
+  return 0;
+}
+
+
+static const luaL_Reg mathlib[] = {
+  {"abs",   math_abs},
+  {"acos",  math_acos},
+  {"asin",  math_asin},
+  {"atan2", math_atan2},
+  {"atan",  math_atan},
+  {"ceil",  math_ceil},
+  {"cosh",   math_cosh},
+  {"cos",   math_cos},
+  {"deg",   math_deg},
+  {"exp",   math_exp},
+  {"floor", math_floor},
+  {"fmod",   math_fmod},
+  {"frexp", math_frexp},
+  {"ldexp", math_ldexp},
+  {"log10", math_log10},
+  {"log",   math_log},
+  {"max",   math_max},
+  {"min",   math_min},
+  {"modf",   math_modf},
+  {"pow",   math_pow},
+  {"rad",   math_rad},
+  {"random",     math_random},
+  {"randomseed", math_randomseed},
+  {"sinh",   math_sinh},
+  {"sin",   math_sin},
+  {"sqrt",  math_sqrt},
+  {"tanh",   math_tanh},
+  {"tan",   math_tan},
+  {NULL, NULL}
+};
+
+
+/*
+** Open math library
+*/
+LUALIB_API int luaopen_math (lua_State *L) {
+  luaL_register(L, LUA_MATHLIBNAME, mathlib);
+  lua_pushnumber(L, PI);
+  lua_setfield(L, -2, "pi");
+  lua_pushnumber(L, HUGE_VAL);
+  lua_setfield(L, -2, "huge");
+#if defined(LUA_COMPAT_MOD)
+  lua_getfield(L, -1, "fmod");
+  lua_setfield(L, -2, "mod");
+#endif
+  return 1;
+}
+