From 6bd2a34271ef7469455e4679b4d8bc9ca9f79e36 Mon Sep 17 00:00:00 2001 From: Chris Danford Date: Sun, 20 Jun 2004 01:35:25 +0000 Subject: [PATCH] Xbox builds again --- stepmania/src/LuaHelpers.cpp | 10 +- stepmania/src/ProfileHtml.cpp | 2 +- stepmania/src/RageDisplay_D3D.cpp | 2 +- stepmania/src/RageFileManager.cpp | 2 +- stepmania/src/RageSurface_Load_PNG.cpp | 14 +- stepmania/src/StepMania.cpp | 10 +- stepmania/src/StepManiaXbox.vcproj | 251 +++- .../src/arch/ArchHooks/ArchHooks_Xbox.cpp | 48 + stepmania/src/arch/ArchHooks/ArchHooks_Xbox.h | 47 + stepmania/src/arch/Dialog/Dialog.cpp | 2 +- stepmania/src/arch/Sound/DSoundHelpers.cpp | 2 + stepmania/src/arch/Threads/Threads_Win32.h | 6 +- stepmania/src/arch/arch_xbox.h | 10 +- stepmania/src/archutils/Win32/AppInstance.h | 4 +- stepmania/src/archutils/Win32/arch_setup.cpp | 4 +- stepmania/src/archutils/Win32/arch_setup.h | 6 +- .../Xbox}/custom_launch_params.cpp | 0 .../Xbox}/custom_launch_params.h | 0 stepmania/src/crypto/CryptNoise.cpp | 11 +- stepmania/src/crypto51/config.h | 4 +- stepmania/src/global.cpp | 9 +- stepmania/src/libresample/src/config.h | 4 +- stepmania/src/lua-5.0/COPYRIGHT | 34 + stepmania/src/lua-5.0/Lua.dsw | 41 + stepmania/src/lua-5.0/LuaXbox.sln | 27 + stepmania/src/lua-5.0/{ => include}/lauxlib.h | 0 stepmania/src/lua-5.0/{ => include}/lua.h | 6 +- stepmania/src/lua-5.0/{ => include}/lualib.h | 0 stepmania/src/lua-5.0/lib/LibLua.lib | Bin 0 -> 325392 bytes stepmania/src/lua-5.0/lib/LibLuaLib.lib | Bin 0 -> 173106 bytes stepmania/src/lua-5.0/lib/LibLuaLibXbox.lib | Bin 0 -> 173106 bytes stepmania/src/lua-5.0/lib/LibLuaXbox.lib | Bin 0 -> 219814 bytes stepmania/src/lua-5.0/lua.lib | Bin 23460 -> 0 bytes stepmania/src/lua-5.0/src/LibLua.dsp | 250 ++++ stepmania/src/lua-5.0/src/LibLua.vcproj | 225 +++ stepmania/src/lua-5.0/src/lapi.c | 922 ++++++++++++ stepmania/src/lua-5.0/src/lapi.h | 16 + stepmania/src/lua-5.0/src/lcode.c | 714 +++++++++ stepmania/src/lua-5.0/src/lcode.h | 74 + stepmania/src/lua-5.0/src/ldebug.c | 585 ++++++++ stepmania/src/lua-5.0/src/ldebug.h | 31 + stepmania/src/lua-5.0/src/ldo.c | 471 ++++++ stepmania/src/lua-5.0/src/ldo.h | 60 + stepmania/src/lua-5.0/src/ldump.c | 170 +++ stepmania/src/lua-5.0/src/lfunc.c | 135 ++ stepmania/src/lua-5.0/src/lfunc.h | 25 + stepmania/src/lua-5.0/src/lgc.c | 498 ++++++ stepmania/src/lua-5.0/src/lgc.h | 25 + stepmania/src/lua-5.0/src/lib/LibLuaLib.dsp | 127 ++ .../src/lua-5.0/src/lib/LibLuaLib.vcproj | 144 ++ stepmania/src/lua-5.0/src/lib/lauxlib.c | 591 ++++++++ stepmania/src/lua-5.0/src/lib/lbaselib.c | 677 +++++++++ stepmania/src/lua-5.0/src/lib/ldblib.c | 299 ++++ stepmania/src/lua-5.0/src/lib/liolib.c | 750 ++++++++++ stepmania/src/lua-5.0/src/lib/lmathlib.c | 246 +++ stepmania/src/lua-5.0/src/lib/loadlib.c | 209 +++ stepmania/src/lua-5.0/src/lib/lstrlib.c | 770 ++++++++++ stepmania/src/lua-5.0/src/lib/ltablib.c | 250 ++++ stepmania/src/lua-5.0/src/llex.c | 417 ++++++ stepmania/src/lua-5.0/src/llex.h | 75 + stepmania/src/lua-5.0/src/llimits.h | 185 +++ stepmania/src/lua-5.0/src/lmem.c | 91 ++ stepmania/src/lua-5.0/src/lmem.h | 44 + stepmania/src/lua-5.0/src/lobject.c | 195 +++ stepmania/src/lua-5.0/src/lobject.h | 336 +++++ stepmania/src/lua-5.0/src/lopcodes.c | 102 ++ stepmania/src/lua-5.0/src/lopcodes.h | 238 +++ stepmania/src/lua-5.0/src/lparser.c | 1333 +++++++++++++++++ stepmania/src/lua-5.0/src/lparser.h | 71 + stepmania/src/lua-5.0/src/lstate.c | 220 +++ stepmania/src/lua-5.0/src/lstate.h | 195 +++ stepmania/src/lua-5.0/src/lstring.c | 102 ++ stepmania/src/lua-5.0/src/lstring.h | 33 + stepmania/src/lua-5.0/src/ltable.c | 509 +++++++ stepmania/src/lua-5.0/src/ltable.h | 31 + stepmania/src/lua-5.0/src/ltests.c | 852 +++++++++++ stepmania/src/lua-5.0/src/ltm.c | 70 + stepmania/src/lua-5.0/src/ltm.h | 51 + stepmania/src/lua-5.0/src/lundump.c | 286 ++++ stepmania/src/lua-5.0/src/lundump.h | 34 + stepmania/src/lua-5.0/src/lvm.c | 781 ++++++++++ stepmania/src/lua-5.0/src/lvm.h | 35 + stepmania/src/lua-5.0/src/lzio.c | 81 + stepmania/src/lua-5.0/src/lzio.h | 64 + 84 files changed, 15210 insertions(+), 41 deletions(-) create mode 100644 stepmania/src/arch/ArchHooks/ArchHooks_Xbox.cpp create mode 100644 stepmania/src/arch/ArchHooks/ArchHooks_Xbox.h rename stepmania/src/{ => archutils/Xbox}/custom_launch_params.cpp (100%) rename stepmania/src/{ => archutils/Xbox}/custom_launch_params.h (100%) create mode 100644 stepmania/src/lua-5.0/COPYRIGHT create mode 100644 stepmania/src/lua-5.0/Lua.dsw create mode 100644 stepmania/src/lua-5.0/LuaXbox.sln rename stepmania/src/lua-5.0/{ => include}/lauxlib.h (100%) rename stepmania/src/lua-5.0/{ => include}/lua.h (98%) rename stepmania/src/lua-5.0/{ => include}/lualib.h (100%) create mode 100644 stepmania/src/lua-5.0/lib/LibLua.lib create mode 100644 stepmania/src/lua-5.0/lib/LibLuaLib.lib create mode 100644 stepmania/src/lua-5.0/lib/LibLuaLibXbox.lib create mode 100644 stepmania/src/lua-5.0/lib/LibLuaXbox.lib delete mode 100644 stepmania/src/lua-5.0/lua.lib create mode 100644 stepmania/src/lua-5.0/src/LibLua.dsp create mode 100644 stepmania/src/lua-5.0/src/LibLua.vcproj create mode 100644 stepmania/src/lua-5.0/src/lapi.c create mode 100644 stepmania/src/lua-5.0/src/lapi.h create mode 100644 stepmania/src/lua-5.0/src/lcode.c create mode 100644 stepmania/src/lua-5.0/src/lcode.h create mode 100644 stepmania/src/lua-5.0/src/ldebug.c create mode 100644 stepmania/src/lua-5.0/src/ldebug.h create mode 100644 stepmania/src/lua-5.0/src/ldo.c create mode 100644 stepmania/src/lua-5.0/src/ldo.h create mode 100644 stepmania/src/lua-5.0/src/ldump.c create mode 100644 stepmania/src/lua-5.0/src/lfunc.c create mode 100644 stepmania/src/lua-5.0/src/lfunc.h create mode 100644 stepmania/src/lua-5.0/src/lgc.c create mode 100644 stepmania/src/lua-5.0/src/lgc.h create mode 100644 stepmania/src/lua-5.0/src/lib/LibLuaLib.dsp create mode 100644 stepmania/src/lua-5.0/src/lib/LibLuaLib.vcproj create mode 100644 stepmania/src/lua-5.0/src/lib/lauxlib.c create mode 100644 stepmania/src/lua-5.0/src/lib/lbaselib.c create mode 100644 stepmania/src/lua-5.0/src/lib/ldblib.c create mode 100644 stepmania/src/lua-5.0/src/lib/liolib.c create mode 100644 stepmania/src/lua-5.0/src/lib/lmathlib.c create mode 100644 stepmania/src/lua-5.0/src/lib/loadlib.c create mode 100644 stepmania/src/lua-5.0/src/lib/lstrlib.c create mode 100644 stepmania/src/lua-5.0/src/lib/ltablib.c create mode 100644 stepmania/src/lua-5.0/src/llex.c create mode 100644 stepmania/src/lua-5.0/src/llex.h create mode 100644 stepmania/src/lua-5.0/src/llimits.h create mode 100644 stepmania/src/lua-5.0/src/lmem.c create mode 100644 stepmania/src/lua-5.0/src/lmem.h create mode 100644 stepmania/src/lua-5.0/src/lobject.c create mode 100644 stepmania/src/lua-5.0/src/lobject.h create mode 100644 stepmania/src/lua-5.0/src/lopcodes.c create mode 100644 stepmania/src/lua-5.0/src/lopcodes.h create mode 100644 stepmania/src/lua-5.0/src/lparser.c create mode 100644 stepmania/src/lua-5.0/src/lparser.h create mode 100644 stepmania/src/lua-5.0/src/lstate.c create mode 100644 stepmania/src/lua-5.0/src/lstate.h create mode 100644 stepmania/src/lua-5.0/src/lstring.c create mode 100644 stepmania/src/lua-5.0/src/lstring.h create mode 100644 stepmania/src/lua-5.0/src/ltable.c create mode 100644 stepmania/src/lua-5.0/src/ltable.h create mode 100644 stepmania/src/lua-5.0/src/ltests.c create mode 100644 stepmania/src/lua-5.0/src/ltm.c create mode 100644 stepmania/src/lua-5.0/src/ltm.h create mode 100644 stepmania/src/lua-5.0/src/lundump.c create mode 100644 stepmania/src/lua-5.0/src/lundump.h create mode 100644 stepmania/src/lua-5.0/src/lvm.c create mode 100644 stepmania/src/lua-5.0/src/lvm.h create mode 100644 stepmania/src/lua-5.0/src/lzio.c create mode 100644 stepmania/src/lua-5.0/src/lzio.h diff --git a/stepmania/src/LuaHelpers.cpp b/stepmania/src/LuaHelpers.cpp index 1119dd37f0..ca6e4c16dc 100644 --- a/stepmania/src/LuaHelpers.cpp +++ b/stepmania/src/LuaHelpers.cpp @@ -10,8 +10,14 @@ LuaFunctionList *g_LuaFunctionList = NULL; #if defined(_WINDOWS) - #pragma comment(lib, "lua-5.0/lua.lib") - + #pragma comment(lib, "lua-5.0/LibLua.lib") + #pragma comment(lib, "lua-5.0/LibLuaLib.lib") +#endif +#if defined(_XBOX) + #pragma comment(lib, "lua-5.0/LibLuaXbox.lib") + #pragma comment(lib, "lua-5.0/LibLuaLibXbox.lib") +#endif +#if defined(_WINDOWS) || defined (_XBOX) /* "interaction between '_setjmp' and C++ object destruction is non-portable" * We don't care; we'll throw a fatal exception immediately anyway. */ #pragma warning (disable : 4611) diff --git a/stepmania/src/ProfileHtml.cpp b/stepmania/src/ProfileHtml.cpp index 59b1a2d12f..2a48bb5a1a 100644 --- a/stepmania/src/ProfileHtml.cpp +++ b/stepmania/src/ProfileHtml.cpp @@ -319,7 +319,7 @@ void PrintStatistics( RageFile &f, const Profile *pProfile, CString sTitle, vect PRINT_OPEN(f,"General Info",true); { BEGIN_TABLE(2); - TABLE_LINE2( "DisplayName", pProfile->m_sDisplayName.empty() ? "(empty)" : pProfile->m_sDisplayName ); + TABLE_LINE2( "DisplayName", pProfile->m_sDisplayName.empty() ? CString("(empty)") : pProfile->m_sDisplayName ); TABLE_LINE2( "ID", pProfile->m_sGuid ); TABLE_LINE2( "LastUsedHighScoreName", pProfile->m_sLastUsedHighScoreName ); TABLE_LINE2( "LastPlayedMachineID", pProfile->m_sLastPlayedMachineGuid ); diff --git a/stepmania/src/RageDisplay_D3D.cpp b/stepmania/src/RageDisplay_D3D.cpp index 08bd035d23..8f01588815 100644 --- a/stepmania/src/RageDisplay_D3D.cpp +++ b/stepmania/src/RageDisplay_D3D.cpp @@ -28,7 +28,7 @@ // load Windows D3D8 dynamically #if defined(_WINDOWS) #pragma comment(lib, "D3dx8.lib") - //#pragma comment(lib, "Dxerr8.lib") + #pragma comment(lib, "Dxerr8.lib") #endif #include diff --git a/stepmania/src/RageFileManager.cpp b/stepmania/src/RageFileManager.cpp index 800411f50d..4124e082eb 100644 --- a/stepmania/src/RageFileManager.cpp +++ b/stepmania/src/RageFileManager.cpp @@ -114,7 +114,7 @@ static void ChangeToDirOfExecutable( CString argv0 ) /* Set the CWD. Any effects of this is platform-specific; most files are read and * written through RageFile. See also RageFileManager::RageFileManager. */ -#if defined(_WIN32) +#if defined(_WINDOWS) chdir( DirOfExecutable + "/.." ); #elif defined(DARWIN) chdir(DirOfExecutable + "/../../.."); diff --git a/stepmania/src/RageSurface_Load_PNG.cpp b/stepmania/src/RageSurface_Load_PNG.cpp index 05c8c2f7a5..1a0de4a2c8 100644 --- a/stepmania/src/RageSurface_Load_PNG.cpp +++ b/stepmania/src/RageSurface_Load_PNG.cpp @@ -6,11 +6,13 @@ #include "RageSurface.h" #if defined(WIN32) -#include "libpng/include/png.h" -#pragma comment(lib, "libpng/lib/libpng.lib") -#pragma warning(disable: 4611) /* interaction between '_setjmp' and C++ object destruction is non-portable */ +# include "libpng/include/png.h" +# if defined(_WINDOWS) +# pragma comment(lib, "libpng/lib/libpng.lib") +# endif +# pragma warning(disable: 4611) /* interaction between '_setjmp' and C++ object destruction is non-portable */ #else -#include +# include #endif #if defined(_XBOX) @@ -131,10 +133,14 @@ static RageSurface *RageSurface_Load_PNG( RageFile *f, const char *fn, char erro type = PALETTE; break; + // TODO: Recompile libpng for Xbox and make sure that this is compiled into + // the library. +#ifndef _XBOX case PNG_COLOR_TYPE_GRAY_ALPHA: type = RGBA; png_set_gray_to_rgb( png ); break; +#endif case PNG_COLOR_TYPE_PALETTE: type = PALETTE; break; diff --git a/stepmania/src/StepMania.cpp b/stepmania/src/StepMania.cpp index 3c5095c0a9..f9a5c297cf 100644 --- a/stepmania/src/StepMania.cpp +++ b/stepmania/src/StepMania.cpp @@ -58,17 +58,17 @@ #include "NetworkSyncManager.h" #if defined(_XBOX) - #include "custom_launch_params.h" + #include "archutils/Xbox/custom_launch_params.h" #ifdef _DEBUG - #pragma comment(lib, "SDL-1.2.6/lib/xboxSDLmaind.lib") + #pragma comment(lib, "SDL-1.2.6/lib/xboxSDLmaind.lib") #else - #pragma comment(lib, "SDL-1.2.6/lib/xboxSDLmain.lib") + #pragma comment(lib, "SDL-1.2.6/lib/xboxSDLmain.lib") #endif #elif defined(_WINDOWS) #ifdef DEBUG - #pragma comment(lib, "SDL-1.2.6/lib/SDLmaind.lib") + #pragma comment(lib, "SDL-1.2.6/lib/SDLmaind.lib") #else - #pragma comment(lib, "SDL-1.2.6/lib/SDLmain.lib") + #pragma comment(lib, "SDL-1.2.6/lib/SDLmain.lib") #endif #endif diff --git a/stepmania/src/StepManiaXbox.vcproj b/stepmania/src/StepManiaXbox.vcproj index aa3c1025be..fa11e34fb1 100644 --- a/stepmania/src/StepManiaXbox.vcproj +++ b/stepmania/src/StepManiaXbox.vcproj @@ -112,7 +112,7 @@ cl /Zl /nologo /c verstub.cpp /Fo"$(IntDir)"\ AdditionalOptions="/MACHINE:I386 /FIXED:NO" AdditionalDependencies="xapilibd.lib d3d8d.lib d3dx8d.lib xgraphicsd.lib dsoundd.lib dmusicd.lib xnetd.lib xboxkrnl.lib debug\verstub.obj" OutputFile="../StepManiaXbox-debug.exe" - LinkIncremental="1" + LinkIncremental="0" SuppressStartupBanner="TRUE" IgnoreDefaultLibraryNames="libcd,libcmt" GenerateDebugInformation="TRUE" @@ -244,7 +244,7 @@ cl /Zl /nologo /c verstub.cpp /Fo"$(IntDir)"\ Name="VCLinkerTool" AdditionalOptions="/MACHINE:I386 /FIXED:NO" AdditionalDependencies="$(intdir)\verstub.obj xapilib.lib d3d8.lib d3dx8.lib xgraphics.lib dsound.lib dmusic.lib xnet.lib xboxkrnl.lib libcmt.lib" - OutputFile="../Program/StepManiaXbox.exe" + OutputFile="../StepMania.exe" LinkIncremental="1" SuppressStartupBanner="TRUE" IgnoreDefaultLibraryNames="libc,libcmtd" @@ -267,10 +267,10 @@ cl StackSize="0x10000" IncludeDebugInfo="TRUE" SuppressStartupBanner="TRUE" - TitleID="123456" - TitleInfo="StepMania" - TitleName="StepMania" - TitleImage="StepMania"/> + TitleID="" + TitleInfo="" + TitleName="" + TitleImage=""/> @@ -1115,6 +1115,12 @@ cl + + + + @@ -1132,7 +1138,10 @@ cl RelativePath="arch\ArchHooks\ArchHooks.h"> + RelativePath="arch\ArchHooks\ArchHooks_Xbox.cpp"> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +#if defined(_WINDOWS) +# include +#else if +# include +#endif class ThreadImpl_Win32: public ThreadImpl { diff --git a/stepmania/src/arch/arch_xbox.h b/stepmania/src/arch/arch_xbox.h index 0c72e40a01..3caeccca89 100644 --- a/stepmania/src/arch/arch_xbox.h +++ b/stepmania/src/arch/arch_xbox.h @@ -2,17 +2,19 @@ #define XBOX_ARCH_H /* Load drivers for Xbox. */ -//#include "ErrorDialog/ErrorDialog_null.h" -#include "ArchHooks/ArchHooks_none.h" + +#include "LoadingWindow/LoadingWindow_Null.h" + +#include "ArchHooks/ArchHooks_Xbox.h" /* Err, is SDL input working on Xbox? arch_default comments indicated no. * (Best to use a custom driver for threaded input, anyway.) */ +/* I believe it is working, and it's the only thing we depend on SDL for. + * I'll write an InputHandler so we can ditch the SDLXbox mess. -Chris */ #include "InputHandler/InputHandler_SDL.h" #include "Sound/RageSoundDriver_DSound.h" -#include "LoadingWindow/LoadingWindow_SDL.h" - /* Undef this if you need no SDL input. */ // #undef SUPPORT_SDL_INPUT diff --git a/stepmania/src/archutils/Win32/AppInstance.h b/stepmania/src/archutils/Win32/AppInstance.h index 39ae99609b..d6e2c9eb41 100644 --- a/stepmania/src/archutils/Win32/AppInstance.h +++ b/stepmania/src/archutils/Win32/AppInstance.h @@ -1,7 +1,9 @@ #ifndef APP_INSTANCE_H #define APP_INSTANCE_H -#include "windows.h" +#if !defined(_XBOX) +# include "windows.h" +#endif /* Win32 only: get an HINSTANCE; used for starting dialog boxes. */ class AppInstance diff --git a/stepmania/src/archutils/Win32/arch_setup.cpp b/stepmania/src/archutils/Win32/arch_setup.cpp index 0e42c99f74..88a3f52d7d 100644 --- a/stepmania/src/archutils/Win32/arch_setup.cpp +++ b/stepmania/src/archutils/Win32/arch_setup.cpp @@ -2,7 +2,9 @@ #include "arch_setup.h" #include "RageThreads.h" #include -#include +#ifdef _WINDOWS +# include +#endif struct tm *my_localtime_r( const time_t *timep, struct tm *result ) { diff --git a/stepmania/src/archutils/Win32/arch_setup.h b/stepmania/src/archutils/Win32/arch_setup.h index eca5be3d53..ae3c962564 100644 --- a/stepmania/src/archutils/Win32/arch_setup.h +++ b/stepmania/src/archutils/Win32/arch_setup.h @@ -84,7 +84,11 @@ inline int lrintf( float f ) /* We implement the crash handler interface (though that interface isn't completely * uniform across platforms yet). */ -#define CRASH_HANDLER +#if defined(_XBOX) + // no crash handler on Xbox +#else +# define CRASH_HANDLER +#endif #define ENDIAN_LITTLE diff --git a/stepmania/src/custom_launch_params.cpp b/stepmania/src/archutils/Xbox/custom_launch_params.cpp similarity index 100% rename from stepmania/src/custom_launch_params.cpp rename to stepmania/src/archutils/Xbox/custom_launch_params.cpp diff --git a/stepmania/src/custom_launch_params.h b/stepmania/src/archutils/Xbox/custom_launch_params.h similarity index 100% rename from stepmania/src/custom_launch_params.h rename to stepmania/src/archutils/Xbox/custom_launch_params.h diff --git a/stepmania/src/crypto/CryptNoise.cpp b/stepmania/src/crypto/CryptNoise.cpp index 662579e34b..26575ec4bb 100644 --- a/stepmania/src/crypto/CryptNoise.cpp +++ b/stepmania/src/crypto/CryptNoise.cpp @@ -5,7 +5,16 @@ #include "global.h" -#if defined(WIN32) +#if defined(_XBOX) +void noise_get_heavy(void (*func) (void *, int)) +{ +} + +void noise_get_light(void (*func) (void *, int)) +{ +} + +#elif defined(_WINDOWS) #define _WIN32_WINNT 0x0400 // VC6 header needs this defined. #include #include diff --git a/stepmania/src/crypto51/config.h b/stepmania/src/crypto51/config.h index ce41ffe822..59c2ef305b 100644 --- a/stepmania/src/crypto51/config.h +++ b/stepmania/src/crypto51/config.h @@ -24,7 +24,9 @@ // define this if you want to disable all OS-dependent features, // such as sockets and OS-provided random number generators -// #define NO_OS_DEPENDENCE +#ifdef _XBOX +# define NO_OS_DEPENDENCE +#endif // Define this to use features provided by Microsoft's CryptoAPI. // Currently the only feature used is random number generation. diff --git a/stepmania/src/global.cpp b/stepmania/src/global.cpp index 4986445833..cf50301785 100644 --- a/stepmania/src/global.cpp +++ b/stepmania/src/global.cpp @@ -1,11 +1,12 @@ #include "global.h" #if defined(_WINDOWS) -#define _WIN32_WINDOWS 0x0410 // include Win98 stuff -#include "windows.h" -#include "archutils/Win32/Crash.h" +# define _WIN32_WINDOWS 0x0410 // include Win98 stuff +# include "windows.h" +# include "archutils/Win32/Crash.h" +#elif defined(_XBOX) #else -#include +# include #endif #if defined(CRASH_HANDLER) && (defined(LINUX) || defined(DARWIN)) diff --git a/stepmania/src/libresample/src/config.h b/stepmania/src/libresample/src/config.h index af7cff6691..f3b8a58514 100644 --- a/stepmania/src/libresample/src/config.h +++ b/stepmania/src/libresample/src/config.h @@ -3,6 +3,6 @@ system supported by GNU autoconf. For all other systems, use this file as a template to create config.h */ - +#ifndef _XBOX #define HAVE_INTTYPES_H 1 - +#endif diff --git a/stepmania/src/lua-5.0/COPYRIGHT b/stepmania/src/lua-5.0/COPYRIGHT new file mode 100644 index 0000000000..16321abf6b --- /dev/null +++ b/stepmania/src/lua-5.0/COPYRIGHT @@ -0,0 +1,34 @@ +Lua License +----------- + +Lua is licensed under the terms of the MIT license reproduced below. +This means that Lua is free software and can be used for both academic +and commercial purposes at absolutely no cost. + +For details and rationale, see http://www.lua.org/license.html . + +=============================================================================== + +Copyright (C) 2003-2004 Tecgraf, PUC-Rio. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +=============================================================================== + +(end of COPYRIGHT) diff --git a/stepmania/src/lua-5.0/Lua.dsw b/stepmania/src/lua-5.0/Lua.dsw new file mode 100644 index 0000000000..7370515299 --- /dev/null +++ b/stepmania/src/lua-5.0/Lua.dsw @@ -0,0 +1,41 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00 +# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! + +############################################################################### + +Project: "LibLua"=".\src\LibLua.dsp" - Package Owner=<4> + +Package=<5> +{{{ +}}} + +Package=<4> +{{{ +}}} + +############################################################################### + +Project: "LibLuaLib"=".\src\lib\LibLuaLib.dsp" - Package Owner=<4> + +Package=<5> +{{{ +}}} + +Package=<4> +{{{ +}}} + +############################################################################### + +Global: + +Package=<5> +{{{ +}}} + +Package=<3> +{{{ +}}} + +############################################################################### + diff --git a/stepmania/src/lua-5.0/LuaXbox.sln b/stepmania/src/lua-5.0/LuaXbox.sln new file mode 100644 index 0000000000..b56fee2f94 --- /dev/null +++ b/stepmania/src/lua-5.0/LuaXbox.sln @@ -0,0 +1,27 @@ +Microsoft Visual Studio Solution File, Format Version 7.00 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LibLua", "src\LibLua.vcproj", "{A893088C-3E2D-43A7-B106-BBBC9DF6D0EF}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "LibLuaLib", "src\lib\LibLuaLib.vcproj", "{DD432F26-496E-451C-93E2-2CE19A748AF8}" +EndProject +Global + GlobalSection(SolutionConfiguration) = preSolution + ConfigName.0 = Debug + ConfigName.1 = Release + EndGlobalSection + GlobalSection(ProjectDependencies) = postSolution + EndGlobalSection + GlobalSection(ProjectConfiguration) = postSolution + {A893088C-3E2D-43A7-B106-BBBC9DF6D0EF}.Debug.ActiveCfg = Release|Xbox + {A893088C-3E2D-43A7-B106-BBBC9DF6D0EF}.Debug.Build.0 = Release|Xbox + {A893088C-3E2D-43A7-B106-BBBC9DF6D0EF}.Release.ActiveCfg = Release|Xbox + {A893088C-3E2D-43A7-B106-BBBC9DF6D0EF}.Release.Build.0 = Release|Xbox + {DD432F26-496E-451C-93E2-2CE19A748AF8}.Debug.ActiveCfg = Release|Xbox + {DD432F26-496E-451C-93E2-2CE19A748AF8}.Debug.Build.0 = Release|Xbox + {DD432F26-496E-451C-93E2-2CE19A748AF8}.Release.ActiveCfg = Release|Xbox + {DD432F26-496E-451C-93E2-2CE19A748AF8}.Release.Build.0 = Release|Xbox + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + EndGlobalSection + GlobalSection(ExtensibilityAddIns) = postSolution + EndGlobalSection +EndGlobal diff --git a/stepmania/src/lua-5.0/lauxlib.h b/stepmania/src/lua-5.0/include/lauxlib.h similarity index 100% rename from stepmania/src/lua-5.0/lauxlib.h rename to stepmania/src/lua-5.0/include/lauxlib.h diff --git a/stepmania/src/lua-5.0/lua.h b/stepmania/src/lua-5.0/include/lua.h similarity index 98% rename from stepmania/src/lua-5.0/lua.h rename to stepmania/src/lua-5.0/include/lua.h index 9fa9c52727..449efeb2f0 100644 --- a/stepmania/src/lua-5.0/lua.h +++ b/stepmania/src/lua-5.0/include/lua.h @@ -14,8 +14,8 @@ #include -#define LUA_VERSION "Lua 5.0" -#define LUA_COPYRIGHT "Copyright (C) 1994-2003 Tecgraf, PUC-Rio" +#define LUA_VERSION "Lua 5.0.2" +#define LUA_COPYRIGHT "Copyright (C) 1994-2004 Tecgraf, PUC-Rio" #define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo & W. Celes" @@ -365,7 +365,7 @@ struct lua_Debug { /****************************************************************************** -* Copyright (C) 1994-2003 Tecgraf, PUC-Rio. All rights reserved. +* Copyright (C) 1994-2004 Tecgraf, PUC-Rio. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the diff --git a/stepmania/src/lua-5.0/lualib.h b/stepmania/src/lua-5.0/include/lualib.h similarity index 100% rename from stepmania/src/lua-5.0/lualib.h rename to stepmania/src/lua-5.0/include/lualib.h diff --git a/stepmania/src/lua-5.0/lib/LibLua.lib b/stepmania/src/lua-5.0/lib/LibLua.lib new file mode 100644 index 0000000000000000000000000000000000000000..4ae3ced2bcdc4ddcb31ddeccaa7d5a52333af8a4 GIT binary patch literal 325392 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�AC=J;kmThLgG%8)9QCSZ8 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�U$ksiAH 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 literal 0 HcmV?d00001 diff --git a/stepmania/src/lua-5.0/lib/LibLuaXbox.lib b/stepmania/src/lua-5.0/lib/LibLuaXbox.lib new file mode 100644 index 0000000000000000000000000000000000000000..2c4b861dbf8bbd2bb3c0fbbee5c641513247f7fc GIT binary patch literal 219814 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

r`Kc;4NqTFmp&7n6uYg6{l$VgIjGh(MfI)> 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 ij8M{7HcO%s@DpUo{+PZ{wk<4$jY>< zXJ&OrI{xcC{`%^1>UHXGzc^BwEl=%Rv%M$&+tE8bG`y>?zkeW>_d0g4w|}Qi-dICK z|3mch--)(`Y939!9Q3U`;v(1?1-g9?-Mbd{m@cjhKT9X zSC%gCBVsyq-_qghM23*xVbGB+mQEieV%qyNOGiF{95nt{M-Sr(y7-Bu3m+3PjRTA6 zQq$2oJV6&nEuH*=i0RajrIVB3L8pFYsermLop{gDCOkpMe`o2$H{d}BQEsNwz-KzM z*3!`{Xdlo4yw9|+U} z|357qKp70-odclrA6Xi`3p>!cRhF*Q;WwaT_bu)IBm4=p?U$DN&@N0nCoS#jL%l(L zzp*s9g@~#DT}wOuMr3F`o=iWrwEZ3tQ}1p|ga5*Npx$3w8k!(t>fdN-JKC9P@aL9x zE(boS|GuT6KfxaK+6_ma;RzZZva}6lWZI5*n1(;JwDWW10~$aZ7($y3fJWd8OndHI z8u>kV(3N|ZuI?lQ1RP?<^D>Y?|-PIJHg1ntEwkX)PBls&nPZ z`FgooZPZ;6wLsg|=cjL0X2nQ2Z86uJt=4aeg>c$p9!)V(YQkH%=c{vp4_33Kw<~YW zmul7~aKS>UT{7rumASd*RLNB)aKWP4kg{_b0;er*HX5~xWYTPSR@+GZY%anD3rK1e zR}M)BZL^VS_eh}aLK|76z-ue*;LV0`+G3_rtv96u;p@T%8+NXG)iu0lGJ53&#>DZl zRZW_Mi_B(T5Zh(VgpaN6Op08x3zFEf#n204yK=eKn46zfgDOa3OW*YZ?FF%2t$J&! z8M;QSGve?L&oQN&HCKYb1q*mS#C{Z*bXHr{YA`|1lU&F@aKQo@PFI>3jJgy`5?M}G z>US&_Ub9Tl^NbjB30$y1T_E;_HR-H2)CKCOF5p$UxM^ca$O-aLQqKf^xm0uRZBs!r z6I3o4bY-QKbkNosvar}x&`iuvyA{Qzf(DIvtIUIRZmLmp%TiXBu`V~}>#hZjrQ?GY zs@sxhRu-)9RA%S=obQ>SuguOi++^>PL07N*#FfORf~MT4mrG73>7a!d#v>#W1UsHE z=4Z^RH)nk&mIO<*gfsNc>G@!VR`62iJ)V!OrWy^m3BfCt33^}!y=PkV)1^6=hqJMQ z7Q47VIp>xhMFwhL6u2m_S_7WzYwx&Vfr==Lzy%BBTdhwvd={1odN}F4>>wl^wC_|a z;=nE$bd4EV|7j&J?vkA#YZsiv**QVh&hHbQ zS!TEBq^0^h#uqf3&B-t47*5X4i7TQVW!wsjb?TxhzGZERlgoB}3trm21{X z@0*2UEK;^S?{l|Eojt2;*nMl&o6f{@$^rw+ZuJVhHX*5WfEJxiD%}jW{5R((C*8iR zP}BltSDKiJTT%;RyU1-}CcLuZ>6C|Z%}&)oRRU#)x5L>3BhjAU^SnT|}QACHlibqA$k~ zqc}_S{vo0d@ti@N<}1W9_FX2r583s@umf#5f*9CoqMz+0`T*&_B4+h4=#z^?A78+G zNH_7`I?yO&Uz|j2^M_@SXVF6zo7dyo)beT7i?}r{&UEdK{{;Ds*N8p?4Gkkt zCT%k(0>Ks~gHM(I2B1KL2Z&{o<`y|jkb(kber-E@df&<@&0kI+HdNKezV^b~!c zo}uUIIa){Gr9Jcz6=;UuqFHLv9L>|6|0lIvff*=g%r8t?X4UXZm!DaTxMjZSu*8H7 zp?aUEXuIwxVOY$ykOPcnSCbXCD_67^$-a=>SY?e{cWbRX)ehUrj=L47aC5RkY}r|~ zT?RX>p&hrZJmZ^{L?Lz9!>OH_GVZXQ>9F6(?habEQek7SFk1Hw+5LR6O;DI!MJ=sS z7}{rE%$`n)t*6@7h(P=OgWZ3GtS1^R{$I?-30lINSr6iUZ8jVO(XDd3!(&PHtozqmSNfbCPe3vPV(w@OpKw>;- zT{1-L%xTULCVCu7%a*Mz%+l62W~u8-1byN>+#w_*Y*X%bw*?YM4R2dX6k?PBWn_fu zCpL2TJjzIJZ?wpUOM(R1WQQn39R?#b*}(`=%TR)>?NEZe#ot&K4;x6@3>)-`xv&T& z?{M>>ZZ5QKYfrbmWoWjU_uAiBv>Onan1u=TWbd@vgfm<2470&1bGEU^H(w_s>v%$o z%{m;h+8xhYeBa=>ZZlC0eYh8ayd`{eFpnc`5bTt%p%UIuzU;W7H-GJxrBQWc0LoMDXP9>kMc`1 zXTXB6D2v1|Ya+-j#9plXo3o0qZZr3^S>v$ON`7HNF$D`(tZWb#R>z@RYz6&d>J%6p zUV*gS>P4SOM4vo_+Xa|Mw|CJJ$=SmoI3XD2RN&Nt=!}(%LGRrN>Bx=HHvXnwEqRME1Bk|_atG1b5c?nTI`-hMq)lh%^H%jXdZmaS=&r68p z*}n~V{3q-_b+%l`QR==3cDf835=DLa;qQqNs986sAXFiWdlr){Cf*RKX|+Y50; zq`&QX>~ys}+n8%iHhZ>=z0y-SaRwpLHh*g&<2N}6+aIe4uVF@jp-Q_^4p%3 z^zFBTCB4U`T24~eQG^y*G9?mIE5=wMk^#1XAlM8B3Co}3f7~DEg|F!x$B*TR5fTm( zIU`q#;`x08!^-oQ8_)kQQzkAMEomzZk>^Vt*^80sUysn9n z%m!6}7PCf=#yB==AVB$RBtIs}cm%JNYdw+;M+nGb*5*4NLxnj6D1U7d{=Lp4xf8UF zpDYR1ce7abT+lUE|E~69>2dVZdW}`5t}#-h=zAVRg_62QN~{u(MMx$_)jdwa8y@#K z2vUTjZ}(VoSj&u~C(%P2JQkl3IjSZw?zt#4-4hDMe>WyT`A1S>rh8H&x%0dLEoP0L z@;EBIC_wpZl-Sih9gsrYvTG#yRbEfV7aoHzJmZl#ASw`fTP-yoZ1e~S)GTB^NQ}~F zJ%*3qN>%drOJW6j&g0n7uz=)kuYm-{^B%*7oV&)516ZclpFppF-(mPrwt(brt(0%Q zASfnAE)cofDlzhVJVJ=QcZ-wq;TJuQiRlYO?$%26`zDWJFAD@DcY7s#>jxgg2C}=x zNUSa|35LJi=o%$alOG0@Xi?7HT8Wx$4j2nO@1{n{%N~V)U(#(`rM#EFs^b`eyF3zz z+}@kQc*SFwTdA%w1`@N@R>8oA+1xC2kCK>Eexy+39!-GU^TGE=?km~s%FD6NS0kKo zKi4%@qUBywSmw$_Kyv%QK;jg=ErVh&6a^}G+a>l#+cQY!qEdkJ*D29*y$Z?PfOe0P zm}zz>6nhIMFu7YT(La3(rS*uB8!1treuWf=I2IFSK%vA3+T19Km1a<*;KLi2w>%$w zE=bHdLkdIgGP}k})MZ$3+*Nzm7>TjD(_^SBd;!WoHWOa9DSO)9m#q{Ov`z2m^_F>=Ok4O-I)#iF4(CjbgtQ z5t#g*oES5s3a6#}b0ejC=0HHgr>IgH_k3UvOCcN-1P(5BkC2Ek9ukE35RgPhPv{E1fg^+~J-CnFU5?Uw+#=L3(`)T(nz<7ApGH%`LG3mV6NtJZam z5;OK`jkM6)<3x?lL^#>Ol)LQ`E8ST^@*nMW-EN7U;W>rE9|Lxc(P38LsN?wA;wsunv8oC`?=*(^vT75VL#&(kVWm2O991vA1WY=*(a9; z1D(FW=ujeRb48)(4_cR^MpqTq0;4vG`Q>$mvUIVBYYJs)V-MFA($Yl*eymZJC@S!V z!dS|vK+)saFQ>cq<;1#tLomV@*#eV)rb(QnN&zSQuBm&Z#JIT`kQN$!NVHoypvZsm zwj{Ng2sjJf2PWFA5>VW4CZ#g&xhT8Z$$-*wn9hrnI_ci>IQ&00c3qQ1drfHs^SijN zQ4+hEs-Vb^6$B*r$V}Z3-4+!4D~Kh*cvCR!&nvpdNJXA%4#WJu!u)PSVBGV;eK;}h zr!|WGJ&3^M?v>Q7b6w-$hb97&yDo`2xuG%S2P^`Vzcz{SGNX~qFJlBIcYPA4^S3n0 RLTAf_56o(ucq_B!e*py7ZD#-g diff --git a/stepmania/src/lua-5.0/src/LibLua.dsp b/stepmania/src/lua-5.0/src/LibLua.dsp new file mode 100644 index 0000000000..3edc62c65a --- /dev/null +++ b/stepmania/src/lua-5.0/src/LibLua.dsp @@ -0,0 +1,250 @@ +# Microsoft Developer Studio Project File - Name="LibLua" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 60000 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Static Library" 0x0104 + +CFG=LibLua - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "LibLua.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "LibLua.mak" CFG="LibLua - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "LibLua - Win32 Release" (based on "Win32 (x86) Static Library") +!MESSAGE "LibLua - Win32 Debug" (based on "Win32 (x86) Static Library") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +RSC=rc.exe + +!IF "$(CFG)" == "LibLua - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "..\obj" +# PROP Intermediate_Dir "..\obj" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c +# ADD CPP /nologo /MD /W4 /GX /O2 /I "..\include" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /FD /c +# SUBTRACT CPP /YX +# ADD BASE RSC /l 0x40c /d "NDEBUG" +# ADD RSC /l 0x409 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LIB32=link.exe -lib +# ADD BASE LIB32 /nologo +# ADD LIB32 /nologo /out:"..\lib\LibLua.lib" + +!ELSEIF "$(CFG)" == "LibLua - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "..\dobj" +# PROP Intermediate_Dir "..\dobj" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c +# ADD CPP /nologo /MDd /W4 /Gm /GX /Zi /Od /I "..\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /FD /GZ /c +# SUBTRACT CPP /YX +# ADD BASE RSC /l 0x40c /d "_DEBUG" +# ADD RSC /l 0x409 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LIB32=link.exe -lib +# ADD BASE LIB32 /nologo +# ADD LIB32 /nologo /out:"..\lib\LibLua.lib" + +!ENDIF + +# Begin Target + +# Name "LibLua - Win32 Release" +# Name "LibLua - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "c" +# Begin Source File + +SOURCE=.\lapi.c +# End Source File +# Begin Source File + +SOURCE=.\lcode.c +# End Source File +# Begin Source File + +SOURCE=.\ldebug.c +# End Source File +# Begin Source File + +SOURCE=.\ldo.c +# End Source File +# Begin Source File + +SOURCE=.\ldump.c +# End Source File +# Begin Source File + +SOURCE=.\lfunc.c +# End Source File +# Begin Source File + +SOURCE=.\lgc.c +# End Source File +# Begin Source File + +SOURCE=.\llex.c +# End Source File +# Begin Source File + +SOURCE=.\lmem.c +# End Source File +# Begin Source File + +SOURCE=.\lobject.c +# End Source File +# Begin Source File + +SOURCE=.\lopcodes.c +# End Source File +# Begin Source File + +SOURCE=.\lparser.c +# End Source File +# Begin Source File + +SOURCE=.\lstate.c +# End Source File +# Begin Source File + +SOURCE=.\lstring.c +# End Source File +# Begin Source File + +SOURCE=.\ltable.c +# End Source File +# Begin Source File + +SOURCE=.\ltests.c +# End Source File +# Begin Source File + +SOURCE=.\ltm.c +# End Source File +# Begin Source File + +SOURCE=.\lundump.c +# End Source File +# Begin Source File + +SOURCE=.\lvm.c +# End Source File +# Begin Source File + +SOURCE=.\lzio.c +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h" +# Begin Source File + +SOURCE=.\lapi.h +# End Source File +# Begin Source File + +SOURCE=.\lcode.h +# End Source File +# Begin Source File + +SOURCE=.\ldebug.h +# End Source File +# Begin Source File + +SOURCE=.\ldo.h +# End Source File +# Begin Source File + +SOURCE=.\lfunc.h +# End Source File +# Begin Source File + +SOURCE=.\lgc.h +# End Source File +# Begin Source File + +SOURCE=.\llex.h +# End Source File +# Begin Source File + +SOURCE=.\llimits.h +# End Source File +# Begin Source File + +SOURCE=.\lmem.h +# End Source File +# Begin Source File + +SOURCE=.\lobject.h +# End Source File +# Begin Source File + +SOURCE=.\lopcodes.h +# End Source File +# Begin Source File + +SOURCE=.\lparser.h +# End Source File +# Begin Source File + +SOURCE=.\lstate.h +# End Source File +# Begin Source File + +SOURCE=.\lstring.h +# End Source File +# Begin Source File + +SOURCE=.\ltable.h +# End Source File +# Begin Source File + +SOURCE=.\ltm.h +# End Source File +# Begin Source File + +SOURCE=.\lundump.h +# End Source File +# Begin Source File + +SOURCE=.\lvm.h +# End Source File +# Begin Source File + +SOURCE=.\lzio.h +# End Source File +# End Group +# End Target +# End Project diff --git a/stepmania/src/lua-5.0/src/LibLua.vcproj b/stepmania/src/lua-5.0/src/LibLua.vcproj new file mode 100644 index 0000000000..745be170af --- /dev/null +++ b/stepmania/src/lua-5.0/src/LibLua.vcproj @@ -0,0 +1,225 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/stepmania/src/lua-5.0/src/lapi.c b/stepmania/src/lua-5.0/src/lapi.c new file mode 100644 index 0000000000..71d3ba6305 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lapi.c @@ -0,0 +1,922 @@ +/* +** $Id$ +** Lua API +** See Copyright Notice in lua.h +*/ + + +#include +#include + +#define lapi_c + +#include "lua.h" + +#include "lapi.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" +#include "lundump.h" +#include "lvm.h" + + +const char lua_ident[] = + "$Lua: " LUA_VERSION " " LUA_COPYRIGHT " $\n" + "$Authors: " LUA_AUTHORS " $\n" + "$URL: www.lua.org $\n"; + + + +#ifndef api_check +#define api_check(L, o) /*{ assert(o); }*/ +#endif + +#define api_checknelems(L, n) api_check(L, (n) <= (L->top - L->base)) + +#define api_incr_top(L) {api_check(L, L->top < L->ci->top); L->top++;} + + + + +static TObject *negindex (lua_State *L, int idx) { + if (idx > LUA_REGISTRYINDEX) { + api_check(L, idx != 0 && -idx <= L->top - L->base); + return L->top+idx; + } + else switch (idx) { /* pseudo-indices */ + case LUA_REGISTRYINDEX: return registry(L); + case LUA_GLOBALSINDEX: return gt(L); + default: { + TObject *func = (L->base - 1); + idx = LUA_GLOBALSINDEX - idx; + lua_assert(iscfunction(func)); + return (idx <= clvalue(func)->c.nupvalues) + ? &clvalue(func)->c.upvalue[idx-1] + : NULL; + } + } +} + + +static TObject *luaA_index (lua_State *L, int idx) { + if (idx > 0) { + api_check(L, idx <= L->top - L->base); + return L->base + idx - 1; + } + else { + TObject *o = negindex(L, idx); + api_check(L, o != NULL); + return o; + } +} + + +static TObject *luaA_indexAcceptable (lua_State *L, int idx) { + if (idx > 0) { + TObject *o = L->base+(idx-1); + api_check(L, idx <= L->stack_last - L->base); + if (o >= L->top) return NULL; + else return o; + } + else + return negindex(L, idx); +} + + +void luaA_pushobject (lua_State *L, const TObject *o) { + setobj2s(L->top, o); + incr_top(L); +} + + +LUA_API int lua_checkstack (lua_State *L, int size) { + int res; + lua_lock(L); + if ((L->top - L->base + size) > LUA_MAXCSTACK) + res = 0; /* stack overflow */ + else { + luaD_checkstack(L, size); + if (L->ci->top < L->top + size) + L->ci->top = L->top + size; + res = 1; + } + lua_unlock(L); + return res; +} + + +LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) { + int i; + lua_lock(to); + api_checknelems(from, n); + from->top -= n; + for (i = 0; i < n; i++) { + setobj2s(to->top, from->top + i); + api_incr_top(to); + } + lua_unlock(to); +} + + +LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) { + lua_CFunction old; + lua_lock(L); + old = G(L)->panic; + G(L)->panic = panicf; + lua_unlock(L); + return old; +} + + +LUA_API lua_State *lua_newthread (lua_State *L) { + lua_State *L1; + lua_lock(L); + luaC_checkGC(L); + L1 = luaE_newthread(L); + setthvalue(L->top, L1); + api_incr_top(L); + lua_unlock(L); + lua_userstateopen(L1); + return L1; +} + + + +/* +** basic stack manipulation +*/ + + +LUA_API int lua_gettop (lua_State *L) { + return (L->top - L->base); +} + + +LUA_API void lua_settop (lua_State *L, int idx) { + lua_lock(L); + if (idx >= 0) { + api_check(L, idx <= L->stack_last - L->base); + while (L->top < L->base + idx) + setnilvalue(L->top++); + L->top = L->base + idx; + } + else { + api_check(L, -(idx+1) <= (L->top - L->base)); + L->top += idx+1; /* `subtract' index (index is negative) */ + } + lua_unlock(L); +} + + +LUA_API void lua_remove (lua_State *L, int idx) { + StkId p; + lua_lock(L); + p = luaA_index(L, idx); + while (++p < L->top) setobjs2s(p-1, p); + L->top--; + lua_unlock(L); +} + + +LUA_API void lua_insert (lua_State *L, int idx) { + StkId p; + StkId q; + lua_lock(L); + p = luaA_index(L, idx); + for (q = L->top; q>p; q--) setobjs2s(q, q-1); + setobjs2s(p, L->top); + lua_unlock(L); +} + + +LUA_API void lua_replace (lua_State *L, int idx) { + lua_lock(L); + api_checknelems(L, 1); + setobj(luaA_index(L, idx), L->top - 1); /* write barrier */ + L->top--; + lua_unlock(L); +} + + +LUA_API void lua_pushvalue (lua_State *L, int idx) { + lua_lock(L); + setobj2s(L->top, luaA_index(L, idx)); + api_incr_top(L); + lua_unlock(L); +} + + + +/* +** access functions (stack -> C) +*/ + + +LUA_API int lua_type (lua_State *L, int idx) { + StkId o = luaA_indexAcceptable(L, idx); + return (o == NULL) ? LUA_TNONE : ttype(o); +} + + +LUA_API const char *lua_typename (lua_State *L, int t) { + UNUSED(L); + return (t == LUA_TNONE) ? "no value" : luaT_typenames[t]; +} + + +LUA_API int lua_iscfunction (lua_State *L, int idx) { + StkId o = luaA_indexAcceptable(L, idx); + return (o == NULL) ? 0 : iscfunction(o); +} + + +LUA_API int lua_isnumber (lua_State *L, int idx) { + TObject n; + const TObject *o = luaA_indexAcceptable(L, idx); + return (o != NULL && tonumber(o, &n)); +} + + +LUA_API int lua_isstring (lua_State *L, int idx) { + int t = lua_type(L, idx); + return (t == LUA_TSTRING || t == LUA_TNUMBER); +} + + +LUA_API int lua_isuserdata (lua_State *L, int idx) { + const TObject *o = luaA_indexAcceptable(L, idx); + return (o != NULL && (ttisuserdata(o) || ttislightuserdata(o))); +} + + +LUA_API int lua_rawequal (lua_State *L, int index1, int index2) { + StkId o1 = luaA_indexAcceptable(L, index1); + StkId o2 = luaA_indexAcceptable(L, index2); + return (o1 == NULL || o2 == NULL) ? 0 /* index out of range */ + : luaO_rawequalObj(o1, o2); +} + + +LUA_API int lua_equal (lua_State *L, int index1, int index2) { + StkId o1, o2; + int i; + lua_lock(L); /* may call tag method */ + o1 = luaA_indexAcceptable(L, index1); + o2 = luaA_indexAcceptable(L, index2); + i = (o1 == NULL || o2 == NULL) ? 0 /* index out of range */ + : equalobj(L, o1, o2); + lua_unlock(L); + return i; +} + + +LUA_API int lua_lessthan (lua_State *L, int index1, int index2) { + StkId o1, o2; + int i; + lua_lock(L); /* may call tag method */ + o1 = luaA_indexAcceptable(L, index1); + o2 = luaA_indexAcceptable(L, index2); + i = (o1 == NULL || o2 == NULL) ? 0 /* index out-of-range */ + : luaV_lessthan(L, o1, o2); + lua_unlock(L); + return i; +} + + + +LUA_API lua_Number lua_tonumber (lua_State *L, int idx) { + TObject n; + const TObject *o = luaA_indexAcceptable(L, idx); + if (o != NULL && tonumber(o, &n)) + return nvalue(o); + else + return 0; +} + + +LUA_API int lua_toboolean (lua_State *L, int idx) { + const TObject *o = luaA_indexAcceptable(L, idx); + return (o != NULL) && !l_isfalse(o); +} + + +LUA_API const char *lua_tostring (lua_State *L, int idx) { + StkId o = luaA_indexAcceptable(L, idx); + if (o == NULL) + return NULL; + else if (ttisstring(o)) + return svalue(o); + else { + const char *s; + lua_lock(L); /* `luaV_tostring' may create a new string */ + s = (luaV_tostring(L, o) ? svalue(o) : NULL); + luaC_checkGC(L); + lua_unlock(L); + return s; + } +} + + +LUA_API size_t lua_strlen (lua_State *L, int idx) { + StkId o = luaA_indexAcceptable(L, idx); + if (o == NULL) + return 0; + else if (ttisstring(o)) + return tsvalue(o)->tsv.len; + else { + size_t l; + lua_lock(L); /* `luaV_tostring' may create a new string */ + l = (luaV_tostring(L, o) ? tsvalue(o)->tsv.len : 0); + lua_unlock(L); + return l; + } +} + + +LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) { + StkId o = luaA_indexAcceptable(L, idx); + return (o == NULL || !iscfunction(o)) ? NULL : clvalue(o)->c.f; +} + + +LUA_API void *lua_touserdata (lua_State *L, int idx) { + StkId o = luaA_indexAcceptable(L, idx); + if (o == NULL) return NULL; + switch (ttype(o)) { + case LUA_TUSERDATA: return (uvalue(o) + 1); + case LUA_TLIGHTUSERDATA: return pvalue(o); + default: return NULL; + } +} + + +LUA_API lua_State *lua_tothread (lua_State *L, int idx) { + StkId o = luaA_indexAcceptable(L, idx); + return (o == NULL || !ttisthread(o)) ? NULL : thvalue(o); +} + + +LUA_API const void *lua_topointer (lua_State *L, int idx) { + StkId o = luaA_indexAcceptable(L, idx); + if (o == NULL) return NULL; + else { + switch (ttype(o)) { + case LUA_TTABLE: return hvalue(o); + case LUA_TFUNCTION: return clvalue(o); + case LUA_TTHREAD: return thvalue(o); + case LUA_TUSERDATA: + case LUA_TLIGHTUSERDATA: + return lua_touserdata(L, idx); + default: return NULL; + } + } +} + + + +/* +** push functions (C -> stack) +*/ + + +LUA_API void lua_pushnil (lua_State *L) { + lua_lock(L); + setnilvalue(L->top); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API void lua_pushnumber (lua_State *L, lua_Number n) { + lua_lock(L); + setnvalue(L->top, n); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) { + lua_lock(L); + luaC_checkGC(L); + setsvalue2s(L->top, luaS_newlstr(L, s, len)); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API void lua_pushstring (lua_State *L, const char *s) { + if (s == NULL) + lua_pushnil(L); + else + lua_pushlstring(L, s, strlen(s)); +} + + +LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt, + va_list argp) { + const char *ret; + lua_lock(L); + luaC_checkGC(L); + ret = luaO_pushvfstring(L, fmt, argp); + lua_unlock(L); + return ret; +} + + +LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) { + const char *ret; + va_list argp; + lua_lock(L); + luaC_checkGC(L); + va_start(argp, fmt); + ret = luaO_pushvfstring(L, fmt, argp); + va_end(argp); + lua_unlock(L); + return ret; +} + + +LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) { + Closure *cl; + lua_lock(L); + luaC_checkGC(L); + api_checknelems(L, n); + cl = luaF_newCclosure(L, n); + cl->c.f = fn; + L->top -= n; + while (n--) + setobj2n(&cl->c.upvalue[n], L->top+n); + setclvalue(L->top, cl); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API void lua_pushboolean (lua_State *L, int b) { + lua_lock(L); + setbvalue(L->top, (b != 0)); /* ensure that true is 1 */ + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API void lua_pushlightuserdata (lua_State *L, void *p) { + lua_lock(L); + setpvalue(L->top, p); + api_incr_top(L); + lua_unlock(L); +} + + + +/* +** get functions (Lua -> stack) +*/ + + +LUA_API void lua_gettable (lua_State *L, int idx) { + StkId t; + lua_lock(L); + t = luaA_index(L, idx); + setobj2s(L->top - 1, luaV_gettable(L, t, L->top - 1, 0)); + lua_unlock(L); +} + + +LUA_API void lua_rawget (lua_State *L, int idx) { + StkId t; + lua_lock(L); + t = luaA_index(L, idx); + api_check(L, ttistable(t)); + setobj2s(L->top - 1, luaH_get(hvalue(t), L->top - 1)); + lua_unlock(L); +} + + +LUA_API void lua_rawgeti (lua_State *L, int idx, int n) { + StkId o; + lua_lock(L); + o = luaA_index(L, idx); + api_check(L, ttistable(o)); + setobj2s(L->top, luaH_getnum(hvalue(o), n)); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API void lua_newtable (lua_State *L) { + lua_lock(L); + luaC_checkGC(L); + sethvalue(L->top, luaH_new(L, 0, 0)); + api_incr_top(L); + lua_unlock(L); +} + + +LUA_API int lua_getmetatable (lua_State *L, int objindex) { + const TObject *obj; + Table *mt = NULL; + int res; + lua_lock(L); + obj = luaA_indexAcceptable(L, objindex); + if (obj != NULL) { + switch (ttype(obj)) { + case LUA_TTABLE: + mt = hvalue(obj)->metatable; + break; + case LUA_TUSERDATA: + mt = uvalue(obj)->uv.metatable; + break; + } + } + if (mt == NULL || mt == hvalue(defaultmeta(L))) + res = 0; + else { + sethvalue(L->top, mt); + api_incr_top(L); + res = 1; + } + lua_unlock(L); + return res; +} + + +LUA_API void lua_getfenv (lua_State *L, int idx) { + StkId o; + lua_lock(L); + o = luaA_index(L, idx); + setobj2s(L->top, isLfunction(o) ? &clvalue(o)->l.g : gt(L)); + api_incr_top(L); + lua_unlock(L); +} + + +/* +** set functions (stack -> Lua) +*/ + + +LUA_API void lua_settable (lua_State *L, int idx) { + StkId t; + lua_lock(L); + api_checknelems(L, 2); + t = luaA_index(L, idx); + luaV_settable(L, t, L->top - 2, L->top - 1); + L->top -= 2; /* pop index and value */ + lua_unlock(L); +} + + +LUA_API void lua_rawset (lua_State *L, int idx) { + StkId t; + lua_lock(L); + api_checknelems(L, 2); + t = luaA_index(L, idx); + api_check(L, ttistable(t)); + setobj2t(luaH_set(L, hvalue(t), L->top-2), L->top-1); /* write barrier */ + L->top -= 2; + lua_unlock(L); +} + + +LUA_API void lua_rawseti (lua_State *L, int idx, int n) { + StkId o; + lua_lock(L); + api_checknelems(L, 1); + o = luaA_index(L, idx); + api_check(L, ttistable(o)); + setobj2t(luaH_setnum(L, hvalue(o), n), L->top-1); /* write barrier */ + L->top--; + lua_unlock(L); +} + + +LUA_API int lua_setmetatable (lua_State *L, int objindex) { + TObject *obj, *mt; + int res = 1; + lua_lock(L); + api_checknelems(L, 1); + obj = luaA_index(L, objindex); + mt = (!ttisnil(L->top - 1)) ? L->top - 1 : defaultmeta(L); + api_check(L, ttistable(mt)); + switch (ttype(obj)) { + case LUA_TTABLE: { + hvalue(obj)->metatable = hvalue(mt); /* write barrier */ + break; + } + case LUA_TUSERDATA: { + uvalue(obj)->uv.metatable = hvalue(mt); /* write barrier */ + break; + } + default: { + res = 0; /* cannot set */ + break; + } + } + L->top--; + lua_unlock(L); + return res; +} + + +LUA_API int lua_setfenv (lua_State *L, int idx) { + StkId o; + int res = 0; + lua_lock(L); + api_checknelems(L, 1); + o = luaA_index(L, idx); + L->top--; + api_check(L, ttistable(L->top)); + if (isLfunction(o)) { + res = 1; + clvalue(o)->l.g = *(L->top); + } + lua_unlock(L); + return res; +} + + +/* +** `load' and `call' functions (run Lua code) +*/ + +LUA_API void lua_call (lua_State *L, int nargs, int nresults) { + StkId func; + lua_lock(L); + api_checknelems(L, nargs+1); + func = L->top - (nargs+1); + luaD_call(L, func, nresults); + lua_unlock(L); +} + + + +/* +** Execute a protected call. +*/ +struct CallS { /* data to `f_call' */ + StkId func; + int nresults; +}; + + +static void f_call (lua_State *L, void *ud) { + struct CallS *c = cast(struct CallS *, ud); + luaD_call(L, c->func, c->nresults); +} + + + +LUA_API int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc) { + struct CallS c; + int status; + ptrdiff_t func; + lua_lock(L); + func = (errfunc == 0) ? 0 : savestack(L, luaA_index(L, errfunc)); + c.func = L->top - (nargs+1); /* function to be called */ + c.nresults = nresults; + status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func); + lua_unlock(L); + return status; +} + + +/* +** Execute a protected C call. +*/ +struct CCallS { /* data to `f_Ccall' */ + lua_CFunction func; + void *ud; +}; + + +static void f_Ccall (lua_State *L, void *ud) { + struct CCallS *c = cast(struct CCallS *, ud); + Closure *cl; + cl = luaF_newCclosure(L, 0); + cl->c.f = c->func; + setclvalue(L->top, cl); /* push function */ + incr_top(L); + setpvalue(L->top, c->ud); /* push only argument */ + incr_top(L); + luaD_call(L, L->top - 2, 0); +} + + +LUA_API int lua_cpcall (lua_State *L, lua_CFunction func, void *ud) { + struct CCallS c; + int status; + lua_lock(L); + c.func = func; + c.ud = ud; + status = luaD_pcall(L, f_Ccall, &c, savestack(L, L->top), 0); + lua_unlock(L); + return status; +} + + +LUA_API int lua_load (lua_State *L, lua_Chunkreader reader, void *data, + const char *chunkname) { + ZIO z; + int status; + int c; + lua_lock(L); + if (!chunkname) chunkname = "?"; + luaZ_init(&z, reader, data, chunkname); + c = luaZ_lookahead(&z); + status = luaD_protectedparser(L, &z, (c == LUA_SIGNATURE[0])); + lua_unlock(L); + return status; +} + + +LUA_API int lua_dump (lua_State *L, lua_Chunkwriter writer, void *data) { + int status; + TObject *o; + lua_lock(L); + api_checknelems(L, 1); + o = L->top - 1; + if (isLfunction(o) && clvalue(o)->l.nupvalues == 0) { + luaU_dump(L, clvalue(o)->l.p, writer, data); + status = 1; + } + else + status = 0; + lua_unlock(L); + return status; +} + + +/* +** Garbage-collection functions +*/ + +/* GC values are expressed in Kbytes: #bytes/2^10 */ +#define GCscalel(x) ((x)>>10) +#define GCscale(x) (cast(int, GCscalel(x))) +#define GCunscale(x) (cast(lu_mem, x)<<10) + +LUA_API int lua_getgcthreshold (lua_State *L) { + int threshold; + lua_lock(L); + threshold = GCscale(G(L)->GCthreshold); + lua_unlock(L); + return threshold; +} + +LUA_API int lua_getgccount (lua_State *L) { + int count; + lua_lock(L); + count = GCscale(G(L)->nblocks); + lua_unlock(L); + return count; +} + +LUA_API void lua_setgcthreshold (lua_State *L, int newthreshold) { + lua_lock(L); + if (cast(lu_mem, newthreshold) > GCscalel(MAX_LUMEM)) + G(L)->GCthreshold = MAX_LUMEM; + else + G(L)->GCthreshold = GCunscale(newthreshold); + luaC_checkGC(L); + lua_unlock(L); +} + + +/* +** miscellaneous functions +*/ + + +LUA_API const char *lua_version (void) { + return LUA_VERSION; +} + + +LUA_API int lua_error (lua_State *L) { + lua_lock(L); + api_checknelems(L, 1); + luaG_errormsg(L); + lua_unlock(L); + return 0; /* to avoid warnings */ +} + + +LUA_API int lua_next (lua_State *L, int idx) { + StkId t; + int more; + lua_lock(L); + t = luaA_index(L, idx); + api_check(L, ttistable(t)); + more = luaH_next(L, hvalue(t), L->top - 1); + if (more) { + api_incr_top(L); + } + else /* no more elements */ + L->top -= 1; /* remove key */ + lua_unlock(L); + return more; +} + + +LUA_API void lua_concat (lua_State *L, int n) { + lua_lock(L); + luaC_checkGC(L); + api_checknelems(L, n); + if (n >= 2) { + luaV_concat(L, n, L->top - L->base - 1); + L->top -= (n-1); + } + else if (n == 0) { /* push empty string */ + setsvalue2s(L->top, luaS_newlstr(L, NULL, 0)); + api_incr_top(L); + } + /* else n == 1; nothing to do */ + lua_unlock(L); +} + + +LUA_API void *lua_newuserdata (lua_State *L, size_t size) { + Udata *u; + lua_lock(L); + luaC_checkGC(L); + u = luaS_newudata(L, size); + setuvalue(L->top, u); + api_incr_top(L); + lua_unlock(L); + return u + 1; +} + + +LUA_API int lua_pushupvalues (lua_State *L) { + Closure *func; + int n, i; + lua_lock(L); + api_check(L, iscfunction(L->base - 1)); + func = clvalue(L->base - 1); + n = func->c.nupvalues; + luaD_checkstack(L, n + LUA_MINSTACK); + for (i=0; itop, &func->c.upvalue[i]); + L->top++; + } + lua_unlock(L); + return n; +} + + +static const char *aux_upvalue (lua_State *L, int funcindex, int n, + TObject **val) { + Closure *f; + StkId fi = luaA_index(L, funcindex); + if (!ttisfunction(fi)) return NULL; + f = clvalue(fi); + if (f->c.isC) { + if (n > f->c.nupvalues) return NULL; + *val = &f->c.upvalue[n-1]; + return ""; + } + else { + Proto *p = f->l.p; + if (n > p->sizeupvalues) return NULL; + *val = f->l.upvals[n-1]->v; + return getstr(p->upvalues[n-1]); + } +} + + +LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) { + const char *name; + TObject *val; + lua_lock(L); + name = aux_upvalue(L, funcindex, n, &val); + if (name) { + setobj2s(L->top, val); + api_incr_top(L); + } + lua_unlock(L); + return name; +} + + +LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) { + const char *name; + TObject *val; + lua_lock(L); + api_checknelems(L, 1); + name = aux_upvalue(L, funcindex, n, &val); + if (name) { + L->top--; + setobj(val, L->top); /* write barrier */ + } + lua_unlock(L); + return name; +} + diff --git a/stepmania/src/lua-5.0/src/lapi.h b/stepmania/src/lua-5.0/src/lapi.h new file mode 100644 index 0000000000..b71328334a --- /dev/null +++ b/stepmania/src/lua-5.0/src/lapi.h @@ -0,0 +1,16 @@ +/* +** $Id$ +** Auxiliary functions from Lua API +** See Copyright Notice in lua.h +*/ + +#ifndef lapi_h +#define lapi_h + + +#include "lobject.h" + + +void luaA_pushobject (lua_State *L, const TObject *o); + +#endif diff --git a/stepmania/src/lua-5.0/src/lcode.c b/stepmania/src/lua-5.0/src/lcode.c new file mode 100644 index 0000000000..29e3f12a9b --- /dev/null +++ b/stepmania/src/lua-5.0/src/lcode.c @@ -0,0 +1,714 @@ +/* +** $Id$ +** Code generator for Lua +** See Copyright Notice in lua.h +*/ + + +#include + +#define lcode_c + +#include "lua.h" + +#include "lcode.h" +#include "ldebug.h" +#include "ldo.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) + + +void luaK_nil (FuncState *fs, int from, int n) { + Instruction *previous; + if (fs->pc > fs->lasttarget && /* no jumps to current position? */ + GET_OPCODE(*(previous = &fs->f->code[fs->pc-1])) == 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; +} + + +static int luaK_condjump (FuncState *fs, OpCode op, int A, int B, int C) { + luaK_codeABC(fs, op, A, B, C); + return luaK_jump(fs); +} + + +static void luaK_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 luaK_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 && testOpMode(GET_OPCODE(*(pi-1)), OpModeT)) + 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, int cond) { + for (; list != NO_JUMP; list = luaK_getjump(fs, list)) { + Instruction i = *getjumpcontrol(fs, list); + if (GET_OPCODE(i) != OP_TEST || GETARG_C(i) != cond) return 1; + } + return 0; /* not found */ +} + + +static void patchtestreg (Instruction *i, int reg) { + if (reg == NO_REG) reg = GETARG_B(*i); + SETARG_A(*i, reg); +} + + +static void luaK_patchlistaux (FuncState *fs, int list, + int ttarget, int treg, int ftarget, int freg, int dtarget) { + while (list != NO_JUMP) { + int next = luaK_getjump(fs, list); + Instruction *i = getjumpcontrol(fs, list); + if (GET_OPCODE(*i) != OP_TEST) { + lua_assert(dtarget != NO_JUMP); + luaK_fixjump(fs, list, dtarget); /* jump to default target */ + } + else { + if (GETARG_C(*i)) { + lua_assert(ttarget != NO_JUMP); + patchtestreg(i, treg); + luaK_fixjump(fs, list, ttarget); + } + else { + lua_assert(ftarget != NO_JUMP); + patchtestreg(i, freg); + luaK_fixjump(fs, list, ftarget); + } + } + list = next; + } +} + + +static void luaK_dischargejpc (FuncState *fs) { + luaK_patchlistaux(fs, fs->jpc, fs->pc, NO_REG, 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); + luaK_patchlistaux(fs, list, target, NO_REG, 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 = luaK_getjump(fs, list)) != NO_JUMP) /* find last element */ + list = next; + luaK_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(lu_byte, newstack); + } +} + + +void luaK_reserveregs (FuncState *fs, int n) { + luaK_checkstack(fs, n); + fs->freereg += n; +} + + +static void freereg (FuncState *fs, int reg) { + if (reg >= fs->nactvar && reg < MAXSTACK) { + fs->freereg--; + lua_assert(reg == fs->freereg); + } +} + + +static void freeexp (FuncState *fs, expdesc *e) { + if (e->k == VNONRELOC) + freereg(fs, e->info); +} + + +static int addk (FuncState *fs, TObject *k, TObject *v) { + const TObject *idx = luaH_get(fs->h, k); + 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 */ + Proto *f = fs->f; + luaM_growvector(fs->L, f->k, fs->nk, f->sizek, TObject, + MAXARG_Bx, "constant table overflow"); + setobj2n(&f->k[fs->nk], v); + setnvalue(luaH_set(fs->L, fs->h, k), cast(lua_Number, fs->nk)); + return fs->nk++; + } +} + + +int luaK_stringK (FuncState *fs, TString *s) { + TObject o; + setsvalue(&o, s); + return addk(fs, &o, &o); +} + + +int luaK_numberK (FuncState *fs, lua_Number r) { + TObject o; + setnvalue(&o, r); + return addk(fs, &o, &o); +} + + +static int nil_constant (FuncState *fs) { + TObject k, v; + setnilvalue(&v); + sethvalue(&k, fs->h); /* cannot use nil as key; instead use table itself */ + return addk(fs, &k, &v); +} + + +void luaK_setcallreturns (FuncState *fs, expdesc *e, int nresults) { + if (e->k == VCALL) { /* expression is an open function call? */ + SETARG_C(getcode(fs, e), nresults+1); + if (nresults == 1) { /* `regular' expression? */ + e->k = VNONRELOC; + e->info = GETARG_A(getcode(fs, e)); + } + } +} + + +void luaK_dischargevars (FuncState *fs, expdesc *e) { + switch (e->k) { + case VLOCAL: { + e->k = VNONRELOC; + break; + } + case VUPVAL: { + e->info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->info, 0); + e->k = VRELOCABLE; + break; + } + case VGLOBAL: { + e->info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->info); + e->k = VRELOCABLE; + break; + } + case VINDEXED: { + freereg(fs, e->aux); + freereg(fs, e->info); + e->info = luaK_codeABC(fs, OP_GETTABLE, 0, e->info, e->aux); + e->k = VRELOCABLE; + break; + } + case VCALL: { + luaK_setcallreturns(fs, e, 1); + 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->info); + break; + } + case VRELOCABLE: { + Instruction *pc = &getcode(fs, e); + SETARG_A(*pc, reg); + break; + } + case VNONRELOC: { + if (reg != e->info) + luaK_codeABC(fs, OP_MOVE, reg, e->info, 0); + break; + } + default: { + lua_assert(e->k == VVOID || e->k == VJMP); + return; /* nothing to do... */ + } + } + e->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 luaK_exp2reg (FuncState *fs, expdesc *e, int reg) { + discharge2reg(fs, e, reg); + if (e->k == VJMP) + luaK_concat(fs, &e->t, e->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, 1) || need_value(fs, e->f, 0)) { + int fj = NO_JUMP; /* first jump (over LOAD ops.) */ + if (e->k != VJMP) + fj = 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); + luaK_patchlistaux(fs, e->f, p_f, NO_REG, final, reg, p_f); + luaK_patchlistaux(fs, e->t, final, reg, p_t, NO_REG, p_t); + } + e->f = e->t = NO_JUMP; + e->info = reg; + e->k = VNONRELOC; +} + + +void luaK_exp2nextreg (FuncState *fs, expdesc *e) { + luaK_dischargevars(fs, e); + freeexp(fs, e); + luaK_reserveregs(fs, 1); + luaK_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->info; /* exp is already in a register */ + if (e->info >= fs->nactvar) { /* reg. is not a local? */ + luaK_exp2reg(fs, e, e->info); /* put value on it */ + return e->info; + } + } + luaK_exp2nextreg(fs, e); /* default */ + return e->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 VNIL: { + if (fs->nk + MAXSTACK <= MAXARG_C) { /* constant fit in argC? */ + e->info = nil_constant(fs); + e->k = VK; + return e->info + MAXSTACK; + } + else break; + } + case VK: { + if (e->info + MAXSTACK <= MAXARG_C) /* constant fit in argC? */ + return e->info + MAXSTACK; + 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 *exp) { + switch (var->k) { + case VLOCAL: { + freeexp(fs, exp); + luaK_exp2reg(fs, exp, var->info); + return; + } + case VUPVAL: { + int e = luaK_exp2anyreg(fs, exp); + luaK_codeABC(fs, OP_SETUPVAL, e, var->info, 0); + break; + } + case VGLOBAL: { + int e = luaK_exp2anyreg(fs, exp); + luaK_codeABx(fs, OP_SETGLOBAL, e, var->info); + break; + } + case VINDEXED: { + int e = luaK_exp2RK(fs, exp); + luaK_codeABC(fs, OP_SETTABLE, var->info, var->aux, e); + break; + } + default: { + lua_assert(0); /* invalid var kind to store */ + break; + } + } + freeexp(fs, exp); +} + + +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->info, luaK_exp2RK(fs, key)); + freeexp(fs, key); + e->info = func; + e->k = VNONRELOC; +} + + +static void invertjump (FuncState *fs, expdesc *e) { + Instruction *pc = getjumpcontrol(fs, e->info); + lua_assert(testOpMode(GET_OPCODE(*pc), OpModeT) && + 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 luaK_condjump(fs, OP_TEST, NO_REG, GETARG_B(ie), !cond); + } + /* else go through */ + } + discharge2anyreg(fs, e); + freeexp(fs, e); + return luaK_condjump(fs, OP_TEST, NO_REG, e->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 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->info; + break; + } + default: { + pc = jumponcond(fs, e, 0); + break; + } + } + luaK_concat(fs, &e->f, pc); /* insert last jump in `f' list */ +} + + +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->info; + break; + } + default: { + pc = jumponcond(fs, e, 1); + break; + } + } + luaK_concat(fs, &e->t, pc); /* insert last jump in `t' list */ +} + + +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 VTRUE: { + e->k = VFALSE; + break; + } + case VJMP: { + invertjump(fs, e); + break; + } + case VRELOCABLE: + case VNONRELOC: { + discharge2anyreg(fs, e); + freeexp(fs, e); + e->info = luaK_codeABC(fs, OP_NOT, 0, e->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; } +} + + +void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) { + t->aux = luaK_exp2RK(fs, k); + t->k = VINDEXED; +} + + +void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) { + if (op == OPR_MINUS) { + luaK_exp2val(fs, e); + if (e->k == VK && ttisnumber(&fs->f->k[e->info])) + e->info = luaK_numberK(fs, -nvalue(&fs->f->k[e->info])); + else { + luaK_exp2anyreg(fs, e); + freeexp(fs, e); + e->info = luaK_codeABC(fs, OP_UNM, 0, e->info, 0); + e->k = VRELOCABLE; + } + } + else /* op == NOT */ + codenot(fs, e); +} + + +void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) { + switch (op) { + case OPR_AND: { + luaK_goiftrue(fs, v); + luaK_patchtohere(fs, v->t); + v->t = NO_JUMP; + break; + } + case OPR_OR: { + luaK_goiffalse(fs, v); + luaK_patchtohere(fs, v->f); + v->f = NO_JUMP; + break; + } + case OPR_CONCAT: { + luaK_exp2nextreg(fs, v); /* operand must be on the `stack' */ + break; + } + default: { + luaK_exp2RK(fs, v); + break; + } + } +} + + +static void codebinop (FuncState *fs, expdesc *res, BinOpr op, + int o1, int o2) { + if (op <= OPR_POW) { /* arithmetic operator? */ + OpCode opc = cast(OpCode, (op - OPR_ADD) + OP_ADD); /* ORDER OP */ + res->info = luaK_codeABC(fs, opc, 0, o1, o2); + res->k = VRELOCABLE; + } + else { /* test operator */ + static const OpCode ops[] = {OP_EQ, OP_EQ, OP_LT, OP_LE, OP_LT, OP_LE}; + int cond = 1; + if (op >= OPR_GT) { /* `>' or `>='? */ + int temp; /* exchange args and replace by `<' or `<=' */ + temp = o1; o1 = o2; o2 = temp; /* o1 <==> o2 */ + } + else if (op == OPR_NE) cond = 0; + res->info = luaK_condjump(fs, ops[op - OPR_NE], cond, o1, o2); + res->k = VJMP; + } +} + + +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, &e1->f, e2->f); + e1->k = e2->k; e1->info = e2->info; e1->aux = e2->aux; e1->t = e2->t; + break; + } + case OPR_OR: { + lua_assert(e1->f == NO_JUMP); /* list must be closed */ + luaK_dischargevars(fs, e2); + luaK_concat(fs, &e1->t, e2->t); + e1->k = e2->k; e1->info = e2->info; e1->aux = e2->aux; e1->f = e2->f; + break; + } + case OPR_CONCAT: { + luaK_exp2val(fs, e2); + if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) { + lua_assert(e1->info == GETARG_B(getcode(fs, e2))-1); + freeexp(fs, e1); + SETARG_B(getcode(fs, e2), e1->info); + e1->k = e2->k; e1->info = e2->info; + } + else { + luaK_exp2nextreg(fs, e2); + freeexp(fs, e2); + freeexp(fs, e1); + e1->info = luaK_codeABC(fs, OP_CONCAT, 0, e1->info, e2->info); + e1->k = VRELOCABLE; + } + break; + } + default: { + int o1 = luaK_exp2RK(fs, e1); + int o2 = luaK_exp2RK(fs, e2); + freeexp(fs, e2); + freeexp(fs, e1); + codebinop(fs, e1, op, o1, o2); + } + } +} + + +void luaK_fixline (FuncState *fs, int line) { + fs->f->lineinfo[fs->pc - 1] = line; +} + + +int luaK_code (FuncState *fs, Instruction i, int line) { + Proto *f = fs->f; + luaK_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); + 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); + return luaK_code(fs, CREATE_ABx(o, a, bc), fs->ls->lastline); +} + diff --git a/stepmania/src/lua-5.0/src/lcode.h b/stepmania/src/lua-5.0/src/lcode.h new file mode 100644 index 0000000000..9817ec41aa --- /dev/null +++ b/stepmania/src/lua-5.0/src/lcode.h @@ -0,0 +1,74 @@ +/* +** $Id$ +** 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_MULT, OPR_DIV, OPR_POW, + OPR_CONCAT, + OPR_NE, OPR_EQ, + OPR_LT, OPR_LE, OPR_GT, OPR_GE, + OPR_AND, OPR_OR, + OPR_NOBINOPR +} BinOpr; + +#define binopistest(op) ((op) >= OPR_NE) + +typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_NOUNOPR } UnOpr; + + +#define getcode(fs,e) ((fs)->f->code[(e)->info]) + +#define luaK_codeAsBx(fs,o,A,sBx) luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx) + +int luaK_code (FuncState *fs, Instruction i, int line); +int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx); +int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C); +void luaK_fixline (FuncState *fs, int line); +void luaK_nil (FuncState *fs, int from, int n); +void luaK_reserveregs (FuncState *fs, int n); +void luaK_checkstack (FuncState *fs, int n); +int luaK_stringK (FuncState *fs, TString *s); +int luaK_numberK (FuncState *fs, lua_Number r); +void luaK_dischargevars (FuncState *fs, expdesc *e); +int luaK_exp2anyreg (FuncState *fs, expdesc *e); +void luaK_exp2nextreg (FuncState *fs, expdesc *e); +void luaK_exp2val (FuncState *fs, expdesc *e); +int luaK_exp2RK (FuncState *fs, expdesc *e); +void luaK_self (FuncState *fs, expdesc *e, expdesc *key); +void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k); +void luaK_goiftrue (FuncState *fs, expdesc *e); +void luaK_goiffalse (FuncState *fs, expdesc *e); +void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e); +void luaK_setcallreturns (FuncState *fs, expdesc *var, int nresults); +int luaK_jump (FuncState *fs); +void luaK_patchlist (FuncState *fs, int list, int target); +void luaK_patchtohere (FuncState *fs, int list); +void luaK_concat (FuncState *fs, int *l1, int l2); +int luaK_getlabel (FuncState *fs); +void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v); +void luaK_infix (FuncState *fs, BinOpr op, expdesc *v); +void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2); + + +#endif diff --git a/stepmania/src/lua-5.0/src/ldebug.c b/stepmania/src/lua-5.0/src/ldebug.c new file mode 100644 index 0000000000..ca317d04e0 --- /dev/null +++ b/stepmania/src/lua-5.0/src/ldebug.c @@ -0,0 +1,585 @@ +/* +** $Id$ +** Debug Interface +** See Copyright Notice in lua.h +*/ + + +#include +#include + +#define ldebug_c + +#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 (CallInfo *ci, const char **name); + + +#define isLua(ci) (!((ci)->state & CI_C)) + + +static int currentpc (CallInfo *ci) { + if (!isLua(ci)) return -1; /* function is not a Lua function? */ + if (ci->state & CI_HASFRAME) /* function has a frame? */ + ci->u.l.savedpc = *ci->u.l.pc; /* use `pc' from there */ + /* function's pc is saved */ + return pcRel(ci->u.l.savedpc, ci_func(ci)->l.p); +} + + +static int currentline (CallInfo *ci) { + int pc = currentpc(ci); + if (pc < 0) + return -1; /* only active lua functions have current-line information */ + else + return getline(ci_func(ci)->l.p, pc); +} + + +void luaG_inithooks (lua_State *L) { + CallInfo *ci; + for (ci = L->ci; ci != L->base_ci; ci--) /* update all `savedpc's */ + currentpc(ci); + L->hookinit = 1; +} + + +/* +** 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(lu_byte, mask); + L->hookinit = 0; + 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 (!(ci->state & CI_C)) /* Lua function? */ + level -= ci->u.l.tailcalls; /* skip lost tail calls */ + } + if (level > 0 || ci == L->base_ci) status = 0; /* there is no such level */ + else if (level < 0) { /* level is of a lost tail call */ + status = 1; + ar->i_ci = 0; + } + else { + status = 1; + ar->i_ci = ci - L->base_ci; + } + lua_unlock(L); + return status; +} + + +static Proto *getluaproto (CallInfo *ci) { + return (isLua(ci) ? ci_func(ci)->l.p : NULL); +} + + +LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) { + const char *name; + CallInfo *ci; + Proto *fp; + lua_lock(L); + name = NULL; + ci = L->base_ci + ar->i_ci; + fp = getluaproto(ci); + if (fp) { /* is a Lua function? */ + name = luaF_getlocalname(fp, n, currentpc(ci)); + if (name) + luaA_pushobject(L, ci->base+(n-1)); /* push value */ + } + lua_unlock(L); + return name; +} + + +LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) { + const char *name; + CallInfo *ci; + Proto *fp; + lua_lock(L); + name = NULL; + ci = L->base_ci + ar->i_ci; + fp = getluaproto(ci); + L->top--; /* pop new value */ + if (fp) { /* is a Lua function? */ + name = luaF_getlocalname(fp, n, currentpc(ci)); + if (!name || name[0] == '(') /* `(' starts private locals */ + name = NULL; + else + setobjs2s(ci->base+(n-1), L->top); + } + lua_unlock(L); + return name; +} + + +static void funcinfo (lua_Debug *ar, StkId func) { + Closure *cl = clvalue(func); + if (cl->c.isC) { + ar->source = "=[C]"; + ar->linedefined = -1; + ar->what = "C"; + } + else { + ar->source = getstr(cl->l.p->source); + ar->linedefined = cl->l.p->lineDefined; + ar->what = (ar->linedefined == 0) ? "main" : "Lua"; + } + luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE); +} + + +static const char *travglobals (lua_State *L, const TObject *o) { + Table *g = hvalue(gt(L)); + int i = sizenode(g); + while (i--) { + Node *n = gnode(g, i); + if (luaO_rawequalObj(o, gval(n)) && ttisstring(gkey(n))) + return getstr(tsvalue(gkey(n))); + } + return NULL; +} + + +static void info_tailcall (lua_State *L, lua_Debug *ar) { + ar->name = ar->namewhat = ""; + ar->what = "tail"; + ar->linedefined = ar->currentline = -1; + ar->source = "=(tail call)"; + luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE); + ar->nups = 0; + setnilvalue(L->top); +} + + +static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar, + StkId f, CallInfo *ci) { + int status = 1; + for (; *what; what++) { + switch (*what) { + case 'S': { + funcinfo(ar, f); + break; + } + case 'l': { + ar->currentline = (ci) ? currentline(ci) : -1; + break; + } + case 'u': { + ar->nups = clvalue(f)->c.nupvalues; + break; + } + case 'n': { + ar->namewhat = (ci) ? getfuncname(ci, &ar->name) : NULL; + if (ar->namewhat == NULL) { + /* try to find a global name */ + if ((ar->name = travglobals(L, f)) != NULL) + ar->namewhat = "global"; + else ar->namewhat = ""; /* not found */ + } + break; + } + case 'f': { + setobj2s(L->top, f); + break; + } + default: status = 0; /* invalid option */ + } + } + return status; +} + + +LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) { + int status = 1; + lua_lock(L); + if (*what == '>') { + StkId f = L->top - 1; + if (!ttisfunction(f)) + luaG_runerror(L, "value for `lua_getinfo' is not a function"); + status = auxgetinfo(L, what + 1, ar, f, NULL); + L->top--; /* pop function */ + } + else if (ar->i_ci != 0) { /* no tail call? */ + CallInfo *ci = L->base_ci + ar->i_ci; + lua_assert(ttisfunction(ci->base - 1)); + status = auxgetinfo(L, what, ar, ci->base - 1, ci); + } + else + info_tailcall(L, ar); + if (strchr(what, 'f')) incr_top(L); + 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->sizelineinfo == pt->sizecode || pt->sizelineinfo == 0); + lua_assert(pt->numparams+pt->is_vararg <= pt->maxstacksize); + check(GET_OPCODE(pt->code[pt->sizecode-1]) == OP_RETURN); + return 1; +} + + +static int checkopenop (const Proto *pt, int pc) { + Instruction i = pt->code[pc+1]; + switch (GET_OPCODE(i)) { + case OP_CALL: + case OP_TAILCALL: + case OP_RETURN: { + check(GETARG_B(i) == 0); + return 1; + } + case OP_SETLISTO: return 1; + default: return 0; /* invalid instruction after an open call */ + } +} + + +static int checkRK (const Proto *pt, int r) { + return (r < pt->maxstacksize || (r >= MAXSTACK && r-MAXSTACK < pt->sizek)); +} + + +static Instruction luaG_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++) { + const Instruction i = pt->code[pc]; + OpCode op = GET_OPCODE(i); + int a = GETARG_A(i); + int b = 0; + int c = 0; + checkreg(pt, a); + switch (getOpMode(op)) { + case iABC: { + b = GETARG_B(i); + c = GETARG_C(i); + if (testOpMode(op, OpModeBreg)) { + checkreg(pt, b); + } + else if (testOpMode(op, OpModeBrk)) + check(checkRK(pt, b)); + if (testOpMode(op, OpModeCrk)) + check(checkRK(pt, c)); + break; + } + case iABx: { + b = GETARG_Bx(i); + if (testOpMode(op, OpModeK)) check(b < pt->sizek); + break; + } + case iAsBx: { + b = GETARG_sBx(i); + break; + } + } + if (testOpMode(op, OpModesetA)) { + if (a == reg) last = pc; /* change register `a' */ + } + if (testOpMode(op, OpModeT)) { + check(pc+2 < pt->sizecode); /* check skip */ + check(GET_OPCODE(pt->code[pc+1]) == OP_JMP); + } + switch (op) { + case OP_LOADBOOL: { + check(c == 0 || pc+2 < pt->sizecode); /* check its jump */ + 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: { + /* `c' is a register, and at least two operands */ + check(c < MAXSTACK && b < c); + break; + } + case OP_TFORLOOP: + checkreg(pt, a+c+5); + if (reg >= a) last = pc; /* affect all registers above base */ + /* go through */ + case OP_FORLOOP: + checkreg(pt, a+2); + /* go through */ + case OP_JMP: { + int dest = pc+1+b; + check(0 <= dest && dest < pt->sizecode); + /* 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: { + checkreg(pt, a + (b&(LFIELDS_PER_FLUSH-1)) + 1); + break; + } + case OP_CLOSURE: { + int nup; + check(b < pt->sizep); + nup = pt->p[b]->nups; + check(pc + nup < pt->sizecode); + for (; nup>0; nup--) { + OpCode op1 = GET_OPCODE(pt->code[pc+nup]); + check(op1 == OP_GETUPVAL || op1 == OP_MOVE); + } + break; + } + default: break; + } + } + return pt->code[last]; +} + +#undef check +#undef checkjump +#undef checkreg + +/* }====================================================== */ + + +int luaG_checkcode (const Proto *pt) { + return luaG_symbexec(pt, pt->sizecode, NO_REG); +} + + +static const char *kname (Proto *p, int c) { + c = c - MAXSTACK; + if (c >= 0 && ttisstring(&p->k[c])) + return svalue(&p->k[c]); + else + return "?"; +} + + +static const char *getobjname (CallInfo *ci, int stackpos, const char **name) { + if (isLua(ci)) { /* a Lua function? */ + Proto *p = ci_func(ci)->l.p; + int pc = currentpc(ci); + Instruction i; + *name = luaF_getlocalname(p, stackpos+1, pc); + if (*name) /* is a local? */ + return "local"; + i = luaG_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(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_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 (CallInfo *ci, const char **name) { + Instruction i; + if ((isLua(ci) && ci->u.l.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(ci)]; + if (GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL) + return getobjname(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 TObject *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 TObject *o, const char *op) { + const char *name = NULL; + const char *t = luaT_typenames[ttype(o)]; + const char *kind = (isinstack(L->ci, o)) ? + getobjname(L->ci, o - L->base, &name) : NULL; + if (kind) + luaG_runerror(L, "attempt to %s %s `%s' (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)) p1 = p2; + lua_assert(!ttisstring(p1)); + luaG_typeerror(L, p1, "concatenate"); +} + + +void luaG_aritherror (lua_State *L, const TObject *p1, const TObject *p2) { + TObject 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 TObject *p1, const TObject *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(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->top, L->top - 1); /* move argument */ + setobjs2s(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); +} + diff --git a/stepmania/src/lua-5.0/src/ldebug.h b/stepmania/src/lua-5.0/src/ldebug.h new file mode 100644 index 0000000000..dbacce421e --- /dev/null +++ b/stepmania/src/lua-5.0/src/ldebug.h @@ -0,0 +1,31 @@ +/* +** $Id$ +** 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) + + +void luaG_inithooks (lua_State *L); +void luaG_typeerror (lua_State *L, const TObject *o, const char *opname); +void luaG_concaterror (lua_State *L, StkId p1, StkId p2); +void luaG_aritherror (lua_State *L, const TObject *p1, const TObject *p2); +int luaG_ordererror (lua_State *L, const TObject *p1, const TObject *p2); +void luaG_runerror (lua_State *L, const char *fmt, ...); +void luaG_errormsg (lua_State *L); +int luaG_checkcode (const Proto *pt); + + +#endif diff --git a/stepmania/src/lua-5.0/src/ldo.c b/stepmania/src/lua-5.0/src/ldo.c new file mode 100644 index 0000000000..064bfadbec --- /dev/null +++ b/stepmania/src/lua-5.0/src/ldo.c @@ -0,0 +1,471 @@ +/* +** $Id$ +** Stack and Call structure of Lua +** See Copyright Notice in lua.h +*/ + + +#include +#include +#include + +#define ldo_c + +#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 (based on long jumps) +** ======================================================= +*/ + + +/* chain list of long jump buffers */ +struct lua_longjmp { + struct lua_longjmp *previous; + jmp_buf b; + volatile int status; /* error code */ +}; + + +static void seterrorobj (lua_State *L, int errcode, StkId oldtop) { + switch (errcode) { + case LUA_ERRMEM: { + setsvalue2s(oldtop, luaS_new(L, MEMERRMSG)); + break; + } + case LUA_ERRERR: { + setsvalue2s(oldtop, luaS_new(L, "error in error handling")); + break; + } + case LUA_ERRSYNTAX: + case LUA_ERRRUN: { + setobjs2s(oldtop, L->top - 1); /* error message on current top */ + break; + } + } + L->top = oldtop + 1; +} + + +void luaD_throw (lua_State *L, int errcode) { + if (L->errorJmp) { + L->errorJmp->status = errcode; + longjmp(L->errorJmp->b, 1); + } + else { + 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; + if (setjmp(lj.b) == 0) + (*f)(L, ud); + L->errorJmp = lj.previous; /* restore old error handler */ + return lj.status; +} + + +static void restore_stack_limit (lua_State *L) { + L->stack_last = L->stack+L->stacksize-1; + if (L->size_ci > LUA_MAXCALLS) { /* there was an overflow? */ + int inuse = (L->ci - L->base_ci); + if (inuse + 1 < LUA_MAXCALLS) /* can `undo' overflow? */ + luaD_reallocCI(L, LUA_MAXCALLS); + } +} + +/* }====================================================== */ + + +static void correctstack (lua_State *L, TObject *oldstack) { + CallInfo *ci; + GCObject *up; + L->top = (L->top - oldstack) + L->stack; + for (up = L->openupval; up != NULL; up = up->gch.next) + gcotouv(up)->v = (gcotouv(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; + } + L->base = L->ci->base; +} + + +void luaD_reallocstack (lua_State *L, int newsize) { + TObject *oldstack = L->stack; + luaM_reallocvector(L, L->stack, L->stacksize, newsize, TObject); + L->stacksize = newsize; + L->stack_last = L->stack+newsize-1-EXTRA_STACK; + 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 = cast(unsigned short, newsize); + L->ci = (L->ci - oldci) + L->base_ci; + L->end_ci = L->base_ci + L->size_ci; +} + + +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 + EXTRA_STACK); +} + + +static void luaD_growCI (lua_State *L) { + if (L->size_ci > LUA_MAXCALLS) /* overflow while handling overflow? */ + luaD_throw(L, LUA_ERRERR); + else { + luaD_reallocCI(L, 2*L->size_ci); + if (L->size_ci > LUA_MAXCALLS) + luaG_runerror(L, "stack overflow"); + } +} + + +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 = L->ci - L->base_ci; + luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */ + L->ci->top = L->top + LUA_MINSTACK; + 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 void adjust_varargs (lua_State *L, int nfixargs, StkId base) { + int i; + Table *htab; + TObject nname; + int actual = L->top - base; /* actual number of arguments */ + if (actual < nfixargs) { + luaD_checkstack(L, nfixargs - actual); + for (; actual < nfixargs; ++actual) + setnilvalue(L->top++); + } + actual -= nfixargs; /* number of extra arguments */ + htab = luaH_new(L, actual, 1); /* create `arg' table */ + for (i=0; itop - actual + i); + /* store counter in field `n' */ + setsvalue(&nname, luaS_newliteral(L, "n")); + setnvalue(luaH_set(L, htab, &nname), cast(lua_Number, actual)); + L->top -= actual; /* remove extra elements from the stack */ + sethvalue(L->top, htab); + incr_top(L); +} + + +static StkId tryfuncTM (lua_State *L, StkId func) { + const TObject *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(p, p-1); + incr_top(L); + func = restorestack(L, funcr); /* previous call may change stack */ + setobj2s(func, tm); /* tag method is the new function to be called */ + return func; +} + + +StkId luaD_precall (lua_State *L, StkId func) { + LClosure *cl; + ptrdiff_t funcr = savestack(L, func); + if (!ttisfunction(func)) /* `func' is not a function? */ + func = tryfuncTM(L, func); /* check the `function' tag method */ + if (L->ci + 1 == L->end_ci) luaD_growCI(L); + else condhardstacktests(luaD_reallocCI(L, L->size_ci)); + cl = &clvalue(func)->l; + if (!cl->isC) { /* Lua function? prepare its call */ + CallInfo *ci; + Proto *p = cl->p; + if (p->is_vararg) /* varargs? */ + adjust_varargs(L, p->numparams, func+1); + luaD_checkstack(L, p->maxstacksize); + ci = ++L->ci; /* now `enter' new function */ + L->base = L->ci->base = restorestack(L, funcr) + 1; + ci->top = L->base + p->maxstacksize; + ci->u.l.savedpc = p->code; /* starting point */ + ci->u.l.tailcalls = 0; + ci->state = CI_SAVEDPC; + while (L->top < ci->top) + setnilvalue(L->top++); + L->top = ci->top; + return NULL; + } + else { /* if is a C function, call it */ + CallInfo *ci; + int n; + luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */ + ci = ++L->ci; /* now `enter' new function */ + L->base = L->ci->base = restorestack(L, funcr) + 1; + ci->top = L->top + LUA_MINSTACK; + ci->state = CI_C; /* a C function */ + if (L->hookmask & LUA_MASKCALL) + luaD_callhook(L, LUA_HOOKCALL, -1); + lua_unlock(L); +#ifdef LUA_COMPATUPVALUES + lua_pushupvalues(L); +#endif + n = (*clvalue(L->base - 1)->c.f)(L); /* do the actual call */ + lua_lock(L); + return L->top - n; + } +} + + +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 (!(L->ci->state & CI_C)) { /* Lua function? */ + while (L->ci->u.l.tailcalls--) /* call hook for eventual tail calls */ + luaD_callhook(L, LUA_HOOKTAILRET, -1); + } + return restorestack(L, fr); +} + + +void luaD_poscall (lua_State *L, int wanted, StkId firstResult) { + StkId res; + if (L->hookmask & LUA_MASKRET) + firstResult = callrethooks(L, firstResult); + res = L->base - 1; /* res == final position of 1st result */ + L->ci--; + L->base = L->ci->base; /* restore base */ + /* move results to correct place */ + while (wanted != 0 && firstResult < L->top) { + setobjs2s(res++, firstResult++); + wanted--; + } + while (wanted-- > 0) + setnilvalue(res++); + L->top = res; +} + + +/* +** 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) { + StkId firstResult; + lua_assert(!(L->ci->state & CI_CALLING)); + if (++L->nCcalls >= LUA_MAXCCALLS) { + if (L->nCcalls == LUA_MAXCCALLS) + luaG_runerror(L, "C stack overflow"); + else if (L->nCcalls >= (LUA_MAXCCALLS + (LUA_MAXCCALLS>>3))) + luaD_throw(L, LUA_ERRERR); /* error while handing stack error */ + } + firstResult = luaD_precall(L, func); + if (firstResult == NULL) /* is a Lua function? */ + firstResult = luaV_execute(L); /* call it */ + luaD_poscall(L, nResults, firstResult); + L->nCcalls--; + luaC_checkGC(L); +} + + +static void resume (lua_State *L, void *ud) { + StkId firstResult; + int nargs = *cast(int *, ud); + CallInfo *ci = L->ci; + if (ci == L->base_ci) { /* no activation record? */ + lua_assert(nargs < L->top - L->base); + luaD_precall(L, L->top - (nargs + 1)); /* start coroutine */ + } + else { /* inside a yield */ + lua_assert(ci->state & CI_YIELD); + if (ci->state & CI_C) { /* `common' yield? */ + /* finish interrupted execution of `OP_CALL' */ + int nresults; + lua_assert((ci-1)->state & CI_SAVEDPC); + lua_assert(GET_OPCODE(*((ci-1)->u.l.savedpc - 1)) == OP_CALL || + GET_OPCODE(*((ci-1)->u.l.savedpc - 1)) == OP_TAILCALL); + nresults = GETARG_C(*((ci-1)->u.l.savedpc - 1)) - 1; + luaD_poscall(L, nresults, L->top - nargs); /* complete it */ + if (nresults >= 0) L->top = L->ci->top; + } + else { /* yielded inside a hook: just continue its execution */ + ci->state &= ~CI_YIELD; + } + } + firstResult = luaV_execute(L); + if (firstResult != NULL) /* return? */ + luaD_poscall(L, LUA_MULTRET, firstResult); /* finalize this coroutine */ +} + + +static int resume_error (lua_State *L, const char *msg) { + L->top = L->ci->base; + setsvalue2s(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; + lu_byte old_allowhooks; + lua_lock(L); + if (L->ci == L->base_ci) { + if (nargs >= L->top - L->base) + return resume_error(L, "cannot resume dead coroutine"); + } + else if (!(L->ci->state & CI_YIELD)) /* not inside a yield? */ + return resume_error(L, "cannot resume non-suspended coroutine"); + old_allowhooks = L->allowhook; + lua_assert(L->errfunc == 0 && L->nCcalls == 0); + status = luaD_rawrunprotected(L, resume, &nargs); + if (status != 0) { /* error? */ + L->ci = L->base_ci; /* go back to initial level */ + L->base = L->ci->base; + L->nCcalls = 0; + luaF_close(L, L->base); /* close eventual pending closures */ + seterrorobj(L, status, L->base); + L->allowhook = old_allowhooks; + restore_stack_limit(L); + } + lua_unlock(L); + return status; +} + + +LUA_API int lua_yield (lua_State *L, int nresults) { + CallInfo *ci; + lua_lock(L); + ci = L->ci; + if (L->nCcalls > 0) + luaG_runerror(L, "attempt to yield across metamethod/C-call boundary"); + if (ci->state & CI_C) { /* usual yield */ + if ((ci-1)->state & CI_C) + luaG_runerror(L, "cannot yield a C function"); + if (L->top - nresults > L->base) { /* is there garbage in the stack? */ + int i; + for (i=0; ibase + i, L->top - nresults + i); + L->top = L->base + nresults; + } + } /* else it's an yield inside a hook: nothing to do */ + ci->state |= CI_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 */ + seterrorobj(L, status, oldtop); + L->nCcalls = oldnCcalls; + L->ci = restoreci(L, old_ci); + L->base = L->ci->base; + 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 */ + int bin; +}; + +static void f_parser (lua_State *L, void *ud) { + struct SParser *p; + Proto *tf; + Closure *cl; + luaC_checkGC(L); + p = cast(struct SParser *, ud); + tf = p->bin ? luaU_undump(L, p->z, &p->buff) : luaY_parser(L, p->z, &p->buff); + cl = luaF_newLclosure(L, 0, gt(L)); + cl->l.p = tf; + setclvalue(L->top, cl); + incr_top(L); +} + + +int luaD_protectedparser (lua_State *L, ZIO *z, int bin) { + struct SParser p; + int status; + ptrdiff_t oldtopr = savestack(L, L->top); /* save current top */ + p.z = z; p.bin = bin; + luaZ_initbuffer(L, &p.buff); + status = luaD_rawrunprotected(L, f_parser, &p); + luaZ_freebuffer(L, &p.buff); + if (status != 0) { /* error? */ + StkId oldtop = restorestack(L, oldtopr); + seterrorobj(L, status, oldtop); + } + return status; +} + + diff --git a/stepmania/src/lua-5.0/src/ldo.h b/stepmania/src/lua-5.0/src/ldo.h new file mode 100644 index 0000000000..b23ac66d89 --- /dev/null +++ b/stepmania/src/lua-5.0/src/ldo.h @@ -0,0 +1,60 @@ +/* +** $Id$ +** 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" + + +/* +** macro to control inclusion of some hard tests on stack reallocation +*/ +#ifndef HARDSTACKTESTS +#define condhardstacktests(x) { /* empty */ } +#else +#define condhardstacktests(x) x +#endif + + +#define luaD_checkstack(L,n) \ + if ((char *)L->stack_last - (char *)L->top <= (n)*(int)sizeof(TObject)) \ + luaD_growstack(L, n); \ + else condhardstacktests(luaD_reallocstack(L, L->stacksize)); + + +#define incr_top(L) {luaD_checkstack(L,1); L->top++;} + +#define savestack(L,p) ((char *)(p) - (char *)L->stack) +#define restorestack(L,n) ((TObject *)((char *)L->stack + (n))) + +#define saveci(L,p) ((char *)(p) - (char *)L->base_ci) +#define restoreci(L,n) ((CallInfo *)((char *)L->base_ci + (n))) + + +/* type of protected functions, to be ran by `runprotected' */ +typedef void (*Pfunc) (lua_State *L, void *ud); + +void luaD_resetprotection (lua_State *L); +int luaD_protectedparser (lua_State *L, ZIO *z, int bin); +void luaD_callhook (lua_State *L, int event, int line); +StkId luaD_precall (lua_State *L, StkId func); +void luaD_call (lua_State *L, StkId func, int nResults); +int luaD_pcall (lua_State *L, Pfunc func, void *u, + ptrdiff_t oldtop, ptrdiff_t ef); +void luaD_poscall (lua_State *L, int wanted, StkId firstResult); +void luaD_reallocCI (lua_State *L, int newsize); +void luaD_reallocstack (lua_State *L, int newsize); +void luaD_growstack (lua_State *L, int n); + +void luaD_throw (lua_State *L, int errcode); +int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud); + + +#endif diff --git a/stepmania/src/lua-5.0/src/ldump.c b/stepmania/src/lua-5.0/src/ldump.c new file mode 100644 index 0000000000..87e3077844 --- /dev/null +++ b/stepmania/src/lua-5.0/src/ldump.c @@ -0,0 +1,170 @@ +/* +** $Id$ +** save bytecodes +** See Copyright Notice in lua.h +*/ + +#include + +#define ldump_c + +#include "lua.h" + +#include "lobject.h" +#include "lopcodes.h" +#include "lstate.h" +#include "lundump.h" + +#define DumpVector(b,n,size,D) DumpBlock(b,(n)*(size),D) +#define DumpLiteral(s,D) DumpBlock("" s,(sizeof(s))-1,D) + +typedef struct { + lua_State* L; + lua_Chunkwriter write; + void* data; +} DumpState; + +static void DumpBlock(const void* b, size_t size, DumpState* D) +{ + lua_unlock(D->L); + (*D->write)(D->L,b,size,D->data); + lua_lock(D->L); +} + +static void DumpByte(int y, DumpState* D) +{ + char x=(char)y; + DumpBlock(&x,sizeof(x),D); +} + +static void DumpInt(int x, DumpState* D) +{ + DumpBlock(&x,sizeof(x),D); +} + +static void DumpSize(size_t x, DumpState* D) +{ + DumpBlock(&x,sizeof(x),D); +} + +static void DumpNumber(lua_Number x, DumpState* D) +{ + DumpBlock(&x,sizeof(x),D); +} + +static void DumpString(TString* s, DumpState* D) +{ + if (s==NULL || getstr(s)==NULL) + DumpSize(0,D); + else + { + size_t size=s->tsv.len+1; /* include trailing '\0' */ + DumpSize(size,D); + DumpBlock(getstr(s),size,D); + } +} + +static void DumpCode(const Proto* f, DumpState* D) +{ + DumpInt(f->sizecode,D); + DumpVector(f->code,f->sizecode,sizeof(*f->code),D); +} + +static void DumpLocals(const Proto* f, DumpState* D) +{ + int i,n=f->sizelocvars; + DumpInt(n,D); + for (i=0; ilocvars[i].varname,D); + DumpInt(f->locvars[i].startpc,D); + DumpInt(f->locvars[i].endpc,D); + } +} + +static void DumpLines(const Proto* f, DumpState* D) +{ + DumpInt(f->sizelineinfo,D); + DumpVector(f->lineinfo,f->sizelineinfo,sizeof(*f->lineinfo),D); +} + +static void DumpUpvalues(const Proto* f, DumpState* D) +{ + int i,n=f->sizeupvalues; + DumpInt(n,D); + for (i=0; iupvalues[i],D); +} + +static void DumpFunction(const Proto* f, const TString* p, DumpState* D); + +static void DumpConstants(const Proto* f, DumpState* D) +{ + int i,n; + DumpInt(n=f->sizek,D); + for (i=0; ik[i]; + DumpByte(ttype(o),D); + switch (ttype(o)) + { + case LUA_TNUMBER: + DumpNumber(nvalue(o),D); + break; + case LUA_TSTRING: + DumpString(tsvalue(o),D); + break; + case LUA_TNIL: + break; + default: + lua_assert(0); /* cannot happen */ + break; + } + } + DumpInt(n=f->sizep,D); + for (i=0; ip[i],f->source,D); +} + +static void DumpFunction(const Proto* f, const TString* p, DumpState* D) +{ + DumpString((f->source==p) ? NULL : f->source,D); + DumpInt(f->lineDefined,D); + DumpByte(f->nups,D); + DumpByte(f->numparams,D); + DumpByte(f->is_vararg,D); + DumpByte(f->maxstacksize,D); + DumpLines(f,D); + DumpLocals(f,D); + DumpUpvalues(f,D); + DumpConstants(f,D); + DumpCode(f,D); +} + +static void DumpHeader(DumpState* D) +{ + DumpLiteral(LUA_SIGNATURE,D); + DumpByte(VERSION,D); + DumpByte(luaU_endianness(),D); + DumpByte(sizeof(int),D); + DumpByte(sizeof(size_t),D); + DumpByte(sizeof(Instruction),D); + DumpByte(SIZE_OP,D); + DumpByte(SIZE_A,D); + DumpByte(SIZE_B,D); + DumpByte(SIZE_C,D); + DumpByte(sizeof(lua_Number),D); + DumpNumber(TEST_NUMBER,D); +} + +/* +** dump function as precompiled chunk +*/ +void luaU_dump (lua_State* L, const Proto* Main, lua_Chunkwriter w, void* data) +{ + DumpState D; + D.L=L; + D.write=w; + D.data=data; + DumpHeader(&D); + DumpFunction(Main,NULL,&D); +} + diff --git a/stepmania/src/lua-5.0/src/lfunc.c b/stepmania/src/lua-5.0/src/lfunc.c new file mode 100644 index 0000000000..a019e64732 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lfunc.c @@ -0,0 +1,135 @@ +/* +** $Id$ +** Auxiliary functions to manipulate prototypes and closures +** See Copyright Notice in lua.h +*/ + + +#include + +#define lfunc_c + +#include "lua.h" + +#include "lfunc.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" + + +#define sizeCclosure(n) (cast(int, sizeof(CClosure)) + \ + cast(int, sizeof(TObject)*((n)-1))) + +#define sizeLclosure(n) (cast(int, sizeof(LClosure)) + \ + cast(int, sizeof(TObject *)*((n)-1))) + + + +Closure *luaF_newCclosure (lua_State *L, int nelems) { + Closure *c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems))); + luaC_link(L, valtogco(c), LUA_TFUNCTION); + c->c.isC = 1; + c->c.nupvalues = cast(lu_byte, nelems); + return c; +} + + +Closure *luaF_newLclosure (lua_State *L, int nelems, TObject *e) { + Closure *c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems))); + luaC_link(L, valtogco(c), LUA_TFUNCTION); + c->l.isC = 0; + c->l.g = *e; + c->l.nupvalues = cast(lu_byte, nelems); + return c; +} + + +UpVal *luaF_findupval (lua_State *L, StkId level) { + GCObject **pp = &L->openupval; + UpVal *p; + UpVal *v; + while ((p = ngcotouv(*pp)) != NULL && p->v >= level) { + if (p->v == level) return p; + pp = &p->next; + } + v = luaM_new(L, UpVal); /* not found: create a new one */ + v->tt = LUA_TUPVAL; + v->marked = 1; /* open upvalues should not be collected */ + v->v = level; /* current value lives in the stack */ + v->next = *pp; /* chain it in the proper position */ + *pp = valtogco(v); + return v; +} + + +void luaF_close (lua_State *L, StkId level) { + UpVal *p; + while ((p = ngcotouv(L->openupval)) != NULL && p->v >= level) { + setobj(&p->value, p->v); /* save current value (write barrier) */ + p->v = &p->value; /* now current value lives here */ + L->openupval = p->next; /* remove from `open' list */ + luaC_link(L, valtogco(p), LUA_TUPVAL); + } +} + + +Proto *luaF_newproto (lua_State *L) { + Proto *f = luaM_new(L, Proto); + luaC_link(L, valtogco(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->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, TObject); + 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_freelem(L, f); +} + + +void luaF_freeclosure (lua_State *L, Closure *c) { + int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) : + sizeLclosure(c->l.nupvalues); + luaM_free(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; isizelocvars && 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 */ +} + diff --git a/stepmania/src/lua-5.0/src/lfunc.h b/stepmania/src/lua-5.0/src/lfunc.h new file mode 100644 index 0000000000..703453a909 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lfunc.h @@ -0,0 +1,25 @@ +/* +** $Id$ +** Auxiliary functions to manipulate prototypes and closures +** See Copyright Notice in lua.h +*/ + +#ifndef lfunc_h +#define lfunc_h + + +#include "lobject.h" + + +Proto *luaF_newproto (lua_State *L); +Closure *luaF_newCclosure (lua_State *L, int nelems); +Closure *luaF_newLclosure (lua_State *L, int nelems, TObject *e); +UpVal *luaF_findupval (lua_State *L, StkId level); +void luaF_close (lua_State *L, StkId level); +void luaF_freeproto (lua_State *L, Proto *f); +void luaF_freeclosure (lua_State *L, Closure *c); + +const char *luaF_getlocalname (const Proto *func, int local_number, int pc); + + +#endif diff --git a/stepmania/src/lua-5.0/src/lgc.c b/stepmania/src/lua-5.0/src/lgc.c new file mode 100644 index 0000000000..5171aeaba6 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lgc.c @@ -0,0 +1,498 @@ +/* +** $Id$ +** Garbage Collector +** See Copyright Notice in lua.h +*/ + +#include + +#define lgc_c + +#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" + + +typedef struct GCState { + GCObject *tmark; /* list of marked objects to be traversed */ + GCObject *wk; /* list of traversed key-weak tables (to be cleared) */ + GCObject *wv; /* list of traversed value-weak tables */ + GCObject *wkv; /* list of traversed key-value weak tables */ + global_State *g; +} GCState; + + +/* +** some userful bit tricks +*/ +#define setbit(x,b) ((x) |= (1<<(b))) +#define resetbit(x,b) ((x) &= cast(lu_byte, ~(1<<(b)))) +#define testbit(x,b) ((x) & (1<<(b))) + +#define unmark(x) resetbit((x)->gch.marked, 0) +#define ismarked(x) ((x)->gch.marked & ((1<<4)|1)) + +#define stringmark(s) setbit((s)->tsv.marked, 0) + + +#define isfinalized(u) (!testbit((u)->uv.marked, 1)) +#define markfinalized(u) resetbit((u)->uv.marked, 1) + + +#define KEYWEAKBIT 1 +#define VALUEWEAKBIT 2 +#define KEYWEAK (1<gch.marked, 0); /* mark object */ + switch (o->gch.tt) { + case LUA_TUSERDATA: { + markvalue(st, gcotou(o)->uv.metatable); + break; + } + case LUA_TFUNCTION: { + gcotocl(o)->c.gclist = st->tmark; + st->tmark = o; + break; + } + case LUA_TTABLE: { + gcotoh(o)->gclist = st->tmark; + st->tmark = o; + break; + } + case LUA_TTHREAD: { + gcototh(o)->gclist = st->tmark; + st->tmark = o; + break; + } + case LUA_TPROTO: { + gcotop(o)->gclist = st->tmark; + st->tmark = o; + break; + } + default: lua_assert(o->gch.tt == LUA_TSTRING); + } +} + + +static void marktmu (GCState *st) { + GCObject *u; + for (u = st->g->tmudata; u; u = u->gch.next) { + unmark(u); /* may be marked, if left from previous GC */ + reallymarkobject(st, u); + } +} + + +/* move `dead' udata that need finalization to list `tmudata' */ +size_t luaC_separateudata (lua_State *L) { + size_t deadmem = 0; + GCObject **p = &G(L)->rootudata; + GCObject *curr; + GCObject *collected = NULL; /* to collect udata with gc event */ + GCObject **lastcollected = &collected; + while ((curr = *p) != NULL) { + lua_assert(curr->gch.tt == LUA_TUSERDATA); + if (ismarked(curr) || isfinalized(gcotou(curr))) + p = &curr->gch.next; /* don't bother with them */ + + else if (fasttm(L, gcotou(curr)->uv.metatable, TM_GC) == NULL) { + markfinalized(gcotou(curr)); /* don't need finalization */ + p = &curr->gch.next; + } + else { /* must call its gc method */ + deadmem += sizeudata(gcotou(curr)->uv.len); + *p = curr->gch.next; + curr->gch.next = NULL; /* link `curr' at the end of `collected' list */ + *lastcollected = curr; + lastcollected = &curr->gch.next; + } + } + /* insert collected udata with gc event into `tmudata' list */ + *lastcollected = G(L)->tmudata; + G(L)->tmudata = collected; + return deadmem; +} + + +static void removekey (Node *n) { + setnilvalue(gval(n)); /* remove corresponding value ... */ + if (iscollectable(gkey(n))) + setttype(gkey(n), LUA_TNONE); /* dead key; remove it */ +} + + +static void traversetable (GCState *st, Table *h) { + int i; + int weakkey = 0; + int weakvalue = 0; + const TObject *mode; + markvalue(st, h->metatable); + lua_assert(h->lsizenode || h->node == st->g->dummynode); + mode = gfasttm(st->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? */ + GCObject **weaklist; + h->marked &= ~(KEYWEAK | VALUEWEAK); /* clear bits */ + h->marked |= cast(lu_byte, (weakkey << KEYWEAKBIT) | + (weakvalue << VALUEWEAKBIT)); + weaklist = (weakkey && weakvalue) ? &st->wkv : + (weakkey) ? &st->wk : + &st->wv; + h->gclist = *weaklist; /* must be cleared after GC, ... */ + *weaklist = valtogco(h); /* ... so put in the appropriate list */ + } + } + if (!weakvalue) { + i = h->sizearray; + while (i--) + markobject(st, &h->array[i]); + } + i = sizenode(h); + while (i--) { + Node *n = gnode(h, i); + if (!ttisnil(gval(n))) { + lua_assert(!ttisnil(gkey(n))); + condmarkobject(st, gkey(n), !weakkey); + condmarkobject(st, gval(n), !weakvalue); + } + } +} + + +static void traverseproto (GCState *st, Proto *f) { + int i; + stringmark(f->source); + for (i=0; isizek; i++) { /* mark literal strings */ + if (ttisstring(f->k+i)) + stringmark(tsvalue(f->k+i)); + } + for (i=0; isizeupvalues; i++) /* mark upvalue names */ + stringmark(f->upvalues[i]); + for (i=0; isizep; i++) /* mark nested protos */ + markvalue(st, f->p[i]); + for (i=0; isizelocvars; i++) /* mark local-variable names */ + stringmark(f->locvars[i].varname); + lua_assert(luaG_checkcode(f)); +} + + + +static void traverseclosure (GCState *st, Closure *cl) { + if (cl->c.isC) { + int i; + for (i=0; ic.nupvalues; i++) /* mark its upvalues */ + markobject(st, &cl->c.upvalue[i]); + } + else { + int i; + lua_assert(cl->l.nupvalues == cl->l.p->nups); + markvalue(st, hvalue(&cl->l.g)); + markvalue(st, cl->l.p); + for (i=0; il.nupvalues; i++) { /* mark its upvalues */ + UpVal *u = cl->l.upvals[i]; + if (!u->marked) { + markobject(st, &u->value); + u->marked = 1; + } + } + } +} + + +static void checkstacksizes (lua_State *L, StkId max) { + int used = L->ci - L->base_ci; /* number of `ci' in use */ + if (4*used < L->size_ci && 2*BASIC_CI_SIZE < L->size_ci) + luaD_reallocCI(L, L->size_ci/2); /* still big enough... */ + else condhardstacktests(luaD_reallocCI(L, L->size_ci)); + used = max - L->stack; /* part of stack in use */ + if (4*used < L->stacksize && 2*(BASIC_STACK_SIZE+EXTRA_STACK) < L->stacksize) + luaD_reallocstack(L, L->stacksize/2); /* still big enough... */ + else condhardstacktests(luaD_reallocstack(L, L->stacksize)); +} + + +static void traversestack (GCState *st, lua_State *L1) { + StkId o, lim; + CallInfo *ci; + markobject(st, gt(L1)); + lim = L1->top; + for (ci = L1->base_ci; ci <= L1->ci; ci++) { + lua_assert(ci->top <= L1->stack_last); + lua_assert(ci->state & (CI_C | CI_HASFRAME | CI_SAVEDPC)); + if (lim < ci->top) + lim = ci->top; + } + for (o = L1->stack; o < L1->top; o++) + markobject(st, o); + for (; o <= lim; o++) + setnilvalue(o); + checkstacksizes(L1, lim); +} + + +static void propagatemarks (GCState *st) { + while (st->tmark) { /* traverse marked objects */ + switch (st->tmark->gch.tt) { + case LUA_TTABLE: { + Table *h = gcotoh(st->tmark); + st->tmark = h->gclist; + traversetable(st, h); + break; + } + case LUA_TFUNCTION: { + Closure *cl = gcotocl(st->tmark); + st->tmark = cl->c.gclist; + traverseclosure(st, cl); + break; + } + case LUA_TTHREAD: { + lua_State *th = gcototh(st->tmark); + st->tmark = th->gclist; + traversestack(st, th); + break; + } + case LUA_TPROTO: { + Proto *p = gcotop(st->tmark); + st->tmark = p->gclist; + traverseproto(st, p); + break; + } + default: lua_assert(0); + } + } +} + + +static int valismarked (const TObject *o) { + if (ttisstring(o)) + stringmark(tsvalue(o)); /* strings are `values', so are never weak */ + return !iscollectable(o) || testbit(o->value.gc->gch.marked, 0); +} + + +/* +** clear collected keys from weaktables +*/ +static void cleartablekeys (GCObject *l) { + while (l) { + Table *h = gcotoh(l); + int i = sizenode(h); + lua_assert(h->marked & KEYWEAK); + while (i--) { + Node *n = gnode(h, i); + if (!valismarked(gkey(n))) /* key was collected? */ + removekey(n); /* remove entry from table */ + } + l = h->gclist; + } +} + + +/* +** clear collected values from weaktables +*/ +static void cleartablevalues (GCObject *l) { + while (l) { + Table *h = gcotoh(l); + int i = h->sizearray; + lua_assert(h->marked & VALUEWEAK); + while (i--) { + TObject *o = &h->array[i]; + if (!valismarked(o)) /* value was collected? */ + setnilvalue(o); /* remove value */ + } + i = sizenode(h); + while (i--) { + Node *n = gnode(h, i); + if (!valismarked(gval(n))) /* value was collected? */ + removekey(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, gcotop(o)); break; + case LUA_TFUNCTION: luaF_freeclosure(L, gcotocl(o)); break; + case LUA_TUPVAL: luaM_freelem(L, gcotouv(o)); break; + case LUA_TTABLE: luaH_free(L, gcotoh(o)); break; + case LUA_TTHREAD: { + lua_assert(gcototh(o) != L && gcototh(o) != G(L)->mainthread); + luaE_freethread(L, gcototh(o)); + break; + } + case LUA_TSTRING: { + luaM_free(L, o, sizestring(gcotots(o)->tsv.len)); + break; + } + case LUA_TUSERDATA: { + luaM_free(L, o, sizeudata(gcotou(o)->uv.len)); + break; + } + default: lua_assert(0); + } +} + + +static int sweeplist (lua_State *L, GCObject **p, int limit) { + GCObject *curr; + int count = 0; /* number of collected items */ + while ((curr = *p) != NULL) { + if (curr->gch.marked > limit) { + unmark(curr); + p = &curr->gch.next; + } + else { + count++; + *p = curr->gch.next; + freeobj(L, curr); + } + } + return count; +} + + +static void sweepstrings (lua_State *L, int all) { + int i; + for (i=0; istrt.size; i++) { /* for each list */ + G(L)->strt.nuse -= sweeplist(L, &G(L)->strt.hash[i], all); + } +} + + +static void checkSizes (lua_State *L, size_t deadmem) { + /* check size of string hash */ + if (G(L)->strt.nuse < cast(ls_nstr, G(L)->strt.size/4) && + G(L)->strt.size > MINSTRTABSIZE*2) + luaS_resize(L, G(L)->strt.size/2); /* table is too big */ + /* check size of buffer */ + if (luaZ_sizebuffer(&G(L)->buff) > LUA_MINBUFFER*2) { /* buffer too big? */ + size_t newsize = luaZ_sizebuffer(&G(L)->buff) / 2; + luaZ_resizebuffer(L, &G(L)->buff, newsize); + } + G(L)->GCthreshold = 2*G(L)->nblocks - deadmem; /* new threshold */ +} + + +static void do1gcTM (lua_State *L, Udata *udata) { + const TObject *tm = fasttm(L, udata->uv.metatable, TM_GC); + if (tm != NULL) { + setobj2s(L->top, tm); + setuvalue(L->top+1, udata); + L->top += 2; + luaD_call(L, L->top - 2, 0); + } +} + + +void luaC_callGCTM (lua_State *L) { + lu_byte oldah = L->allowhook; + L->allowhook = 0; /* stop debug hooks during GC tag methods */ + L->top++; /* reserve space to keep udata while runs its gc method */ + while (G(L)->tmudata != NULL) { + GCObject *o = G(L)->tmudata; + Udata *udata = gcotou(o); + G(L)->tmudata = udata->uv.next; /* remove udata from `tmudata' */ + udata->uv.next = G(L)->rootudata; /* return it to `root' list */ + G(L)->rootudata = o; + setuvalue(L->top - 1, udata); /* keep a reference to it */ + unmark(o); + markfinalized(udata); + do1gcTM(L, udata); + } + L->top--; + L->allowhook = oldah; /* restore hooks */ +} + + +void luaC_sweep (lua_State *L, int all) { + if (all) all = 256; /* larger than any mark */ + sweeplist(L, &G(L)->rootudata, all); + sweepstrings(L, all); + sweeplist(L, &G(L)->rootgc, all); +} + + +/* mark root set */ +static void markroot (GCState *st, lua_State *L) { + global_State *g = st->g; + markobject(st, defaultmeta(L)); + markobject(st, registry(L)); + traversestack(st, g->mainthread); + if (L != g->mainthread) /* another thread is running? */ + markvalue(st, L); /* cannot collect it */ +} + + +static size_t mark (lua_State *L) { + size_t deadmem; + GCState st; + GCObject *wkv; + st.g = G(L); + st.tmark = NULL; + st.wkv = st.wk = st.wv = NULL; + markroot(&st, L); + propagatemarks(&st); /* mark all reachable objects */ + cleartablevalues(st.wkv); + cleartablevalues(st.wv); + wkv = st.wkv; /* keys must be cleared after preserving udata */ + st.wkv = NULL; + st.wv = NULL; + deadmem = luaC_separateudata(L); /* separate userdata to be preserved */ + marktmu(&st); /* mark `preserved' userdata */ + propagatemarks(&st); /* remark, to propagate `preserveness' */ + cleartablekeys(wkv); + /* `propagatemarks' may resuscitate some weak tables; clear them too */ + cleartablekeys(st.wk); + cleartablevalues(st.wv); + cleartablekeys(st.wkv); + cleartablevalues(st.wkv); + return deadmem; +} + + +void luaC_collectgarbage (lua_State *L) { + size_t deadmem = mark(L); + luaC_sweep(L, 0); + checkSizes(L, deadmem); + luaC_callGCTM(L); +} + + +void luaC_link (lua_State *L, GCObject *o, lu_byte tt) { + o->gch.next = G(L)->rootgc; + G(L)->rootgc = o; + o->gch.marked = 0; + o->gch.tt = tt; +} + diff --git a/stepmania/src/lua-5.0/src/lgc.h b/stepmania/src/lua-5.0/src/lgc.h new file mode 100644 index 0000000000..bff16dc891 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lgc.h @@ -0,0 +1,25 @@ +/* +** $Id$ +** Garbage Collector +** See Copyright Notice in lua.h +*/ + +#ifndef lgc_h +#define lgc_h + + +#include "lobject.h" + + +#define luaC_checkGC(L) { lua_assert(!(L->ci->state & CI_CALLING)); \ + if (G(L)->nblocks >= G(L)->GCthreshold) luaC_collectgarbage(L); } + + +size_t luaC_separateudata (lua_State *L); +void luaC_callGCTM (lua_State *L); +void luaC_sweep (lua_State *L, int all); +void luaC_collectgarbage (lua_State *L); +void luaC_link (lua_State *L, GCObject *o, lu_byte tt); + + +#endif diff --git a/stepmania/src/lua-5.0/src/lib/LibLuaLib.dsp b/stepmania/src/lua-5.0/src/lib/LibLuaLib.dsp new file mode 100644 index 0000000000..efb3cb0dce --- /dev/null +++ b/stepmania/src/lua-5.0/src/lib/LibLuaLib.dsp @@ -0,0 +1,127 @@ +# Microsoft Developer Studio Project File - Name="LibLuaLib" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 60000 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Static Library" 0x0104 + +CFG=LibLuaLib - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "LibLuaLib.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "LibLuaLib.mak" CFG="LibLuaLib - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "LibLuaLib - Win32 Release" (based on "Win32 (x86) Static Library") +!MESSAGE "LibLuaLib - Win32 Debug" (based on "Win32 (x86) Static Library") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +RSC=rc.exe + +!IF "$(CFG)" == "LibLuaLib - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "..\..\obj" +# PROP Intermediate_Dir "..\..\obj" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c +# ADD CPP /nologo /MD /W4 /GX /O2 /I ".." /I "..\..\include" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /FD /c +# SUBTRACT CPP /YX +# ADD BASE RSC /l 0x40c /d "NDEBUG" +# ADD RSC /l 0x409 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LIB32=link.exe -lib +# ADD BASE LIB32 /nologo +# ADD LIB32 /nologo /out:"..\..\lib\LibLuaLib.lib" + +!ELSEIF "$(CFG)" == "LibLuaLib - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "..\..\dobj" +# PROP Intermediate_Dir "..\..\dobj" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c +# ADD CPP /nologo /MDd /W4 /Gm /GX /Zi /Od /I ".." /I "..\..\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /FD /GZ /c +# SUBTRACT CPP /YX +# ADD BASE RSC /l 0x40c /d "_DEBUG" +# ADD RSC /l 0x409 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LIB32=link.exe -lib +# ADD BASE LIB32 /nologo +# ADD LIB32 /nologo /out:"..\..\lib\LibLuaLib.lib" + +!ENDIF + +# Begin Target + +# Name "LibLuaLib - Win32 Release" +# Name "LibLuaLib - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "c" +# Begin Source File + +SOURCE=.\lauxlib.c +# End Source File +# Begin Source File + +SOURCE=.\lbaselib.c +# End Source File +# Begin Source File + +SOURCE=.\ldblib.c +# End Source File +# Begin Source File + +SOURCE=.\liolib.c +# ADD CPP /D USE_POPEN=1 /D popen=_popen /D pclose=_pclose +# End Source File +# Begin Source File + +SOURCE=.\lmathlib.c +# End Source File +# Begin Source File + +SOURCE=.\loadlib.c +# End Source File +# Begin Source File + +SOURCE=.\lstrlib.c +# End Source File +# Begin Source File + +SOURCE=.\ltablib.c +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h" +# End Group +# End Target +# End Project diff --git a/stepmania/src/lua-5.0/src/lib/LibLuaLib.vcproj b/stepmania/src/lua-5.0/src/lib/LibLuaLib.vcproj new file mode 100644 index 0000000000..d38f4ea16e --- /dev/null +++ b/stepmania/src/lua-5.0/src/lib/LibLuaLib.vcproj @@ -0,0 +1,144 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/stepmania/src/lua-5.0/src/lib/lauxlib.c b/stepmania/src/lua-5.0/src/lib/lauxlib.c new file mode 100644 index 0000000000..fcff8d0bc4 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lib/lauxlib.c @@ -0,0 +1,591 @@ +/* +** $Id$ +** Auxiliary functions for building Lua libraries +** See Copyright Notice in lua.h +*/ + + +#include +#include +#include +#include +#include + + +/* This file uses only the official API of Lua. +** Any function declared here could be written as an application function. +*/ + +#define lauxlib_c + +#include "lua.h" + +#include "lauxlib.h" + + +/* number of prereserved references (for internal use) */ +#define RESERVED_REFS 2 + +/* reserved references */ +#define FREELIST_REF 1 /* free list of references */ +#define ARRAYSIZE_REF 2 /* array sizes */ + + +/* 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; + lua_getstack(L, 0, &ar); + 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 `%s' on bad self (%s)", ar.name, extramsg); + } + if (ar.name == NULL) + ar.name = "?"; + return luaL_error(L, "bad argument #%d to `%s' (%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, lua_typename(L, lua_type(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, "Snl", &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_findstring (const char *name, const char *const list[]) { + int i; + for (i=0; list[i]; i++) + if (strcmp(list[i], name) == 0) + return i; + return -1; /* name not found */ +} + + +LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) { + lua_pushstring(L, tname); + lua_rawget(L, LUA_REGISTRYINDEX); /* 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_pushstring(L, tname); + lua_pushvalue(L, -2); + lua_rawset(L, LUA_REGISTRYINDEX); /* registry.name = metatable */ + lua_pushvalue(L, -1); + lua_pushstring(L, tname); + lua_rawset(L, LUA_REGISTRYINDEX); /* registry[metatable] = name */ + return 1; +} + + +LUALIB_API void luaL_getmetatable (lua_State *L, const char *tname) { + lua_pushstring(L, tname); + lua_rawget(L, LUA_REGISTRYINDEX); +} + + +LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) { + const char *tn; + if (!lua_getmetatable(L, ud)) return NULL; /* no metatable? */ + lua_rawget(L, LUA_REGISTRYINDEX); /* get registry[metatable] */ + tn = lua_tostring(L, -1); + if (tn && (strcmp(tn, tname) == 0)) { + lua_pop(L, 1); + return lua_touserdata(L, ud); + } + else { + lua_pop(L, 1); + return NULL; + } +} + + +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_tostring(L, narg); + if (!s) tag_error(L, narg, LUA_TSTRING); + if (len) *len = lua_strlen(L, narg); + 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) { + if (lua_isnoneornil(L, narg)) return def; + else return luaL_checknumber(L, narg); +} + + +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_openlib (lua_State *L, const char *libname, + const luaL_reg *l, int nup) { + if (libname) { + lua_pushstring(L, libname); + lua_gettable(L, LUA_GLOBALSINDEX); /* check whether lib already exists */ + if (lua_isnil(L, -1)) { /* no? */ + lua_pop(L, 1); + lua_newtable(L); /* create it */ + lua_pushstring(L, libname); + lua_pushvalue(L, -2); + lua_settable(L, LUA_GLOBALSINDEX); /* register it with given name */ + } + lua_insert(L, -(nup+1)); /* move library table to below upvalues */ + } + for (; l->name; l++) { + int i; + lua_pushstring(L, l->name); + for (i=0; ifunc, nup); + lua_settable(L, -(nup+3)); + } + lua_pop(L, nup); /* remove upvalues */ +} + + + +/* +** {====================================================== +** getn-setn: size for arrays +** ======================================================= +*/ + +static int checkint (lua_State *L, int topop) { + int n = (int)lua_tonumber(L, -1); + if (n == 0 && !lua_isnumber(L, -1)) n = -1; + lua_pop(L, topop); + return n; +} + + +static void getsizes (lua_State *L) { + lua_rawgeti(L, LUA_REGISTRYINDEX, ARRAYSIZE_REF); + 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, "__mode"); + lua_pushliteral(L, "k"); + lua_rawset(L, -3); /* metatable(N).__mode = "k" */ + lua_pushvalue(L, -1); + lua_rawseti(L, LUA_REGISTRYINDEX, ARRAYSIZE_REF); /* store in register */ + } +} + + +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_pushnumber(L, (lua_Number)n); + lua_rawset(L, t); + } + else { /* use `sizes' */ + getsizes(L); + lua_pushvalue(L, t); + lua_pushnumber(L, (lua_Number)n); + lua_rawset(L, -3); /* sizes[t] = n */ + lua_pop(L, 1); /* remove `sizes' */ + } +} + + +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; + for (n = 1; ; n++) { /* else must count elements */ + lua_rawgeti(L, t, n); + if (lua_isnil(L, -1)) break; + lua_pop(L, 1); + } + lua_pop(L, 1); + return n - 1; +} + +/* }====================================================== */ + + + +/* +** {====================================================== +** 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_putchar(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 = lua_strlen(L, -1); + if (vl <= bufffree(B)) { /* fit into buffer? */ + memcpy(B->p, lua_tostring(L, -1), 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_tonumber(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 = luaL_getn(L, t); + if (ref < RESERVED_REFS) + ref = RESERVED_REFS; /* skip reserved references */ + ref++; /* create new reference */ + luaL_setn(L, t, ref); + } + 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_pushnumber(L, (lua_Number)ref); + lua_rawseti(L, t, FREELIST_REF); /* t[FREELIST_REF] = ref */ + } +} + + + +/* +** {====================================================== +** Load functions +** ======================================================= +*/ + +typedef struct LoadF { + 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 (feof(lf->f)) return NULL; + *size = fread(lf->buff, 1, LUAL_BUFFERSIZE, lf->f); + return (*size > 0) ? lf->buff : NULL; +} + + +static int errfile (lua_State *L, int fnameindex) { + const char *filename = lua_tostring(L, fnameindex) + 1; + lua_pushfstring(L, "cannot read %s: %s", filename, strerror(errno)); + 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 */ + 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, fnameindex); /* unable to open file */ + c = ungetc(getc(lf.f), lf.f); + if (!(isspace(c) || isprint(c)) && lf.f != stdin) { /* binary file? */ + fclose(lf.f); + lf.f = fopen(filename, "rb"); /* reopen in binary mode */ + if (lf.f == NULL) return errfile(L, fnameindex); /* unable to reopen file */ + } + status = lua_load(L, getF, &lf, lua_tostring(L, -1)); + readstatus = ferror(lf.f); + if (lf.f != stdin) fclose(lf.f); /* close file (even in case of errors) */ + if (readstatus) { + lua_settop(L, fnameindex); /* ignore results from `lua_load' */ + return errfile(L, 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); +} + +/* }====================================================== */ + + +/* +** {====================================================== +** compatibility code +** ======================================================= +*/ + + +static void callalert (lua_State *L, int status) { + if (status != 0) { + lua_getglobal(L, "_ALERT"); + if (lua_isfunction(L, -1)) { + lua_insert(L, -2); + lua_call(L, 1, 0); + } + else { /* no _ALERT function; print it on stderr */ + fprintf(stderr, "%s\n", lua_tostring(L, -2)); + lua_pop(L, 2); /* remove error message and _ALERT */ + } + } +} + + +static int aux_do (lua_State *L, int status) { + if (status == 0) { /* parse OK? */ + status = lua_pcall(L, 0, LUA_MULTRET, 0); /* call main */ + } + callalert(L, status); + return status; +} + + +LUALIB_API int lua_dofile (lua_State *L, const char *filename) { + return aux_do(L, luaL_loadfile(L, filename)); +} + + +LUALIB_API int lua_dobuffer (lua_State *L, const char *buff, size_t size, + const char *name) { + return aux_do(L, luaL_loadbuffer(L, buff, size, name)); +} + + +LUALIB_API int lua_dostring (lua_State *L, const char *str) { + return lua_dobuffer(L, str, strlen(str), str); +} + +/* }====================================================== */ diff --git a/stepmania/src/lua-5.0/src/lib/lbaselib.c b/stepmania/src/lua-5.0/src/lib/lbaselib.c new file mode 100644 index 0000000000..b9d8d2a223 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lib/lbaselib.c @@ -0,0 +1,677 @@ +/* +** $Id$ +** Basic library +** See Copyright Notice in lua.h +*/ + + + +#include +#include +#include +#include + +#define lbaselib_c + +#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, "`tostring' must return a string to `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); + luaL_checkany(L, 1); + if (!lua_isstring(L, 1) || level == 0) + lua_pushvalue(L, 1); /* propagate error message without changes */ + else { /* 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) { + if (lua_isfunction(L, 1)) lua_pushvalue(L, 1); + else { + lua_Debug ar; + int level = luaL_optint(L, 1, 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 aux_getfenv (lua_State *L) { + lua_getfenv(L, -1); + lua_pushliteral(L, "__fenv"); + lua_rawget(L, -2); + return !lua_isnil(L, -1); +} + + +static int luaB_getfenv (lua_State *L) { + getfunc(L); + if (!aux_getfenv(L)) /* __fenv not defined? */ + lua_pop(L, 1); /* remove it, to return real environment */ + return 1; +} + + +static int luaB_setfenv (lua_State *L) { + luaL_checktype(L, 2, LUA_TTABLE); + getfunc(L); + if (aux_getfenv(L)) /* __fenv defined? */ + luaL_error(L, "`setfenv' cannot change a protected environment"); + else + lua_pop(L, 2); /* remove __fenv and real environment table */ + lua_pushvalue(L, 2); + if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0) + lua_replace(L, LUA_GLOBALSINDEX); + else if (lua_setfenv(L, -2) == 0) + luaL_error(L, "`setfenv' cannot change environment of given function"); + return 0; +} + + +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_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_rawset(L, 1); + return 1; +} + + +static int luaB_gcinfo (lua_State *L) { + lua_pushnumber(L, (lua_Number)lua_getgccount(L)); + lua_pushnumber(L, (lua_Number)lua_getgcthreshold(L)); + return 2; +} + + +static int luaB_collectgarbage (lua_State *L) { + lua_setgcthreshold(L, luaL_optint(L, 1, 0)); + return 0; +} + + +static int luaB_type (lua_State *L) { + luaL_checkany(L, 1); + lua_pushstring(L, lua_typename(L, lua_type(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_pushliteral(L, "next"); + lua_rawget(L, LUA_GLOBALSINDEX); /* return generator, */ + lua_pushvalue(L, 1); /* state, */ + lua_pushnil(L); /* and initial value */ + return 3; +} + + +static int luaB_ipairs (lua_State *L) { + lua_Number i = lua_tonumber(L, 2); + luaL_checktype(L, 1, LUA_TTABLE); + if (i == 0 && lua_isnone(L, 2)) { /* `for' start? */ + lua_pushliteral(L, "ipairs"); + lua_rawget(L, LUA_GLOBALSINDEX); /* return generator, */ + lua_pushvalue(L, 1); /* state, */ + lua_pushnumber(L, 0); /* and initial value */ + return 3; + } + else { /* `for' step */ + i++; /* next value */ + lua_pushnumber(L, i); + lua_rawgeti(L, 1, (int)i); + return (lua_isnil(L, -1)) ? 0 : 2; + } +} + + +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)); +} + + +static int luaB_dofile (lua_State *L) { + const char *fname = luaL_optstring(L, 1, NULL); + int n = lua_gettop(L); + int status = luaL_loadfile(L, fname); + if (status != 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!")); + lua_settop(L, 1); + return 1; +} + + +static int luaB_unpack (lua_State *L) { + int n, i; + luaL_checktype(L, 1, LUA_TTABLE); + n = luaL_getn(L, 1); + luaL_checkstack(L, n, "table too big to unpack"); + for (i=1; i<=n; i++) /* push arg[1...n] */ + lua_rawgeti(L, 1, i); + return n; +} + + +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) { + char buff[128]; + 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)); + return 1; + case LUA_TSTRING: + lua_pushvalue(L, 1); + return 1; + case LUA_TBOOLEAN: + lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false")); + return 1; + case LUA_TTABLE: + sprintf(buff, "table: %p", lua_topointer(L, 1)); + break; + case LUA_TFUNCTION: + sprintf(buff, "function: %p", lua_topointer(L, 1)); + break; + case LUA_TUSERDATA: + case LUA_TLIGHTUSERDATA: + sprintf(buff, "userdata: %p", lua_touserdata(L, 1)); + break; + case LUA_TTHREAD: + sprintf(buff, "thread: %p", (void *)lua_tothread(L, 1)); + break; + case LUA_TNIL: + lua_pushliteral(L, "nil"); + return 1; + } + lua_pushstring(L, buff); + 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; +} + + +/* +** {====================================================== +** `require' function +** ======================================================= +*/ + + +/* name of global that holds table with loaded packages */ +#define REQTAB "_LOADED" + +/* name of global that holds the search path for packages */ +#define LUA_PATH "LUA_PATH" + +#ifndef LUA_PATH_SEP +#define LUA_PATH_SEP ';' +#endif + +#ifndef LUA_PATH_MARK +#define LUA_PATH_MARK '?' +#endif + +#ifndef LUA_PATH_DEFAULT +#define LUA_PATH_DEFAULT "?;?.lua" +#endif + + +static const char *getpath (lua_State *L) { + const char *path; + lua_getglobal(L, LUA_PATH); /* try global variable */ + path = lua_tostring(L, -1); + lua_pop(L, 1); + if (path) return path; +#ifndef _XBOX + path = getenv(LUA_PATH); /* else try environment variable */ + if (path) return path; +#endif + return LUA_PATH_DEFAULT; /* else use default */ +} + + +static const char *pushnextpath (lua_State *L, const char *path) { + const char *l; + if (*path == '\0') return NULL; /* no more paths */ + if (*path == LUA_PATH_SEP) path++; /* skip separator */ + l = strchr(path, LUA_PATH_SEP); /* find next separator */ + if (l == NULL) l = path+strlen(path); + lua_pushlstring(L, path, l - path); /* directory name */ + return l; +} + + +static void pushcomposename (lua_State *L) { + const char *path = lua_tostring(L, -1); + const char *wild; + int n = 1; + while ((wild = strchr(path, LUA_PATH_MARK)) != NULL) { + /* is there stack space for prefix, name, and eventual last sufix? */ + luaL_checkstack(L, 3, "too many marks in a path component"); + lua_pushlstring(L, path, wild - path); /* push prefix */ + lua_pushvalue(L, 1); /* push package name (in place of MARK) */ + path = wild + 1; /* continue after MARK */ + n += 2; + } + lua_pushstring(L, path); /* push last sufix (`n' already includes this) */ + lua_concat(L, n); +} + + +static int luaB_require (lua_State *L) { + const char *path; + int status = LUA_ERRFILE; /* not found (yet) */ + luaL_checkstring(L, 1); + lua_settop(L, 1); + lua_getglobal(L, REQTAB); + if (!lua_istable(L, 2)) return luaL_error(L, "`" REQTAB "' is not a table"); + path = getpath(L); + lua_pushvalue(L, 1); /* check package's name in book-keeping table */ + lua_rawget(L, 2); + if (lua_toboolean(L, -1)) /* is it there? */ + return 1; /* package is already loaded; return its result */ + else { /* must load it */ + while (status == LUA_ERRFILE) { + lua_settop(L, 3); /* reset stack position */ + if ((path = pushnextpath(L, path)) == NULL) break; + pushcomposename(L); + status = luaL_loadfile(L, lua_tostring(L, -1)); /* try to load it */ + } + } + switch (status) { + case 0: { + lua_getglobal(L, "_REQUIREDNAME"); /* save previous name */ + lua_insert(L, -2); /* put it below function */ + lua_pushvalue(L, 1); + lua_setglobal(L, "_REQUIREDNAME"); /* set new name */ + lua_call(L, 0, 1); /* run loaded module */ + lua_insert(L, -2); /* put result below previous name */ + lua_setglobal(L, "_REQUIREDNAME"); /* reset to previous name */ + if (lua_isnil(L, -1)) { /* no/nil return? */ + lua_pushboolean(L, 1); + lua_replace(L, -2); /* replace to true */ + } + lua_pushvalue(L, 1); + lua_pushvalue(L, -2); + lua_rawset(L, 2); /* mark it as loaded */ + return 1; /* return value */ + } + case LUA_ERRFILE: { /* file not found */ + return luaL_error(L, "could not load package `%s' from path `%s'", + lua_tostring(L, 1), getpath(L)); + } + default: { + return luaL_error(L, "error loading package `%s' (%s)", + lua_tostring(L, 1), lua_tostring(L, -1)); + } + } +} + +/* }====================================================== */ + + +static const luaL_reg base_funcs[] = { + {"error", luaB_error}, + {"getmetatable", luaB_getmetatable}, + {"setmetatable", luaB_setmetatable}, + {"getfenv", luaB_getfenv}, + {"setfenv", luaB_setfenv}, + {"next", luaB_next}, + {"ipairs", luaB_ipairs}, + {"pairs", luaB_pairs}, + {"print", luaB_print}, + {"tonumber", luaB_tonumber}, + {"tostring", luaB_tostring}, + {"type", luaB_type}, + {"assert", luaB_assert}, + {"unpack", luaB_unpack}, + {"rawequal", luaB_rawequal}, + {"rawget", luaB_rawget}, + {"rawset", luaB_rawset}, + {"pcall", luaB_pcall}, + {"xpcall", luaB_xpcall}, + {"collectgarbage", luaB_collectgarbage}, + {"gcinfo", luaB_gcinfo}, + {"loadfile", luaB_loadfile}, + {"dofile", luaB_dofile}, + {"loadstring", luaB_loadstring}, + {"require", luaB_require}, + {NULL, NULL} +}; + + +/* +** {====================================================== +** Coroutine library +** ======================================================= +*/ + +static int auxresume (lua_State *L, lua_State *co, int narg) { + int status; + if (!lua_checkstack(co, narg)) + luaL_error(L, "too many arguments to resume"); + lua_xmove(L, co, narg); + status = lua_resume(co, narg); + if (status == 0) { + int nres = lua_gettop(co); + if (!lua_checkstack(L, nres)) + 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_costatus (lua_State *L) { + lua_State *co = lua_tothread(L, 1); + luaL_argcheck(L, co, 1, "coroutine expected"); + if (L == co) lua_pushliteral(L, "running"); + else { + lua_Debug ar; + if (lua_getstack(co, 0, &ar) == 0 && lua_gettop(co) == 0) + lua_pushliteral(L, "dead"); + else + lua_pushliteral(L, "suspended"); + } + return 1; +} + + +static const luaL_reg co_funcs[] = { + {"create", luaB_cocreate}, + {"wrap", luaB_cowrap}, + {"resume", luaB_coresume}, + {"yield", luaB_yield}, + {"status", luaB_costatus}, + {NULL, NULL} +}; + +/* }====================================================== */ + + + +static void base_open (lua_State *L) { + lua_pushliteral(L, "_G"); + lua_pushvalue(L, LUA_GLOBALSINDEX); + luaL_openlib(L, NULL, base_funcs, 0); /* open lib into global table */ + lua_pushliteral(L, "_VERSION"); + lua_pushliteral(L, LUA_VERSION); + lua_rawset(L, -3); /* set global _VERSION */ + /* `newproxy' needs a weaktable as upvalue */ + lua_pushliteral(L, "newproxy"); + lua_newtable(L); /* new table `w' */ + lua_pushvalue(L, -1); /* `w' will be its own metatable */ + lua_setmetatable(L, -2); + lua_pushliteral(L, "__mode"); + lua_pushliteral(L, "k"); + lua_rawset(L, -3); /* metatable(w).__mode = "k" */ + lua_pushcclosure(L, luaB_newproxy, 1); + lua_rawset(L, -3); /* set global `newproxy' */ + lua_rawset(L, -1); /* set global _G */ +} + + +LUALIB_API int luaopen_base (lua_State *L) { + base_open(L); + luaL_openlib(L, LUA_COLIBNAME, co_funcs, 0); + lua_newtable(L); + lua_setglobal(L, REQTAB); + return 0; +} + diff --git a/stepmania/src/lua-5.0/src/lib/ldblib.c b/stepmania/src/lua-5.0/src/lib/ldblib.c new file mode 100644 index 0000000000..fd461660f3 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lib/ldblib.c @@ -0,0 +1,299 @@ +/* +** $Id$ +** Interface from Lua to its debug API +** See Copyright Notice in lua.h +*/ + + +#include +#include +#include + +#define ldblib_c + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + + +static void settabss (lua_State *L, const char *i, const char *v) { + lua_pushstring(L, i); + lua_pushstring(L, v); + lua_rawset(L, -3); +} + + +static void settabsi (lua_State *L, const char *i, int v) { + lua_pushstring(L, i); + lua_pushnumber(L, (lua_Number)v); + lua_rawset(L, -3); +} + + +static int getinfo (lua_State *L) { + lua_Debug ar; + const char *options = luaL_optstring(L, 2, "flnSu"); + if (lua_isnumber(L, 1)) { + if (!lua_getstack(L, (int)(lua_tonumber(L, 1)), &ar)) { + lua_pushnil(L); /* level out of range */ + return 1; + } + } + else if (lua_isfunction(L, 1)) { + lua_pushfstring(L, ">%s", options); + options = lua_tostring(L, -1); + lua_pushvalue(L, 1); + } + else + return luaL_argerror(L, 1, "function or level expected"); + if (!lua_getinfo(L, options, &ar)) + return luaL_argerror(L, 2, "invalid option"); + lua_newtable(L); + for (; *options; options++) { + switch (*options) { + case 'S': + settabss(L, "source", ar.source); + settabss(L, "short_src", ar.short_src); + settabsi(L, "linedefined", ar.linedefined); + settabss(L, "what", ar.what); + break; + case 'l': + settabsi(L, "currentline", ar.currentline); + break; + case 'u': + settabsi(L, "nups", ar.nups); + break; + case 'n': + settabss(L, "name", ar.name); + settabss(L, "namewhat", ar.namewhat); + break; + case 'f': + lua_pushliteral(L, "func"); + lua_pushvalue(L, -3); + lua_rawset(L, -3); + break; + } + } + return 1; /* return table */ +} + + +static int getlocal (lua_State *L) { + lua_Debug ar; + const char *name; + if (!lua_getstack(L, luaL_checkint(L, 1), &ar)) /* level out of range? */ + return luaL_argerror(L, 1, "level out of range"); + name = lua_getlocal(L, &ar, luaL_checkint(L, 2)); + if (name) { + lua_pushstring(L, name); + lua_pushvalue(L, -2); + return 2; + } + else { + lua_pushnil(L); + return 1; + } +} + + +static int setlocal (lua_State *L) { + lua_Debug ar; + if (!lua_getstack(L, luaL_checkint(L, 1), &ar)) /* level out of range? */ + return luaL_argerror(L, 1, "level out of range"); + luaL_checkany(L, 3); + lua_pushstring(L, lua_setlocal(L, &ar, luaL_checkint(L, 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 getupvalue (lua_State *L) { + return auxupvalue(L, 1); +} + + +static int 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); + if (lua_isfunction(L, -1)) { + lua_pushstring(L, hooknames[(int)ar->event]); + if (ar->currentline >= 0) + lua_pushnumber(L, (lua_Number)ar->currentline); + else lua_pushnil(L); + lua_assert(lua_getinfo(L, "lS", ar)); + lua_call(L, 2, 0); + } + else + lua_pop(L, 1); /* pop result from gettable */ +} + + +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 int sethook (lua_State *L) { + if (lua_isnoneornil(L, 1)) { + lua_settop(L, 1); + lua_sethook(L, NULL, 0, 0); /* turn off hooks */ + } + else { + const char *smask = luaL_checkstring(L, 2); + int count = luaL_optint(L, 3, 0); + luaL_checktype(L, 1, LUA_TFUNCTION); + lua_sethook(L, hookf, makemask(smask, count), count); + } + lua_pushlightuserdata(L, (void *)&KEY_HOOK); + lua_pushvalue(L, 1); + lua_rawset(L, LUA_REGISTRYINDEX); /* set new hook */ + return 0; +} + + +static int gethook (lua_State *L) { + char buff[5]; + int mask = lua_gethookmask(L); + lua_Hook hook = lua_gethook(L); + if (hook != NULL && hook != hookf) /* external hook? */ + lua_pushliteral(L, "external hook"); + else { + lua_pushlightuserdata(L, (void *)&KEY_HOOK); + lua_rawget(L, LUA_REGISTRYINDEX); /* get hook */ + } + lua_pushstring(L, unmakemask(mask, buff)); + lua_pushnumber(L, (lua_Number)lua_gethookcount(L)); + return 3; +} + + +static int 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; + lua_dostring(L, buffer); + 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 errorfb (lua_State *L) { + int level = 1; /* skip level 0 (it's this function) */ + int firstpart = 1; /* still before eventual `...' */ + lua_Debug ar; + if (lua_gettop(L) == 0) + lua_pushliteral(L, ""); + else if (!lua_isstring(L, 1)) return 1; /* no string message */ + else lua_pushliteral(L, "\n"); + lua_pushliteral(L, "stack traceback:"); + while (lua_getstack(L, level++, &ar)) { + if (level > LEVELS1 && firstpart) { + /* no more than `LEVELS2' more levels? */ + if (!lua_getstack(L, level+LEVELS2, &ar)) + level--; /* keep going */ + else { + lua_pushliteral(L, "\n\t..."); /* too many levels */ + while (lua_getstack(L, level+LEVELS2, &ar)) /* find last levels */ + level++; + } + firstpart = 0; + continue; + } + lua_pushliteral(L, "\n\t"); + lua_getinfo(L, "Snl", &ar); + lua_pushfstring(L, "%s:", ar.short_src); + if (ar.currentline > 0) + lua_pushfstring(L, "%d:", ar.currentline); + switch (*ar.namewhat) { + case 'g': /* global */ + case 'l': /* local */ + case 'f': /* field */ + case 'm': /* method */ + lua_pushfstring(L, " in function `%s'", ar.name); + break; + default: { + 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)); + } + lua_concat(L, lua_gettop(L)); + return 1; +} + + +static const luaL_reg dblib[] = { + {"getlocal", getlocal}, + {"getinfo", getinfo}, + {"gethook", gethook}, + {"getupvalue", getupvalue}, + {"sethook", sethook}, + {"setlocal", setlocal}, + {"setupvalue", setupvalue}, + {"debug", debug}, + {"traceback", errorfb}, + {NULL, NULL} +}; + + +LUALIB_API int luaopen_debug (lua_State *L) { + luaL_openlib(L, LUA_DBLIBNAME, dblib, 0); + lua_pushliteral(L, "_TRACEBACK"); + lua_pushcfunction(L, errorfb); + lua_settable(L, LUA_GLOBALSINDEX); + return 1; +} + diff --git a/stepmania/src/lua-5.0/src/lib/liolib.c b/stepmania/src/lua-5.0/src/lib/liolib.c new file mode 100644 index 0000000000..af3d8f9a40 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lib/liolib.c @@ -0,0 +1,750 @@ +/* +** $Id$ +** Standard I/O (and system) library +** See Copyright Notice in lua.h +*/ + + +#include +#include +#include +#include +#include +#include + +#define liolib_c + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + + +/* +** by default, gcc does not get `tmpname' +*/ +#ifndef USE_TMPNAME +#ifdef __GNUC__ +#define USE_TMPNAME 0 +#else +#define USE_TMPNAME 1 +#endif +#endif + + +/* +** by default, posix systems get `popen' +*/ +#ifndef USE_POPEN +#ifdef _POSIX_C_SOURCE +#if _POSIX_C_SOURCE >= 2 +#define USE_POPEN 1 +#endif +#endif +#endif + +#ifndef USE_POPEN +#define USE_POPEN 0 +#endif + + + + +/* +** {====================================================== +** FILE Operations +** ======================================================= +*/ + + +#if !USE_POPEN +#define pclose(f) (-1) +#endif + + +#define FILEHANDLE "FILE*" + +#define IO_INPUT "_input" +#define IO_OUTPUT "_output" + + +static int pushresult (lua_State *L, int i, const char *filename) { + if (i) { + lua_pushboolean(L, 1); + return 1; + } + else { + lua_pushnil(L); + if (filename) + lua_pushfstring(L, "%s: %s", filename, strerror(errno)); + else + lua_pushfstring(L, "%s", strerror(errno)); + lua_pushnumber(L, errno); + return 3; + } +} + + +static FILE **topfile (lua_State *L, int findex) { + FILE **f = (FILE **)luaL_checkudata(L, findex, FILEHANDLE); + if (f == NULL) luaL_argerror(L, findex, "bad file"); + return f; +} + + +static int io_type (lua_State *L) { + FILE **f = (FILE **)luaL_checkudata(L, 1, FILEHANDLE); + if (f == NULL) lua_pushnil(L); + else if (*f == NULL) + lua_pushliteral(L, "closed file"); + else + lua_pushliteral(L, "file"); + return 1; +} + + +static FILE *tofile (lua_State *L, int findex) { + FILE **f = topfile(L, findex); + 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, FILEHANDLE); + lua_setmetatable(L, -2); + return pf; +} + + +/* +** assumes that top of the stack is the `io' library, and next is +** the `io' metatable +*/ +static void registerfile (lua_State *L, FILE *f, const char *name, + const char *impname) { + lua_pushstring(L, name); + *newfile(L) = f; + if (impname) { + lua_pushstring(L, impname); + lua_pushvalue(L, -2); + lua_settable(L, -6); /* metatable[impname] = file */ + } + lua_settable(L, -3); /* io[name] = file */ +} + + +static int aux_close (lua_State *L) { + FILE *f = tofile(L, 1); + if (f == stdin || f == stdout || f == stderr) + return 0; /* file cannot be closed */ + else { + int ok = (pclose(f) != -1) || (fclose(f) == 0); + if (ok) + *(FILE **)lua_touserdata(L, 1) = NULL; /* mark file as closed */ + return ok; + } +} + + +static int io_close (lua_State *L) { + if (lua_isnone(L, 1) && lua_type(L, lua_upvalueindex(1)) == LUA_TTABLE) { + lua_pushstring(L, IO_OUTPUT); + lua_rawget(L, lua_upvalueindex(1)); + } + return pushresult(L, aux_close(L), NULL); +} + + +static int io_gc (lua_State *L) { + FILE **f = topfile(L, 1); + if (*f != NULL) /* ignore closed files */ + aux_close(L); + return 0; +} + + +static int io_tostring (lua_State *L) { + char buff[128]; + FILE **f = topfile(L, 1); + if (*f == NULL) + strcpy(buff, "closed"); + else + sprintf(buff, "%p", lua_touserdata(L, 1)); + lua_pushfstring(L, "file (%s)", buff); + 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; +} + + +static int io_popen (lua_State *L) { +#if !USE_POPEN + luaL_error(L, "`popen' not supported"); + return 0; +#else + const char *filename = luaL_checkstring(L, 1); + const char *mode = luaL_optstring(L, 2, "r"); + FILE **pf = newfile(L); + *pf = popen(filename, mode); + return (*pf == NULL) ? pushresult(L, 0, filename) : 1; +#endif +} + + +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, const char *name) { + lua_pushstring(L, name); + lua_rawget(L, lua_upvalueindex(1)); + return tofile(L, -1); +} + + +static int g_iofile (lua_State *L, const char *name, const char *mode) { + if (!lua_isnoneornil(L, 1)) { + const char *filename = lua_tostring(L, 1); + lua_pushstring(L, name); + if (filename) { + FILE **pf = newfile(L); + *pf = fopen(filename, mode); + if (*pf == NULL) { + lua_pushfstring(L, "%s: %s", filename, strerror(errno)); + luaL_argerror(L, 1, lua_tostring(L, -1)); + } + } + else { + tofile(L, 1); /* check that it's a valid file handle */ + lua_pushvalue(L, 1); + } + lua_rawset(L, lua_upvalueindex(1)); + } + /* return current value */ + lua_pushstring(L, name); + lua_rawget(L, lua_upvalueindex(1)); + 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 close) { + lua_pushliteral(L, FILEHANDLE); + lua_rawget(L, LUA_REGISTRYINDEX); + lua_pushvalue(L, idx); + lua_pushboolean(L, close); /* close/not close file when finished */ + lua_pushcclosure(L, io_readline, 3); +} + + +static int f_lines (lua_State *L) { + tofile(L, 1); /* 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? */ + lua_pushstring(L, IO_INPUT); + lua_rawget(L, lua_upvalueindex(1)); /* will iterate over default input */ + return f_lines(L); + } + else { + const char *filename = luaL_checkstring(L, 1); + FILE **pf = newfile(L); + *pf = fopen(filename, "r"); + luaL_argcheck(L, *pf, 1, strerror(errno)); + 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_strlen(L, -1) > 0); /* check whether read something */ + } + l = strlen(p); + if (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_strlen(L, -1) > 0); +} + + +static int g_read (lua_State *L, FILE *f, int first) { + int nargs = lua_gettop(L) - 1; + int success; + int n; + 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_tonumber(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; + case 'w': /* word */ + return luaL_error(L, "obsolete option `*w' to `read'"); + default: + return luaL_argerror(L, n, "invalid format"); + } + } + } + } + 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, 1), 2); +} + + +static int io_readline (lua_State *L) { + FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(2)); + if (f == NULL) /* file is already closed? */ + luaL_error(L, "file is already closed"); + if (read_line(L, f)) return 1; + else { /* EOF */ + if (lua_toboolean(L, lua_upvalueindex(3))) { /* generator created file? */ + lua_settop(L, 0); + lua_pushvalue(L, lua_upvalueindex(2)); + 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, 1), 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, 1); + int op = luaL_findstring(luaL_optstring(L, 2, "cur"), modenames); + long offset = luaL_optlong(L, 3, 0); + luaL_argcheck(L, op != -1, 2, "invalid mode"); + op = fseek(f, offset, mode[op]); + if (op) + return pushresult(L, 0, NULL); /* error */ + else { + lua_pushnumber(L, ftell(f)); + return 1; + } +} + + +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, 1)) == 0, NULL); +} + + +static const luaL_reg iolib[] = { + {"input", io_input}, + {"output", io_output}, + {"lines", io_lines}, + {"close", io_close}, + {"flush", io_flush}, + {"open", io_open}, + {"popen", io_popen}, + {"read", io_read}, + {"tmpfile", io_tmpfile}, + {"type", io_type}, + {"write", io_write}, + {NULL, NULL} +}; + + +static const luaL_reg flib[] = { + {"flush", f_flush}, + {"read", f_read}, + {"lines", f_lines}, + {"seek", f_seek}, + {"write", f_write}, + {"close", io_close}, + {"__gc", io_gc}, + {"__tostring", io_tostring}, + {NULL, NULL} +}; + + +static void createmeta (lua_State *L) { + luaL_newmetatable(L, FILEHANDLE); /* create new metatable for file handles */ + /* file methods */ + lua_pushliteral(L, "__index"); + lua_pushvalue(L, -2); /* push metatable */ + lua_rawset(L, -3); /* metatable.__index = metatable */ + luaL_openlib(L, NULL, flib, 0); +} + +/* }====================================================== */ + + +/* +** {====================================================== +** Other O.S. Operations +** ======================================================= +*/ + +static int io_execute (lua_State *L) { + lua_pushnumber(L, system(luaL_checkstring(L, 1))); + return 1; +} + + +static int io_remove (lua_State *L) { + const char *filename = luaL_checkstring(L, 1); + return pushresult(L, remove(filename) == 0, filename); +} + + +static int io_rename (lua_State *L) { + const char *fromname = luaL_checkstring(L, 1); + const char *toname = luaL_checkstring(L, 2); + return pushresult(L, rename(fromname, toname) == 0, fromname); +} + + +static int io_tmpname (lua_State *L) { +#if !USE_TMPNAME + luaL_error(L, "`tmpname' not supported"); + return 0; +#else + char buff[L_tmpnam]; + if (tmpnam(buff) != buff) + return luaL_error(L, "unable to generate a unique filename in `tmpname'"); + lua_pushstring(L, buff); + return 1; +#endif +} + + +static int io_getenv (lua_State *L) { + lua_pushstring(L, getenv(luaL_checkstring(L, 1))); /* if NULL push nil */ + return 1; +} + + +static int io_clock (lua_State *L) { + lua_pushnumber(L, ((lua_Number)clock())/(lua_Number)CLOCKS_PER_SEC); + return 1; +} + + +/* +** {====================================================== +** Time/Date operations +** { year=%Y, month=%m, day=%d, hour=%H, min=%M, sec=%S, +** wday=%w+1, yday=%j, isdst=? } +** ======================================================= +*/ + +static void setfield (lua_State *L, const char *key, int value) { + lua_pushstring(L, key); + lua_pushnumber(L, value); + lua_rawset(L, -3); +} + +static void setboolfield (lua_State *L, const char *key, int value) { + lua_pushstring(L, key); + lua_pushboolean(L, value); + lua_rawset(L, -3); +} + +static int getboolfield (lua_State *L, const char *key) { + int res; + lua_pushstring(L, key); + lua_gettable(L, -2); + res = lua_toboolean(L, -1); + lua_pop(L, 1); + return res; +} + + +static int getfield (lua_State *L, const char *key, int d) { + int res; + lua_pushstring(L, key); + lua_gettable(L, -2); + if (lua_isnumber(L, -1)) + res = (int)(lua_tonumber(L, -1)); + else { + if (d == -2) + return luaL_error(L, "field `%s' missing in date table", key); + res = d; + } + lua_pop(L, 1); + return res; +} + + +static int io_date (lua_State *L) { + const char *s = luaL_optstring(L, 1, "%c"); + time_t t = (time_t)(luaL_optnumber(L, 2, -1)); + struct tm *stm; + if (t == (time_t)(-1)) /* no time given? */ + t = time(NULL); /* use current time */ + if (*s == '!') { /* UTC? */ + stm = gmtime(&t); + s++; /* skip `!' */ + } + else + stm = localtime(&t); + if (stm == NULL) /* invalid date? */ + lua_pushnil(L); + else if (strcmp(s, "*t") == 0) { + lua_newtable(L); + setfield(L, "sec", stm->tm_sec); + setfield(L, "min", stm->tm_min); + setfield(L, "hour", stm->tm_hour); + setfield(L, "day", stm->tm_mday); + setfield(L, "month", stm->tm_mon+1); + setfield(L, "year", stm->tm_year+1900); + setfield(L, "wday", stm->tm_wday+1); + setfield(L, "yday", stm->tm_yday+1); + setboolfield(L, "isdst", stm->tm_isdst); + } + else { + char b[256]; + if (strftime(b, sizeof(b), s, stm)) + lua_pushstring(L, b); + else + return luaL_error(L, "`date' format too long"); + } + return 1; +} + + +static int io_time (lua_State *L) { + if (lua_isnoneornil(L, 1)) /* called without args? */ + lua_pushnumber(L, time(NULL)); /* return current time */ + else { + time_t t; + struct tm ts; + luaL_checktype(L, 1, LUA_TTABLE); + lua_settop(L, 1); /* make sure table is at the top */ + ts.tm_sec = getfield(L, "sec", 0); + ts.tm_min = getfield(L, "min", 0); + ts.tm_hour = getfield(L, "hour", 12); + ts.tm_mday = getfield(L, "day", -2); + ts.tm_mon = getfield(L, "month", -2) - 1; + ts.tm_year = getfield(L, "year", -2) - 1900; + ts.tm_isdst = getboolfield(L, "isdst"); + t = mktime(&ts); + if (t == (time_t)(-1)) + lua_pushnil(L); + else + lua_pushnumber(L, t); + } + return 1; +} + + +static int io_difftime (lua_State *L) { + lua_pushnumber(L, difftime((time_t)(luaL_checknumber(L, 1)), + (time_t)(luaL_optnumber(L, 2, 0)))); + return 1; +} + +/* }====================================================== */ + + +static int io_setloc (lua_State *L) { + static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, + LC_NUMERIC, LC_TIME}; + static const char *const catnames[] = {"all", "collate", "ctype", "monetary", + "numeric", "time", NULL}; + const char *l = lua_tostring(L, 1); + int op = luaL_findstring(luaL_optstring(L, 2, "all"), catnames); + luaL_argcheck(L, l || lua_isnoneornil(L, 1), 1, "string expected"); + luaL_argcheck(L, op != -1, 2, "invalid option"); + lua_pushstring(L, setlocale(cat[op], l)); + return 1; +} + + +static int io_exit (lua_State *L) { + exit(luaL_optint(L, 1, EXIT_SUCCESS)); + return 0; /* to avoid warnings */ +} + +static const luaL_reg syslib[] = { + {"clock", io_clock}, + {"date", io_date}, + {"difftime", io_difftime}, + {"execute", io_execute}, + {"exit", io_exit}, + {"getenv", io_getenv}, + {"remove", io_remove}, + {"rename", io_rename}, + {"setlocale", io_setloc}, + {"time", io_time}, + {"tmpname", io_tmpname}, + {NULL, NULL} +}; + +/* }====================================================== */ + + + +LUALIB_API int luaopen_io (lua_State *L) { + luaL_openlib(L, LUA_OSLIBNAME, syslib, 0); + createmeta(L); + lua_pushvalue(L, -1); + luaL_openlib(L, LUA_IOLIBNAME, iolib, 1); + /* put predefined file handles into `io' table */ + registerfile(L, stdin, "stdin", IO_INPUT); + registerfile(L, stdout, "stdout", IO_OUTPUT); + registerfile(L, stderr, "stderr", NULL); + return 1; +} + diff --git a/stepmania/src/lua-5.0/src/lib/lmathlib.c b/stepmania/src/lua-5.0/src/lib/lmathlib.c new file mode 100644 index 0000000000..24e4fc745a --- /dev/null +++ b/stepmania/src/lua-5.0/src/lib/lmathlib.c @@ -0,0 +1,246 @@ +/* +** $Id$ +** Standard mathematical library +** See Copyright Notice in lua.h +*/ + + +#include +#include + +#define lmathlib_c + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + +#undef PI +#define PI (3.14159265358979323846) +#define RADIANS_PER_DEGREE (PI/180.0) + + + +/* +** If you want Lua to operate in degrees (instead of radians), +** define USE_DEGREES +*/ +#ifdef USE_DEGREES +#define FROMRAD(a) ((a)/RADIANS_PER_DEGREE) +#define TORAD(a) ((a)*RADIANS_PER_DEGREE) +#else +#define FROMRAD(a) (a) +#define TORAD(a) (a) +#endif + + +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(TORAD(luaL_checknumber(L, 1)))); + return 1; +} + +static int math_cos (lua_State *L) { + lua_pushnumber(L, cos(TORAD(luaL_checknumber(L, 1)))); + return 1; +} + +static int math_tan (lua_State *L) { + lua_pushnumber(L, tan(TORAD(luaL_checknumber(L, 1)))); + return 1; +} + +static int math_asin (lua_State *L) { + lua_pushnumber(L, FROMRAD(asin(luaL_checknumber(L, 1)))); + return 1; +} + +static int math_acos (lua_State *L) { + lua_pushnumber(L, FROMRAD(acos(luaL_checknumber(L, 1)))); + return 1; +} + +static int math_atan (lua_State *L) { + lua_pushnumber(L, FROMRAD(atan(luaL_checknumber(L, 1)))); + return 1; +} + +static int math_atan2 (lua_State *L) { + lua_pushnumber(L, FROMRAD(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_mod (lua_State *L) { + lua_pushnumber(L, fmod(luaL_checknumber(L, 1), luaL_checknumber(L, 2))); + return 1; +} + +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_pushnumber(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, (int)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, (int)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}, + {"sin", math_sin}, + {"cos", math_cos}, + {"tan", math_tan}, + {"asin", math_asin}, + {"acos", math_acos}, + {"atan", math_atan}, + {"atan2", math_atan2}, + {"ceil", math_ceil}, + {"floor", math_floor}, + {"mod", math_mod}, + {"frexp", math_frexp}, + {"ldexp", math_ldexp}, + {"sqrt", math_sqrt}, + {"min", math_min}, + {"max", math_max}, + {"log", math_log}, + {"log10", math_log10}, + {"exp", math_exp}, + {"deg", math_deg}, + {"pow", math_pow}, + {"rad", math_rad}, + {"random", math_random}, + {"randomseed", math_randomseed}, + {NULL, NULL} +}; + + +/* +** Open math library +*/ +LUALIB_API int luaopen_math (lua_State *L) { + luaL_openlib(L, LUA_MATHLIBNAME, mathlib, 0); + lua_pushliteral(L, "pi"); + lua_pushnumber(L, PI); + lua_settable(L, -3); + lua_pushliteral(L, "__pow"); + lua_pushcfunction(L, math_pow); + lua_settable(L, LUA_GLOBALSINDEX); + return 1; +} + diff --git a/stepmania/src/lua-5.0/src/lib/loadlib.c b/stepmania/src/lua-5.0/src/lib/loadlib.c new file mode 100644 index 0000000000..3b50333959 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lib/loadlib.c @@ -0,0 +1,209 @@ +/* +** $Id$ +** Dynamic library loader for Lua +** See Copyright Notice in lua.h +* +* This Lua library exports a single function, called loadlib, which is +* called from Lua as loadlib(lib,init), where lib is the full name of the +* library to be loaded (including the complete path) and init is the name +* of a function to be called after the library is loaded. Typically, this +* function will register other functions, thus making the complete library +* available to Lua. The init function is *not* automatically called by +* loadlib. Instead, loadlib returns the init function as a Lua function +* that the client can call when it thinks is appropriate. In the case of +* errors, loadlib returns nil and two strings describing the error. +* The first string is supplied by the operating system; it should be +* informative and useful for error messages. The second string is "open", +* "init", or "absent" to identify the error and is meant to be used for +* making decisions without having to look into the first string (whose +* format is system-dependent). +* +* This module contains an implementation of loadlib for Unix systems that +* have dlfcn, an implementation for Windows, and a stub for other systems. +* See the list at the end of this file for some links to available +* implementations of dlfcn and interfaces to other native dynamic loaders +* on top of which loadlib could be implemented. +* +*/ + +#include "lua.h" +#include "lauxlib.h" +#include "lualib.h" + + +#undef LOADLIB + + +#ifdef USE_DLOPEN +#define LOADLIB +/* +* This is an implementation of loadlib based on the dlfcn interface. +* The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD, +* NetBSD, AIX 4.2, HPUX 11, and probably most other Unix flavors, at least +* as an emulation layer on top of native functions. +*/ + +#include + +static int loadlib(lua_State *L) +{ + const char *path=luaL_checkstring(L,1); + const char *init=luaL_checkstring(L,2); + void *lib=dlopen(path,RTLD_NOW); + if (lib!=NULL) + { + lua_CFunction f=(lua_CFunction) dlsym(lib,init); + if (f!=NULL) + { + lua_pushlightuserdata(L,lib); + lua_pushcclosure(L,f,1); + return 1; + } + } + /* else return appropriate error messages */ + lua_pushnil(L); + lua_pushstring(L,dlerror()); + lua_pushstring(L,(lib!=NULL) ? "init" : "open"); + if (lib!=NULL) dlclose(lib); + return 3; +} + +#endif + + + +/* +** In Windows, default is to use dll; otherwise, default is not to use dll +*/ +#ifndef USE_DLL +#if defined(_WIN32) && !defined(_XBOX) +#define USE_DLL 1 +#else +#define USE_DLL 0 +#endif +#endif + + +#if USE_DLL +#define LOADLIB +/* +* This is an implementation of loadlib for Windows using native functions. +*/ + +#ifndef _XBOX +#include +#endif + +static void pusherror(lua_State *L) +{ +#ifndef _XBOX + int error=GetLastError(); + char buffer[128]; + if (FormatMessage(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM, + 0, error, 0, buffer, sizeof(buffer), 0)) + lua_pushstring(L,buffer); + else + lua_pushfstring(L,"system error %d\n",error); +#endif +} + +static int loadlib(lua_State *L) +{ + const char *path=luaL_checkstring(L,1); + const char *init=luaL_checkstring(L,2); + HINSTANCE lib=LoadLibrary(path); + if (lib!=NULL) + { + lua_CFunction f=(lua_CFunction) GetProcAddress(lib,init); + if (f!=NULL) + { + lua_pushlightuserdata(L,lib); + lua_pushcclosure(L,f,1); + return 1; + } + } + lua_pushnil(L); + pusherror(L); + lua_pushstring(L,(lib!=NULL) ? "init" : "open"); + if (lib!=NULL) FreeLibrary(lib); + return 3; +} + +#endif + + + +#ifndef LOADLIB +/* Fallback for other systems */ + +/* +** Those systems support dlopen, so they should have defined USE_DLOPEN. +** The default (no)implementation gives them a special error message. +*/ +#ifdef linux +#define LOADLIB +#endif + +#ifdef sun +#define LOADLIB +#endif + +#ifdef sgi +#define LOADLIB +#endif + +#ifdef BSD +#define LOADLIB +#endif + +#ifdef _WIN32 +#define LOADLIB +#endif + +#ifdef LOADLIB +#undef LOADLIB +#define LOADLIB "`loadlib' not installed (check your Lua configuration)" +#else +#define LOADLIB "`loadlib' not supported" +#endif + +static int loadlib(lua_State *L) +{ + lua_pushnil(L); + lua_pushliteral(L,LOADLIB); + lua_pushliteral(L,"absent"); + return 3; +} +#endif + +LUALIB_API int luaopen_loadlib (lua_State *L) +{ + lua_register(L,"loadlib",loadlib); + return 0; +} + +/* +* Here are some links to available implementations of dlfcn and +* interfaces to other native dynamic loaders on top of which loadlib +* could be implemented. Please send contributions and corrections to us. +* +* AIX +* Starting with AIX 4.2, dlfcn is included in the base OS. +* There is also an emulation package available. +* http://www.faqs.org/faqs/aix-faq/part4/section-21.html +* +* HPUX +* HPUX 11 has dlfcn. For HPUX 10 use shl_*. +* http://www.geda.seul.org/mailinglist/geda-dev37/msg00094.html +* http://www.stat.umn.edu/~luke/xls/projects/dlbasics/dlbasics.html +* +* Macintosh, Windows +* http://www.stat.umn.edu/~luke/xls/projects/dlbasics/dlbasics.html +* +* Mac OS X/Darwin +* http://www.opendarwin.org/projects/dlcompat/ +* +* GLIB has wrapper code for BeOS, OS2, Unix and Windows +* http://cvs.gnome.org/lxr/source/glib/gmodule/ +* +*/ diff --git a/stepmania/src/lua-5.0/src/lib/lstrlib.c b/stepmania/src/lua-5.0/src/lib/lstrlib.c new file mode 100644 index 0000000000..c48c3bb7c3 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lib/lstrlib.c @@ -0,0 +1,770 @@ +/* +** $Id$ +** Standard library for string operations and pattern-matching +** See Copyright Notice in lua.h +*/ + + +#include +#include +#include +#include +#include + +#define lstrlib_c + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + +/* macro to `unsign' a character */ +#ifndef uchar +#define uchar(c) ((unsigned char)(c)) +#endif + + +typedef long sint32; /* a signed version for size_t */ + + +static int str_len (lua_State *L) { + size_t l; + luaL_checklstring(L, 1, &l); + lua_pushnumber(L, (lua_Number)l); + return 1; +} + + +static sint32 posrelat (sint32 pos, size_t len) { + /* relative string position: negative means back from end */ + return (pos>=0) ? pos : (sint32)len+pos+1; +} + + +static int str_sub (lua_State *L) { + size_t l; + const char *s = luaL_checklstring(L, 1, &l); + sint32 start = posrelat(luaL_checklong(L, 2), l); + sint32 end = posrelat(luaL_optlong(L, 3, -1), l); + if (start < 1) start = 1; + if (end > (sint32)l) end = (sint32)l; + if (start <= end) + lua_pushlstring(L, s+start-1, end-start+1); + else lua_pushliteral(L, ""); + return 1; +} + + +static int str_lower (lua_State *L) { + size_t l; + size_t i; + luaL_Buffer b; + const char *s = luaL_checklstring(L, 1, &l); + luaL_buffinit(L, &b); + for (i=0; i 0) + luaL_addlstring(&b, s, l); + luaL_pushresult(&b); + return 1; +} + + +static int str_byte (lua_State *L) { + size_t l; + const char *s = luaL_checklstring(L, 1, &l); + sint32 pos = posrelat(luaL_optlong(L, 2, 1), l); + if (pos <= 0 || (size_t)(pos) > l) /* index out of range? */ + return 0; /* no answer */ + lua_pushnumber(L, uchar(s[pos-1])); + return 1; +} + + +static int str_char (lua_State *L) { + int n = lua_gettop(L); /* number of arguments */ + int i; + luaL_Buffer b; + luaL_buffinit(L, &b); + for (i=1; i<=n; i++) { + int c = luaL_checkint(L, i); + luaL_argcheck(L, uchar(c) == c, i, "invalid value"); + luaL_putchar(&b, uchar(c)); + } + luaL_pushresult(&b); + return 1; +} + + +static int writer (lua_State *L, const void* b, size_t size, void* B) { + (void)L; + luaL_addlstring((luaL_Buffer*) B, (const char *)b, size); + return 1; +} + + +static int str_dump (lua_State *L) { + luaL_Buffer b; + luaL_checktype(L, 1, LUA_TFUNCTION); + luaL_buffinit(L,&b); + if (!lua_dump(L, writer, &b)) + luaL_error(L, "unable to dump given function"); + luaL_pushresult(&b); + return 1; +} + + + +/* +** {====================================================== +** PATTERN MATCHING +** ======================================================= +*/ + +#ifndef MAX_CAPTURES +#define MAX_CAPTURES 32 /* arbitrary limit */ +#endif + + +#define CAP_UNFINISHED (-1) +#define CAP_POSITION (-2) + +typedef struct MatchState { + const char *src_init; /* init of source string */ + const char *src_end; /* end (`\0') of source string */ + lua_State *L; + int level; /* total number of captures (finished or unfinished) */ + struct { + const char *init; + sint32 len; + } capture[MAX_CAPTURES]; +} MatchState; + + +#define ESC '%' +#define SPECIALS "^$*+?.([%-" + + +static int check_capture (MatchState *ms, int l) { + l -= '1'; + if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED) + return luaL_error(ms->L, "invalid capture index"); + return l; +} + + +static int capture_to_close (MatchState *ms) { + int level = ms->level; + for (level--; level>=0; level--) + if (ms->capture[level].len == CAP_UNFINISHED) return level; + return luaL_error(ms->L, "invalid pattern capture"); +} + + +static const char *luaI_classend (MatchState *ms, const char *p) { + switch (*p++) { + case ESC: { + if (*p == '\0') + luaL_error(ms->L, "malformed pattern (ends with `%')"); + return p+1; + } + case '[': { + if (*p == '^') p++; + do { /* look for a `]' */ + if (*p == '\0') + luaL_error(ms->L, "malformed pattern (missing `]')"); + if (*(p++) == ESC && *p != '\0') + p++; /* skip escapes (e.g. `%]') */ + } while (*p != ']'); + return p+1; + } + default: { + return p; + } + } +} + + +static int match_class (int c, int cl) { + int res; + switch (tolower(cl)) { + case 'a' : res = isalpha(c); break; + case 'c' : res = iscntrl(c); break; + case 'd' : res = isdigit(c); break; + case 'l' : res = islower(c); break; + case 'p' : res = ispunct(c); break; + case 's' : res = isspace(c); break; + case 'u' : res = isupper(c); break; + case 'w' : res = isalnum(c); break; + case 'x' : res = isxdigit(c); break; + case 'z' : res = (c == 0); break; + default: return (cl == c); + } + return (islower(cl) ? res : !res); +} + + +static int matchbracketclass (int c, const char *p, const char *ec) { + int sig = 1; + if (*(p+1) == '^') { + sig = 0; + p++; /* skip the `^' */ + } + while (++p < ec) { + if (*p == ESC) { + p++; + if (match_class(c, *p)) + return sig; + } + else if ((*(p+1) == '-') && (p+2 < ec)) { + p+=2; + if (uchar(*(p-2)) <= c && c <= uchar(*p)) + return sig; + } + else if (uchar(*p) == c) return sig; + } + return !sig; +} + + +static int luaI_singlematch (int c, const char *p, const char *ep) { + switch (*p) { + case '.': return 1; /* matches any char */ + case ESC: return match_class(c, *(p+1)); + case '[': return matchbracketclass(c, p, ep-1); + default: return (uchar(*p) == c); + } +} + + +static const char *match (MatchState *ms, const char *s, const char *p); + + +static const char *matchbalance (MatchState *ms, const char *s, + const char *p) { + if (*p == 0 || *(p+1) == 0) + luaL_error(ms->L, "unbalanced pattern"); + if (*s != *p) return NULL; + else { + int b = *p; + int e = *(p+1); + int cont = 1; + while (++s < ms->src_end) { + if (*s == e) { + if (--cont == 0) return s+1; + } + else if (*s == b) cont++; + } + } + return NULL; /* string ends out of balance */ +} + + +static const char *max_expand (MatchState *ms, const char *s, + const char *p, const char *ep) { + sint32 i = 0; /* counts maximum expand for item */ + while ((s+i)src_end && luaI_singlematch(uchar(*(s+i)), p, ep)) + i++; + /* keeps trying to match with the maximum repetitions */ + while (i>=0) { + const char *res = match(ms, (s+i), ep+1); + if (res) return res; + i--; /* else didn't match; reduce 1 repetition to try again */ + } + return NULL; +} + + +static const char *min_expand (MatchState *ms, const char *s, + const char *p, const char *ep) { + for (;;) { + const char *res = match(ms, s, ep+1); + if (res != NULL) + return res; + else if (ssrc_end && luaI_singlematch(uchar(*s), p, ep)) + s++; /* try with one more repetition */ + else return NULL; + } +} + + +static const char *start_capture (MatchState *ms, const char *s, + const char *p, int what) { + const char *res; + int level = ms->level; + if (level >= MAX_CAPTURES) luaL_error(ms->L, "too many captures"); + ms->capture[level].init = s; + ms->capture[level].len = what; + ms->level = level+1; + if ((res=match(ms, s, p)) == NULL) /* match failed? */ + ms->level--; /* undo capture */ + return res; +} + + +static const char *end_capture (MatchState *ms, const char *s, + const char *p) { + int l = capture_to_close(ms); + const char *res; + ms->capture[l].len = s - ms->capture[l].init; /* close capture */ + if ((res = match(ms, s, p)) == NULL) /* match failed? */ + ms->capture[l].len = CAP_UNFINISHED; /* undo capture */ + return res; +} + + +static const char *match_capture (MatchState *ms, const char *s, int l) { + size_t len; + l = check_capture(ms, l); + len = ms->capture[l].len; + if ((size_t)(ms->src_end-s) >= len && + memcmp(ms->capture[l].init, s, len) == 0) + return s+len; + else return NULL; +} + + +static const char *match (MatchState *ms, const char *s, const char *p) { + init: /* using goto's to optimize tail recursion */ + switch (*p) { + case '(': { /* start capture */ + if (*(p+1) == ')') /* position capture? */ + return start_capture(ms, s, p+2, CAP_POSITION); + else + return start_capture(ms, s, p+1, CAP_UNFINISHED); + } + case ')': { /* end capture */ + return end_capture(ms, s, p+1); + } + case ESC: { + switch (*(p+1)) { + case 'b': { /* balanced string? */ + s = matchbalance(ms, s, p+2); + if (s == NULL) return NULL; + p+=4; goto init; /* else return match(ms, s, p+4); */ + } + case 'f': { /* frontier? */ + const char *ep; char previous; + p += 2; + if (*p != '[') + luaL_error(ms->L, "missing `[' after `%%f' in pattern"); + ep = luaI_classend(ms, p); /* points to what is next */ + previous = (s == ms->src_init) ? '\0' : *(s-1); + if (matchbracketclass(uchar(previous), p, ep-1) || + !matchbracketclass(uchar(*s), p, ep-1)) return NULL; + p=ep; goto init; /* else return match(ms, s, ep); */ + } + default: { + if (isdigit(uchar(*(p+1)))) { /* capture results (%0-%9)? */ + s = match_capture(ms, s, *(p+1)); + if (s == NULL) return NULL; + p+=2; goto init; /* else return match(ms, s, p+2) */ + } + goto dflt; /* case default */ + } + } + } + case '\0': { /* end of pattern */ + return s; /* match succeeded */ + } + case '$': { + if (*(p+1) == '\0') /* is the `$' the last char in pattern? */ + return (s == ms->src_end) ? s : NULL; /* check end of string */ + else goto dflt; + } + default: dflt: { /* it is a pattern item */ + const char *ep = luaI_classend(ms, p); /* points to what is next */ + int m = ssrc_end && luaI_singlematch(uchar(*s), p, ep); + switch (*ep) { + case '?': { /* optional */ + const char *res; + if (m && ((res=match(ms, s+1, ep+1)) != NULL)) + return res; + p=ep+1; goto init; /* else return match(ms, s, ep+1); */ + } + case '*': { /* 0 or more repetitions */ + return max_expand(ms, s, p, ep); + } + case '+': { /* 1 or more repetitions */ + return (m ? max_expand(ms, s+1, p, ep) : NULL); + } + case '-': { /* 0 or more repetitions (minimum) */ + return min_expand(ms, s, p, ep); + } + default: { + if (!m) return NULL; + s++; p=ep; goto init; /* else return match(ms, s+1, ep); */ + } + } + } + } +} + + + +static const char *lmemfind (const char *s1, size_t l1, + const char *s2, size_t l2) { + if (l2 == 0) return s1; /* empty strings are everywhere */ + else if (l2 > l1) return NULL; /* avoids a negative `l1' */ + else { + const char *init; /* to search for a `*s2' inside `s1' */ + l2--; /* 1st char will be checked by `memchr' */ + l1 = l1-l2; /* `s2' cannot be found after that */ + while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) { + init++; /* 1st char is already checked */ + if (memcmp(init, s2+1, l2) == 0) + return init-1; + else { /* correct `l1' and `s1' to try again */ + l1 -= init-s1; + s1 = init; + } + } + return NULL; /* not found */ + } +} + + +static void push_onecapture (MatchState *ms, int i) { + int l = ms->capture[i].len; + if (l == CAP_UNFINISHED) luaL_error(ms->L, "unfinished capture"); + if (l == CAP_POSITION) + lua_pushnumber(ms->L, (lua_Number)(ms->capture[i].init - ms->src_init + 1)); + else + lua_pushlstring(ms->L, ms->capture[i].init, l); +} + + +static int push_captures (MatchState *ms, const char *s, const char *e) { + int i; + luaL_checkstack(ms->L, ms->level, "too many captures"); + if (ms->level == 0 && s) { /* no explicit captures? */ + lua_pushlstring(ms->L, s, e-s); /* return whole match */ + return 1; + } + else { /* return all captures */ + for (i=0; ilevel; i++) + push_onecapture(ms, i); + return ms->level; /* number of strings pushed */ + } +} + + +static int str_find (lua_State *L) { + size_t l1, l2; + const char *s = luaL_checklstring(L, 1, &l1); + const char *p = luaL_checklstring(L, 2, &l2); + sint32 init = posrelat(luaL_optlong(L, 3, 1), l1) - 1; + if (init < 0) init = 0; + else if ((size_t)(init) > l1) init = (sint32)l1; + if (lua_toboolean(L, 4) || /* explicit request? */ + strpbrk(p, SPECIALS) == NULL) { /* or no special characters? */ + /* do a plain search */ + const char *s2 = lmemfind(s+init, l1-init, p, l2); + if (s2) { + lua_pushnumber(L, (lua_Number)(s2-s+1)); + lua_pushnumber(L, (lua_Number)(s2-s+l2)); + return 2; + } + } + else { + MatchState ms; + int anchor = (*p == '^') ? (p++, 1) : 0; + const char *s1=s+init; + ms.L = L; + ms.src_init = s; + ms.src_end = s+l1; + do { + const char *res; + ms.level = 0; + if ((res=match(&ms, s1, p)) != NULL) { + lua_pushnumber(L, (lua_Number)(s1-s+1)); /* start */ + lua_pushnumber(L, (lua_Number)(res-s)); /* end */ + return push_captures(&ms, NULL, 0) + 2; + } + } while (s1++L; + if (lua_isstring(L, 3)) { + const char *news = lua_tostring(L, 3); + size_t l = lua_strlen(L, 3); + size_t i; + for (i=0; i= 3 && (lua_isstring(L, 3) || lua_isfunction(L, 3)), + 3, "string or function expected"); + luaL_buffinit(L, &b); + ms.L = L; + ms.src_init = src; + ms.src_end = src+srcl; + while (n < max_s) { + const char *e; + ms.level = 0; + e = match(&ms, src, p); + if (e) { + n++; + add_s(&ms, &b, src, e); + } + if (e && e>src) /* non empty match? */ + src = e; /* skip it */ + else if (src < ms.src_end) + luaL_putchar(&b, *src++); + else break; + if (anchor) break; + } + luaL_addlstring(&b, src, ms.src_end-src); + luaL_pushresult(&b); + lua_pushnumber(L, (lua_Number)n); /* number of substitutions */ + return 2; +} + +/* }====================================================== */ + + +/* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */ +#define MAX_ITEM 512 +/* maximum size of each format specification (such as '%-099.99d') */ +#define MAX_FORMAT 20 + + +static void luaI_addquoted (lua_State *L, luaL_Buffer *b, int arg) { + size_t l; + const char *s = luaL_checklstring(L, arg, &l); + luaL_putchar(b, '"'); + while (l--) { + switch (*s) { + case '"': case '\\': case '\n': { + luaL_putchar(b, '\\'); + luaL_putchar(b, *s); + break; + } + case '\0': { + luaL_addlstring(b, "\\000", 4); + break; + } + default: { + luaL_putchar(b, *s); + break; + } + } + s++; + } + luaL_putchar(b, '"'); +} + + +static const char *scanformat (lua_State *L, const char *strfrmt, + char *form, int *hasprecision) { + const char *p = strfrmt; + while (strchr("-+ #0", *p)) p++; /* skip flags */ + if (isdigit(uchar(*p))) p++; /* skip width */ + if (isdigit(uchar(*p))) p++; /* (2 digits at most) */ + if (*p == '.') { + p++; + *hasprecision = 1; + if (isdigit(uchar(*p))) p++; /* skip precision */ + if (isdigit(uchar(*p))) p++; /* (2 digits at most) */ + } + if (isdigit(uchar(*p))) + luaL_error(L, "invalid format (width or precision too long)"); + if (p-strfrmt+2 > MAX_FORMAT) /* +2 to include `%' and the specifier */ + luaL_error(L, "invalid format (too long)"); + form[0] = '%'; + strncpy(form+1, strfrmt, p-strfrmt+1); + form[p-strfrmt+2] = 0; + return p; +} + + +static int str_format (lua_State *L) { + int arg = 1; + size_t sfl; + const char *strfrmt = luaL_checklstring(L, arg, &sfl); + const char *strfrmt_end = strfrmt+sfl; + luaL_Buffer b; + luaL_buffinit(L, &b); + while (strfrmt < strfrmt_end) { + if (*strfrmt != '%') + luaL_putchar(&b, *strfrmt++); + else if (*++strfrmt == '%') + luaL_putchar(&b, *strfrmt++); /* %% */ + else { /* format item */ + char form[MAX_FORMAT]; /* to store the format (`%...') */ + char buff[MAX_ITEM]; /* to store the formatted item */ + int hasprecision = 0; + if (isdigit(uchar(*strfrmt)) && *(strfrmt+1) == '$') + return luaL_error(L, "obsolete option (d$) to `format'"); + arg++; + strfrmt = scanformat(L, strfrmt, form, &hasprecision); + switch (*strfrmt++) { + case 'c': case 'd': case 'i': { + sprintf(buff, form, luaL_checkint(L, arg)); + break; + } + case 'o': case 'u': case 'x': case 'X': { + sprintf(buff, form, (unsigned int)(luaL_checknumber(L, arg))); + break; + } + case 'e': case 'E': case 'f': + case 'g': case 'G': { + sprintf(buff, form, luaL_checknumber(L, arg)); + break; + } + case 'q': { + luaI_addquoted(L, &b, arg); + continue; /* skip the `addsize' at the end */ + } + case 's': { + size_t l; + const char *s = luaL_checklstring(L, arg, &l); + if (!hasprecision && l >= 100) { + /* no precision and string is too long to be formatted; + keep original string */ + lua_pushvalue(L, arg); + luaL_addvalue(&b); + continue; /* skip the `addsize' at the end */ + } + else { + sprintf(buff, form, s); + break; + } + } + default: { /* also treat cases `pnLlh' */ + return luaL_error(L, "invalid option to `format'"); + } + } + luaL_addlstring(&b, buff, strlen(buff)); + } + } + luaL_pushresult(&b); + return 1; +} + + +static const luaL_reg strlib[] = { + {"len", str_len}, + {"sub", str_sub}, + {"lower", str_lower}, + {"upper", str_upper}, + {"char", str_char}, + {"rep", str_rep}, + {"byte", str_byte}, + {"format", str_format}, + {"dump", str_dump}, + {"find", str_find}, + {"gfind", gfind}, + {"gsub", str_gsub}, + {NULL, NULL} +}; + + +/* +** Open string library +*/ +LUALIB_API int luaopen_string (lua_State *L) { + luaL_openlib(L, LUA_STRLIBNAME, strlib, 0); + return 1; +} + diff --git a/stepmania/src/lua-5.0/src/lib/ltablib.c b/stepmania/src/lua-5.0/src/lib/ltablib.c new file mode 100644 index 0000000000..970e9940ce --- /dev/null +++ b/stepmania/src/lua-5.0/src/lib/ltablib.c @@ -0,0 +1,250 @@ +/* +** $Id$ +** Library for Table Manipulation +** See Copyright Notice in lua.h +*/ + + +#include + +#define ltablib_c + +#include "lua.h" + +#include "lauxlib.h" +#include "lualib.h" + + +#define aux_getn(L,n) (luaL_checktype(L, n, LUA_TTABLE), luaL_getn(L, n)) + + +static int luaB_foreachi (lua_State *L) { + int i; + int n = aux_getn(L, 1); + luaL_checktype(L, 2, LUA_TFUNCTION); + for (i=1; i<=n; i++) { + lua_pushvalue(L, 2); /* function */ + lua_pushnumber(L, (lua_Number)i); /* 1st argument */ + lua_rawgeti(L, 1, i); /* 2nd argument */ + lua_call(L, 2, 1); + if (!lua_isnil(L, -1)) + return 1; + lua_pop(L, 1); /* remove nil result */ + } + return 0; +} + + +static int luaB_foreach (lua_State *L) { + luaL_checktype(L, 1, LUA_TTABLE); + luaL_checktype(L, 2, LUA_TFUNCTION); + lua_pushnil(L); /* first key */ + for (;;) { + if (lua_next(L, 1) == 0) + return 0; + lua_pushvalue(L, 2); /* function */ + lua_pushvalue(L, -3); /* key */ + lua_pushvalue(L, -3); /* value */ + lua_call(L, 2, 1); + if (!lua_isnil(L, -1)) + return 1; + lua_pop(L, 2); /* remove value and result */ + } +} + + +static int luaB_getn (lua_State *L) { + lua_pushnumber(L, (lua_Number)aux_getn(L, 1)); + return 1; +} + + +static int luaB_setn (lua_State *L) { + luaL_checktype(L, 1, LUA_TTABLE); + luaL_setn(L, 1, luaL_checkint(L, 2)); + return 0; +} + + +static int luaB_tinsert (lua_State *L) { + int v = lua_gettop(L); /* number of arguments */ + int n = aux_getn(L, 1) + 1; + int pos; /* where to insert new element */ + if (v == 2) /* called with only 2 arguments */ + pos = n; /* insert new element at the end */ + else { + pos = luaL_checkint(L, 2); /* 2nd argument is the position */ + if (pos > n) n = pos; /* `grow' array if necessary */ + v = 3; /* function may be called with more than 3 args */ + } + luaL_setn(L, 1, n); /* new size */ + while (--n >= pos) { /* move up elements */ + lua_rawgeti(L, 1, n); + lua_rawseti(L, 1, n+1); /* t[n+1] = t[n] */ + } + lua_pushvalue(L, v); + lua_rawseti(L, 1, pos); /* t[pos] = v */ + return 0; +} + + +static int luaB_tremove (lua_State *L) { + int n = aux_getn(L, 1); + int pos = luaL_optint(L, 2, n); + if (n <= 0) return 0; /* table is `empty' */ + luaL_setn(L, 1, n-1); /* t.n = n-1 */ + lua_rawgeti(L, 1, pos); /* result = t[pos] */ + for ( ;pos= P */ + while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) { + if (i>u) luaL_error(L, "invalid order function for sorting"); + lua_pop(L, 1); /* remove a[i] */ + } + /* repeat --j until a[j] <= P */ + while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) { + if (j +#include + +#define llex_c + +#include "lua.h" + +#include "ldo.h" +#include "llex.h" +#include "lobject.h" +#include "lparser.h" +#include "lstate.h" +#include "lstring.h" +#include "lzio.h" + + + +#define next(LS) (LS->current = zgetc(LS->z)) + + + +/* ORDER RESERVED */ +static const char *const token2string [] = { + "and", "break", "do", "else", "elseif", + "end", "false", "for", "function", "if", + "in", "local", "nil", "not", "or", "repeat", + "return", "then", "true", "until", "while", "*name", + "..", "...", "==", ">=", "<=", "~=", + "*number", "*string", "" +}; + + +void luaX_init (lua_State *L) { + int i; + for (i=0; itsv.reserved = cast(lu_byte, i+1); /* reserved word */ + } +} + + +#define MAXSRC 80 + + +void luaX_checklimit (LexState *ls, int val, int limit, const char *msg) { + if (val > limit) { + msg = luaO_pushfstring(ls->L, "too many %s (limit=%d)", msg, limit); + luaX_syntaxerror(ls, msg); + } +} + + +void luaX_errorline (LexState *ls, const char *s, const char *token, int line) { + lua_State *L = ls->L; + char buff[MAXSRC]; + luaO_chunkid(buff, getstr(ls->source), MAXSRC); + luaO_pushfstring(L, "%s:%d: %s near `%s'", buff, line, s, token); + luaD_throw(L, LUA_ERRSYNTAX); +} + + +static void luaX_error (LexState *ls, const char *s, const char *token) { + luaX_errorline(ls, s, token, ls->linenumber); +} + + +void luaX_syntaxerror (LexState *ls, const char *msg) { + const char *lasttoken; + switch (ls->t.token) { + case TK_NAME: + lasttoken = getstr(ls->t.seminfo.ts); + break; + case TK_STRING: + case TK_NUMBER: + lasttoken = luaZ_buffer(ls->buff); + break; + default: + lasttoken = luaX_token2str(ls, ls->t.token); + break; + } + luaX_error(ls, msg, lasttoken); +} + + +const char *luaX_token2str (LexState *ls, int token) { + if (token < FIRST_RESERVED) { + lua_assert(token == (unsigned char)token); + return luaO_pushfstring(ls->L, "%c", token); + } + else + return token2string[token-FIRST_RESERVED]; +} + + +static void luaX_lexerror (LexState *ls, const char *s, int token) { + if (token == TK_EOS) + luaX_error(ls, s, luaX_token2str(ls, token)); + else + luaX_error(ls, s, luaZ_buffer(ls->buff)); +} + + +static void inclinenumber (LexState *LS) { + next(LS); /* skip `\n' */ + ++LS->linenumber; + luaX_checklimit(LS, LS->linenumber, MAX_INT, "lines in a chunk"); +} + + +void luaX_setinput (lua_State *L, LexState *LS, ZIO *z, TString *source) { + 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; + next(LS); /* read first char */ + if (LS->current == '#') { + do { /* skip first line */ + next(LS); + } while (LS->current != '\n' && LS->current != EOZ); + } +} + + + +/* +** ======================================================= +** LEXICAL ANALYZER +** ======================================================= +*/ + + +/* use buffer to store names, literal strings and numbers */ + +/* extra space to allocate when growing buffer */ +#define EXTRABUFF 32 + +/* maximum number of chars that can be read without checking buffer size */ +#define MAXNOCHECK 5 + +#define checkbuffer(LS, len) \ + if (((len)+MAXNOCHECK)*sizeof(char) > luaZ_sizebuffer((LS)->buff)) \ + luaZ_openspace((LS)->L, (LS)->buff, (len)+EXTRABUFF) + +#define save(LS, c, l) \ + (luaZ_buffer((LS)->buff)[l++] = cast(char, c)) +#define save_and_next(LS, l) (save(LS, LS->current, l), next(LS)) + + +static size_t readname (LexState *LS) { + size_t l = 0; + checkbuffer(LS, l); + do { + checkbuffer(LS, l); + save_and_next(LS, l); + } while (isalnum(LS->current) || LS->current == '_'); + save(LS, '\0', l); + return l-1; +} + + +/* LUA_NUMBER */ +static void read_numeral (LexState *LS, int comma, SemInfo *seminfo) { + size_t l = 0; + checkbuffer(LS, l); + if (comma) save(LS, '.', l); + while (isdigit(LS->current)) { + checkbuffer(LS, l); + save_and_next(LS, l); + } + if (LS->current == '.') { + save_and_next(LS, l); + if (LS->current == '.') { + save_and_next(LS, l); + save(LS, '\0', l); + luaX_lexerror(LS, + "ambiguous syntax (decimal point x string concatenation)", + TK_NUMBER); + } + } + while (isdigit(LS->current)) { + checkbuffer(LS, l); + save_and_next(LS, l); + } + if (LS->current == 'e' || LS->current == 'E') { + save_and_next(LS, l); /* read `E' */ + if (LS->current == '+' || LS->current == '-') + save_and_next(LS, l); /* optional exponent sign */ + while (isdigit(LS->current)) { + checkbuffer(LS, l); + save_and_next(LS, l); + } + } + save(LS, '\0', l); + if (!luaO_str2d(luaZ_buffer(LS->buff), &seminfo->r)) + luaX_lexerror(LS, "malformed number", TK_NUMBER); +} + + +static void read_long_string (LexState *LS, SemInfo *seminfo) { + int cont = 0; + size_t l = 0; + checkbuffer(LS, l); + save(LS, '[', l); /* save first `[' */ + save_and_next(LS, l); /* pass the second `[' */ + if (LS->current == '\n') /* string starts with a newline? */ + inclinenumber(LS); /* skip it */ + for (;;) { + checkbuffer(LS, l); + switch (LS->current) { + case EOZ: + save(LS, '\0', l); + luaX_lexerror(LS, (seminfo) ? "unfinished long string" : + "unfinished long comment", TK_EOS); + break; /* to avoid warnings */ + case '[': + save_and_next(LS, l); + if (LS->current == '[') { + cont++; + save_and_next(LS, l); + } + continue; + case ']': + save_and_next(LS, l); + if (LS->current == ']') { + if (cont == 0) goto endloop; + cont--; + save_and_next(LS, l); + } + continue; + case '\n': + save(LS, '\n', l); + inclinenumber(LS); + if (!seminfo) l = 0; /* reset buffer to avoid wasting space */ + continue; + default: + save_and_next(LS, l); + } + } endloop: + save_and_next(LS, l); /* skip the second `]' */ + save(LS, '\0', l); + if (seminfo) + seminfo->ts = luaS_newlstr(LS->L, luaZ_buffer(LS->buff) + 2, l - 5); +} + + +static void read_string (LexState *LS, int del, SemInfo *seminfo) { + size_t l = 0; + checkbuffer(LS, l); + save_and_next(LS, l); + while (LS->current != del) { + checkbuffer(LS, l); + switch (LS->current) { + case EOZ: + save(LS, '\0', l); + luaX_lexerror(LS, "unfinished string", TK_EOS); + break; /* to avoid warnings */ + case '\n': + save(LS, '\0', l); + luaX_lexerror(LS, "unfinished string", TK_STRING); + break; /* to avoid warnings */ + case '\\': + next(LS); /* do not save the `\' */ + switch (LS->current) { + case 'a': save(LS, '\a', l); next(LS); break; + case 'b': save(LS, '\b', l); next(LS); break; + case 'f': save(LS, '\f', l); next(LS); break; + case 'n': save(LS, '\n', l); next(LS); break; + case 'r': save(LS, '\r', l); next(LS); break; + case 't': save(LS, '\t', l); next(LS); break; + case 'v': save(LS, '\v', l); next(LS); break; + case '\n': save(LS, '\n', l); inclinenumber(LS); break; + case EOZ: break; /* will raise an error next loop */ + default: { + if (!isdigit(LS->current)) + save_and_next(LS, l); /* handles \\, \", \', and \? */ + else { /* \xxx */ + int c = 0; + int i = 0; + do { + c = 10*c + (LS->current-'0'); + next(LS); + } while (++i<3 && isdigit(LS->current)); + if (c > UCHAR_MAX) { + save(LS, '\0', l); + luaX_lexerror(LS, "escape sequence too large", TK_STRING); + } + save(LS, c, l); + } + } + } + break; + default: + save_and_next(LS, l); + } + } + save_and_next(LS, l); /* skip delimiter */ + save(LS, '\0', l); + seminfo->ts = luaS_newlstr(LS->L, luaZ_buffer(LS->buff) + 1, l - 3); +} + + +int luaX_lex (LexState *LS, SemInfo *seminfo) { + for (;;) { + switch (LS->current) { + + case '\n': { + inclinenumber(LS); + continue; + } + case '-': { + next(LS); + if (LS->current != '-') return '-'; + /* else is a comment */ + next(LS); + if (LS->current == '[' && (next(LS), LS->current == '[')) + read_long_string(LS, NULL); /* long comment */ + else /* short comment */ + while (LS->current != '\n' && LS->current != EOZ) + next(LS); + continue; + } + case '[': { + next(LS); + if (LS->current != '[') return '['; + else { + read_long_string(LS, seminfo); + return 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 '.': { + next(LS); + if (LS->current == '.') { + next(LS); + if (LS->current == '.') { + next(LS); + return TK_DOTS; /* ... */ + } + else return TK_CONCAT; /* .. */ + } + else if (!isdigit(LS->current)) return '.'; + else { + read_numeral(LS, 1, seminfo); + return TK_NUMBER; + } + } + case EOZ: { + return TK_EOS; + } + default: { + if (isspace(LS->current)) { + next(LS); + continue; + } + else if (isdigit(LS->current)) { + read_numeral(LS, 0, seminfo); + return TK_NUMBER; + } + else if (isalpha(LS->current) || LS->current == '_') { + /* identifier or reserved word */ + size_t l = readname(LS); + TString *ts = luaS_newlstr(LS->L, luaZ_buffer(LS->buff), l); + if (ts->tsv.reserved > 0) /* reserved word? */ + return ts->tsv.reserved - 1 + FIRST_RESERVED; + seminfo->ts = ts; + return TK_NAME; + } + else { + int c = LS->current; + if (iscntrl(c)) + luaX_error(LS, "invalid control char", + luaO_pushfstring(LS->L, "char(%d)", c)); + next(LS); + return c; /* single-char tokens (+ - / ...) */ + } + } + } + } +} + +#undef next diff --git a/stepmania/src/lua-5.0/src/llex.h b/stepmania/src/lua-5.0/src/llex.h new file mode 100644 index 0000000000..de122ccdea --- /dev/null +++ b/stepmania/src/lua-5.0/src/llex.h @@ -0,0 +1,75 @@ +/* +** $Id$ +** 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_NAME, TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_NUMBER, + TK_STRING, TK_EOS +}; + +/* number of reserved words */ +#define NUM_RESERVED (cast(int, TK_WHILE-FIRST_RESERVED+1)) + + +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 */ + int nestlevel; /* level of nested non-terminals */ +} LexState; + + +void luaX_init (lua_State *L); +void luaX_setinput (lua_State *L, LexState *LS, ZIO *z, TString *source); +int luaX_lex (LexState *LS, SemInfo *seminfo); +void luaX_checklimit (LexState *ls, int val, int limit, const char *msg); +void luaX_syntaxerror (LexState *ls, const char *s); +void luaX_errorline (LexState *ls, const char *s, const char *token, int line); +const char *luaX_token2str (LexState *ls, int token); + + +#endif diff --git a/stepmania/src/lua-5.0/src/llimits.h b/stepmania/src/lua-5.0/src/llimits.h new file mode 100644 index 0000000000..4435a4536f --- /dev/null +++ b/stepmania/src/lua-5.0/src/llimits.h @@ -0,0 +1,185 @@ +/* +** $Id$ +** Limits, basic types, and some other `installation-dependent' definitions +** See Copyright Notice in lua.h +*/ + +#ifndef llimits_h +#define llimits_h + + +#include +#include + + +#include "lua.h" + + +/* +** try to find number of bits in an integer +*/ +#ifndef BITS_INT +/* avoid overflows in comparison */ +#if INT_MAX-20 < 32760 +#define BITS_INT 16 +#else +#if INT_MAX > 2147483640L +/* machine has at least 32 bits */ +#define BITS_INT 32 +#else +#error "you must define BITS_INT with number of bits in an integer" +#endif +#endif +#endif + + +/* +** the following types define integer types for values that may not +** fit in a `small int' (16 bits), but may waste space in a +** `large long' (64 bits). The current definitions should work in +** any machine, but may not be optimal. +*/ + +/* an unsigned integer to hold hash values */ +typedef unsigned int lu_hash; +/* its signed equivalent */ +typedef int ls_hash; + +/* an unsigned integer big enough to count the total memory used by Lua; */ +/* it should be at least as large as size_t */ +typedef unsigned long lu_mem; + +#define MAX_LUMEM ULONG_MAX + + +/* an integer big enough to count the number of strings in use */ +typedef long ls_nstr; + +/* 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_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) ((lu_hash)(p)) + + + +/* type to ensure maximum alignment */ +#ifndef LUSER_ALIGNMENT_T +typedef union { double u; void *s; long l; } L_Umaxalign; +#else +typedef LUSER_ALIGNMENT_T L_Umaxalign; +#endif + + +/* result of `usual argument conversion' over lua_Number */ +#ifndef LUA_UACNUMBER +typedef double l_uacNumber; +#else +typedef LUA_UACNUMBER l_uacNumber; +#endif + + +#ifndef lua_assert +#define lua_assert(c) /* empty */ +#endif + + +#ifndef check_exp +#define check_exp(c,e) (e) +#endif + + +#ifndef UNUSED +#define UNUSED(x) ((void)(x)) /* to avoid warnings */ +#endif + + +#ifndef cast +#define cast(t, exp) ((t)(exp)) +#endif + + + +/* +** type for virtual-machine instructions +** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h) +*/ +typedef unsigned long Instruction; + + +/* maximum depth for calls (unsigned short) */ +#ifndef LUA_MAXCALLS +#define LUA_MAXCALLS 4096 +#endif + + +/* +** maximum depth for C calls (unsigned short): Not too big, or may +** overflow the C stack... +*/ + +#ifndef LUA_MAXCCALLS +#define LUA_MAXCCALLS 200 +#endif + + +/* maximum size for the C stack */ +#ifndef LUA_MAXCSTACK +#define LUA_MAXCSTACK 2048 +#endif + + +/* maximum stack for a Lua function */ +#define MAXSTACK 250 + + +/* maximum number of variables declared in a function */ +#ifndef MAXVARS +#define MAXVARS 200 /* arbitrary limit ( + +#define lmem_c + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" + + + +/* +** definition for realloc function. It must assure that l_realloc(NULL, +** 0, x) allocates a new block (ANSI C assures that). (`os' is the old +** block size; some allocators may use that.) +*/ +#ifndef l_realloc +#define l_realloc(b,os,s) realloc(b,s) +#endif + +/* +** definition for free function. (`os' is the old block size; some +** allocators may use that.) +*/ +#ifndef l_free +#define l_free(b,os) free(b) +#endif + + +#define MINSIZEARRAY 4 + + +void *luaM_growaux (lua_State *L, void *block, int *size, int size_elems, + int limit, const char *errormsg) { + void *newblock; + int newsize = (*size)*2; + if (newsize < MINSIZEARRAY) + newsize = MINSIZEARRAY; /* minimum size */ + else if (*size >= limit/2) { /* cannot double it? */ + if (*size < limit - MINSIZEARRAY) /* try something smaller... */ + newsize = limit; /* still have at least MINSIZEARRAY free places */ + else luaG_runerror(L, errormsg); + } + newblock = luaM_realloc(L, block, + cast(lu_mem, *size)*cast(lu_mem, size_elems), + cast(lu_mem, newsize)*cast(lu_mem, size_elems)); + *size = newsize; /* update only when everything else is OK */ + return newblock; +} + + +/* +** generic allocation routine. +*/ +void *luaM_realloc (lua_State *L, void *block, lu_mem oldsize, lu_mem size) { + lua_assert((oldsize == 0) == (block == NULL)); + if (size == 0) { + if (block != NULL) { + l_free(block, oldsize); + block = NULL; + } + else return NULL; /* avoid `nblocks' computations when oldsize==size==0 */ + } + else if (size >= MAX_SIZET) + luaG_runerror(L, "memory allocation error: block too big"); + else { + block = l_realloc(block, oldsize, size); + if (block == NULL) { + if (L) + luaD_throw(L, LUA_ERRMEM); + else return NULL; /* error before creating state! */ + } + } + if (L) { + lua_assert(G(L) != NULL && G(L)->nblocks > 0); + G(L)->nblocks -= oldsize; + G(L)->nblocks += size; + } + return block; +} + diff --git a/stepmania/src/lua-5.0/src/lmem.h b/stepmania/src/lua-5.0/src/lmem.h new file mode 100644 index 0000000000..0020af338c --- /dev/null +++ b/stepmania/src/lua-5.0/src/lmem.h @@ -0,0 +1,44 @@ +/* +** $Id$ +** Interface to Memory Manager +** See Copyright Notice in lua.h +*/ + +#ifndef lmem_h +#define lmem_h + + +#include + +#include "llimits.h" +#include "lua.h" + +#define MEMERRMSG "not enough memory" + + +void *luaM_realloc (lua_State *L, void *oldblock, lu_mem oldsize, lu_mem size); + +void *luaM_growaux (lua_State *L, void *block, int *size, int size_elem, + int limit, const char *errormsg); + +#define luaM_free(L, b, s) luaM_realloc(L, (b), (s), 0) +#define luaM_freelem(L, b) luaM_realloc(L, (b), sizeof(*(b)), 0) +#define luaM_freearray(L, b, n, t) luaM_realloc(L, (b), \ + cast(lu_mem, n)*cast(lu_mem, sizeof(t)), 0) + +#define luaM_malloc(L, t) luaM_realloc(L, NULL, 0, (t)) +#define luaM_new(L, t) cast(t *, luaM_malloc(L, sizeof(t))) +#define luaM_newvector(L, n,t) cast(t *, luaM_malloc(L, \ + cast(lu_mem, n)*cast(lu_mem, sizeof(t)))) + +#define luaM_growvector(L,v,nelems,size,t,limit,e) \ + if (((nelems)+1) > (size)) \ + ((v)=cast(t *, luaM_growaux(L,v,&(size),sizeof(t),limit,e))) + +#define luaM_reallocvector(L, v,oldn,n,t) \ + ((v)=cast(t *, luaM_realloc(L, v,cast(lu_mem, oldn)*cast(lu_mem, sizeof(t)), \ + cast(lu_mem, n)*cast(lu_mem, sizeof(t))))) + + +#endif + diff --git a/stepmania/src/lua-5.0/src/lobject.c b/stepmania/src/lua-5.0/src/lobject.c new file mode 100644 index 0000000000..fb176df591 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lobject.c @@ -0,0 +1,195 @@ +/* +** $Id$ +** Some generic functions over Lua objects +** See Copyright Notice in lua.h +*/ + +#include +#include +#include +#include + +#define lobject_c + +#include "lua.h" + +#include "ldo.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" +#include "lvm.h" + + +/* function to convert a string to a lua_Number */ +#ifndef lua_str2number +#define lua_str2number(s,p) strtod((s), (p)) +#endif + + +const TObject luaO_nilobject = {LUA_TNIL, {NULL}}; + + +/* +** converts an integer to a "floating point byte", represented as +** (mmmmmxxx), where the real value is (xxx) * 2^(mmmmm) +*/ +int luaO_int2fb (unsigned int x) { + int m = 0; /* mantissa */ + while (x >= (1<<3)) { + x = (x+1) >> 1; + m++; + } + return (m << 3) | cast(int, x); +} + + +int luaO_log2 (unsigned int x) { + static const lu_byte log_8[255] = { + 0, + 1,1, + 2,2,2,2, + 3,3,3,3,3,3,3,3, + 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4, + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, + 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, + 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7 + }; + if (x >= 0x00010000) { + if (x >= 0x01000000) return log_8[((x>>24) & 0xff) - 1]+24; + else return log_8[((x>>16) & 0xff) - 1]+16; + } + else { + if (x >= 0x00000100) return log_8[((x>>8) & 0xff) - 1]+8; + else if (x) return log_8[(x & 0xff) - 1]; + return -1; /* special `log' for 0 */ + } +} + + +int luaO_rawequalObj (const TObject *t1, const TObject *t2) { + if (ttype(t1) != ttype(t2)) return 0; + else switch (ttype(t1)) { + case LUA_TNIL: + return 1; + case LUA_TNUMBER: + return nvalue(t1) == nvalue(t2); + case LUA_TBOOLEAN: + return bvalue(t1) == bvalue(t2); /* boolean true must be 1 !! */ + case LUA_TLIGHTUSERDATA: + return pvalue(t1) == pvalue(t2); + default: + lua_assert(iscollectable(t1)); + return gcvalue(t1) == gcvalue(t2); + } +} + + +int luaO_str2d (const char *s, lua_Number *result) { + char *endptr; + lua_Number res = lua_str2number(s, &endptr); + if (endptr == s) return 0; /* no conversion */ + while (isspace((unsigned char)(*endptr))) endptr++; + if (*endptr != '\0') return 0; /* invalid trailing characters? */ + *result = res; + return 1; +} + + + +static void pushstr (lua_State *L, const char *str) { + setsvalue2s(L->top, luaS_new(L, str)); + incr_top(L); +} + + +/* this function handles only `%d', `%c', %f, and `%s' formats */ +const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) { + int n = 1; + pushstr(L, ""); + for (;;) { + const char *e = strchr(fmt, '%'); + if (e == NULL) break; + setsvalue2s(L->top, luaS_newlstr(L, fmt, e-fmt)); + incr_top(L); + switch (*(e+1)) { + case 's': + pushstr(L, va_arg(argp, char *)); + break; + case 'c': { + char buff[2]; + buff[0] = cast(char, va_arg(argp, int)); + buff[1] = '\0'; + pushstr(L, buff); + break; + } + case 'd': + setnvalue(L->top, cast(lua_Number, va_arg(argp, int))); + incr_top(L); + break; + case 'f': + setnvalue(L->top, cast(lua_Number, va_arg(argp, l_uacNumber))); + incr_top(L); + break; + case '%': + pushstr(L, "%"); + break; + default: lua_assert(0); + } + n += 2; + fmt = e+2; + } + pushstr(L, fmt); + luaV_concat(L, n+1, L->top - L->base - 1); + L->top -= n; + return svalue(L->top - 1); +} + + +const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) { + const char *msg; + va_list argp; + va_start(argp, fmt); + msg = luaO_pushvfstring(L, fmt, argp); + va_end(argp); + return msg; +} + + +void luaO_chunkid (char *out, const char *source, int bufflen) { + if (*source == '=') { + strncpy(out, source+1, bufflen); /* remove first char */ + out[bufflen-1] = '\0'; /* ensures null termination */ + } + else { /* out = "source", or "...source" */ + if (*source == '@') { + int l; + source++; /* skip the `@' */ + bufflen -= sizeof(" `...' "); + l = strlen(source); + strcpy(out, ""); + if (l>bufflen) { + source += (l-bufflen); /* get last part of file name */ + strcat(out, "..."); + } + strcat(out, source); + } + else { /* out = [string "string"] */ + int len = strcspn(source, "\n"); /* stop at first newline */ + bufflen -= sizeof(" [string \"...\"] "); + if (len > bufflen) len = bufflen; + strcpy(out, "[string \""); + if (source[len] != '\0') { /* must truncate? */ + strncat(out, source, len); + strcat(out, "..."); + } + else + strcat(out, source); + strcat(out, "\"]"); + } + } +} diff --git a/stepmania/src/lua-5.0/src/lobject.h b/stepmania/src/lua-5.0/src/lobject.h new file mode 100644 index 0000000000..f30eb97989 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lobject.h @@ -0,0 +1,336 @@ +/* +** $Id$ +** Type definitions for Lua objects +** See Copyright Notice in lua.h +*/ + +#ifndef lobject_h +#define lobject_h + + +#include "llimits.h" +#include "lua.h" + + +/* tags for values visible from Lua */ +#define NUM_TAGS LUA_TTHREAD + + +/* +** Extra tags for non-values +*/ +#define LUA_TPROTO (NUM_TAGS+1) +#define LUA_TUPVAL (NUM_TAGS+2) + + +/* +** Union of all collectable objects +*/ +typedef union GCObject GCObject; + + +/* +** Common Header for all collectable objects (in macro form, to be +** included in other objects) +*/ +#define CommonHeader GCObject *next; lu_byte tt; lu_byte marked + + +/* +** Common header in struct form +*/ +typedef struct GCheader { + CommonHeader; +} GCheader; + + + + +/* +** Union of all Lua values +*/ +typedef union { + GCObject *gc; + void *p; + lua_Number n; + int b; +} Value; + + +/* +** Lua values (or `tagged objects') +*/ +typedef struct lua_TObject { + int tt; + Value value; +} TObject; + + +/* Macros to test type */ +#define ttisnil(o) (ttype(o) == LUA_TNIL) +#define ttisnumber(o) (ttype(o) == LUA_TNUMBER) +#define ttisstring(o) (ttype(o) == LUA_TSTRING) +#define ttistable(o) (ttype(o) == LUA_TTABLE) +#define ttisfunction(o) (ttype(o) == LUA_TFUNCTION) +#define ttisboolean(o) (ttype(o) == LUA_TBOOLEAN) +#define ttisuserdata(o) (ttype(o) == LUA_TUSERDATA) +#define ttisthread(o) (ttype(o) == LUA_TTHREAD) +#define ttislightuserdata(o) (ttype(o) == LUA_TLIGHTUSERDATA) + +/* Macros to access values */ +#define ttype(o) ((o)->tt) +#define gcvalue(o) check_exp(iscollectable(o), (o)->value.gc) +#define pvalue(o) check_exp(ttislightuserdata(o), (o)->value.p) +#define nvalue(o) check_exp(ttisnumber(o), (o)->value.n) +#define tsvalue(o) check_exp(ttisstring(o), &(o)->value.gc->ts) +#define uvalue(o) check_exp(ttisuserdata(o), &(o)->value.gc->u) +#define clvalue(o) check_exp(ttisfunction(o), &(o)->value.gc->cl) +#define hvalue(o) check_exp(ttistable(o), &(o)->value.gc->h) +#define bvalue(o) check_exp(ttisboolean(o), (o)->value.b) +#define thvalue(o) check_exp(ttisthread(o), &(o)->value.gc->th) + +#define l_isfalse(o) (ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0)) + +/* Macros to set values */ +#define setnvalue(obj,x) \ + { TObject *i_o=(obj); i_o->tt=LUA_TNUMBER; i_o->value.n=(x); } + +#define chgnvalue(obj,x) \ + check_exp(ttype(obj)==LUA_TNUMBER, (obj)->value.n=(x)) + +#define setpvalue(obj,x) \ + { TObject *i_o=(obj); i_o->tt=LUA_TLIGHTUSERDATA; i_o->value.p=(x); } + +#define setbvalue(obj,x) \ + { TObject *i_o=(obj); i_o->tt=LUA_TBOOLEAN; i_o->value.b=(x); } + +#define setsvalue(obj,x) \ + { TObject *i_o=(obj); i_o->tt=LUA_TSTRING; \ + i_o->value.gc=cast(GCObject *, (x)); \ + lua_assert(i_o->value.gc->gch.tt == LUA_TSTRING); } + +#define setuvalue(obj,x) \ + { TObject *i_o=(obj); i_o->tt=LUA_TUSERDATA; \ + i_o->value.gc=cast(GCObject *, (x)); \ + lua_assert(i_o->value.gc->gch.tt == LUA_TUSERDATA); } + +#define setthvalue(obj,x) \ + { TObject *i_o=(obj); i_o->tt=LUA_TTHREAD; \ + i_o->value.gc=cast(GCObject *, (x)); \ + lua_assert(i_o->value.gc->gch.tt == LUA_TTHREAD); } + +#define setclvalue(obj,x) \ + { TObject *i_o=(obj); i_o->tt=LUA_TFUNCTION; \ + i_o->value.gc=cast(GCObject *, (x)); \ + lua_assert(i_o->value.gc->gch.tt == LUA_TFUNCTION); } + +#define sethvalue(obj,x) \ + { TObject *i_o=(obj); i_o->tt=LUA_TTABLE; \ + i_o->value.gc=cast(GCObject *, (x)); \ + lua_assert(i_o->value.gc->gch.tt == LUA_TTABLE); } + +#define setnilvalue(obj) ((obj)->tt=LUA_TNIL) + + + +/* +** for internal debug only +*/ +#define checkconsistency(obj) \ + lua_assert(!iscollectable(obj) || (ttype(obj) == (obj)->value.gc->gch.tt)) + + +#define setobj(obj1,obj2) \ + { const TObject *o2=(obj2); TObject *o1=(obj1); \ + checkconsistency(o2); \ + o1->tt=o2->tt; o1->value = o2->value; } + + +/* +** different types of sets, according to destination +*/ + +/* from stack to (same) stack */ +#define setobjs2s setobj +/* to stack (not from same stack) */ +#define setobj2s setobj +#define setsvalue2s setsvalue +/* from table to same table */ +#define setobjt2t setobj +/* to table */ +#define setobj2t setobj +/* to new object */ +#define setobj2n setobj +#define setsvalue2n setsvalue + +#define setttype(obj, tt) (ttype(obj) = (tt)) + + +#define iscollectable(o) (ttype(o) >= LUA_TSTRING) + + + +typedef TObject *StkId; /* index to stack elements */ + + +/* +** String headers for string table +*/ +typedef union TString { + L_Umaxalign dummy; /* ensures maximum alignment for strings */ + struct { + CommonHeader; + lu_byte reserved; + lu_hash hash; + size_t len; + } tsv; +} TString; + + +#define getstr(ts) cast(const char *, (ts) + 1) +#define svalue(o) getstr(tsvalue(o)) + + + +typedef union Udata { + L_Umaxalign dummy; /* ensures maximum alignment for `local' udata */ + struct { + CommonHeader; + struct Table *metatable; + size_t len; + } uv; +} Udata; + + + + +/* +** Function Prototypes +*/ +typedef struct Proto { + CommonHeader; + TObject *k; /* constants used by the function */ + Instruction *code; + struct Proto **p; /* functions defined inside the function */ + int *lineinfo; /* map from opcodes to source lines */ + struct LocVar *locvars; /* information about local variables */ + TString **upvalues; /* upvalue names */ + TString *source; + int sizeupvalues; + int sizek; /* size of `k' */ + int sizecode; + int sizelineinfo; + int sizep; /* size of `p' */ + int sizelocvars; + int lineDefined; + GCObject *gclist; + lu_byte nups; /* number of upvalues */ + lu_byte numparams; + lu_byte is_vararg; + lu_byte maxstacksize; +} Proto; + + +typedef struct LocVar { + TString *varname; + int startpc; /* first point where variable is active */ + int endpc; /* first point where variable is dead */ +} LocVar; + + + +/* +** Upvalues +*/ + +typedef struct UpVal { + CommonHeader; + TObject *v; /* points to stack or to its own value */ + TObject value; /* the value (when closed) */ +} UpVal; + + +/* +** Closures +*/ + +#define ClosureHeader \ + CommonHeader; lu_byte isC; lu_byte nupvalues; GCObject *gclist + +typedef struct CClosure { + ClosureHeader; + lua_CFunction f; + TObject upvalue[1]; +} CClosure; + + +typedef struct LClosure { + ClosureHeader; + struct Proto *p; + TObject g; /* global table for this closure */ + UpVal *upvals[1]; +} LClosure; + + +typedef union Closure { + CClosure c; + LClosure l; +} Closure; + + +#define iscfunction(o) (ttype(o) == LUA_TFUNCTION && clvalue(o)->c.isC) +#define isLfunction(o) (ttype(o) == LUA_TFUNCTION && !clvalue(o)->c.isC) + + +/* +** Tables +*/ + +typedef struct Node { + TObject i_key; + TObject i_val; + struct Node *next; /* for chaining */ +} Node; + + +typedef struct Table { + CommonHeader; + lu_byte flags; /* 1<

lsizenode)) + + + +extern const TObject luaO_nilobject; + +int luaO_log2 (unsigned int x); +int luaO_int2fb (unsigned int x); +#define fb2int(x) (((x) & 7) << ((x) >> 3)) + +int luaO_rawequalObj (const TObject *t1, const TObject *t2); +int luaO_str2d (const char *s, lua_Number *result); + +const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp); +const char *luaO_pushfstring (lua_State *L, const char *fmt, ...); +void luaO_chunkid (char *out, const char *source, int len); + + +#endif diff --git a/stepmania/src/lua-5.0/src/lopcodes.c b/stepmania/src/lua-5.0/src/lopcodes.c new file mode 100644 index 0000000000..d92f396f49 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lopcodes.c @@ -0,0 +1,102 @@ +/* +** $Id$ +** extracted automatically from lopcodes.h by mkprint.lua +** DO NOT EDIT +** See Copyright Notice in lua.h +*/ + + +#define lopcodes_c + +#include "lua.h" + +#include "lobject.h" +#include "lopcodes.h" + + +#ifdef LUA_OPNAMES + +const char *const luaP_opnames[] = { + "MOVE", + "LOADK", + "LOADBOOL", + "LOADNIL", + "GETUPVAL", + "GETGLOBAL", + "GETTABLE", + "SETGLOBAL", + "SETUPVAL", + "SETTABLE", + "NEWTABLE", + "SELF", + "ADD", + "SUB", + "MUL", + "DIV", + "POW", + "UNM", + "NOT", + "CONCAT", + "JMP", + "EQ", + "LT", + "LE", + "TEST", + "CALL", + "TAILCALL", + "RETURN", + "FORLOOP", + "TFORLOOP", + "TFORPREP", + "SETLIST", + "SETLISTO", + "CLOSE", + "CLOSURE" +}; + +#endif + +#define opmode(t,b,bk,ck,sa,k,m) (((t)<>1) /* `sBx' is signed */ +#else +#define MAXARG_Bx MAX_INT +#define MAXARG_sBx MAX_INT +#endif + + +#define MAXARG_A ((1<>POS_A)) +#define SETARG_A(i,u) ((i) = (((i)&MASK0(SIZE_A,POS_A)) | \ + ((cast(Instruction, u)<>POS_B) & MASK1(SIZE_B,0))) +#define SETARG_B(i,b) ((i) = (((i)&MASK0(SIZE_B,POS_B)) | \ + ((cast(Instruction, b)<>POS_C) & MASK1(SIZE_C,0))) +#define SETARG_C(i,b) ((i) = (((i)&MASK0(SIZE_C,POS_C)) | \ + ((cast(Instruction, b)<>POS_Bx) & MASK1(SIZE_Bx,0))) +#define SETARG_Bx(i,b) ((i) = (((i)&MASK0(SIZE_Bx,POS_Bx)) | \ + ((cast(Instruction, b)< C) then R(A) := R(B) else pc++ */ + +OP_CALL,/* A B C R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */ +OP_TAILCALL,/* A B C return R(A)(R(A+1), ... ,R(A+B-1)) */ +OP_RETURN,/* A B return R(A), ... ,R(A+B-2) (see note) */ + +OP_FORLOOP,/* A sBx R(A)+=R(A+2); if R(A) =) R(A)*/ +OP_CLOSURE/* A Bx R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n)) */ +} OpCode; + + +#define NUM_OPCODES (cast(int, OP_CLOSURE+1)) + + + +/*=========================================================================== + Notes: + (1) In OP_CALL, if (B == 0) then B = top. C is the number of returns - 1, + and can be 0: OP_CALL then sets `top' to last_result+1, so + next open instruction (OP_CALL, OP_RETURN, OP_SETLIST) may use `top'. + + (2) In OP_RETURN, if (B == 0) then return up to `top' + + (3) For comparisons, B specifies what conditions the test should accept. + + (4) All `skips' (pc++) assume that next instruction is a jump +===========================================================================*/ + + +/* +** masks for instruction properties +*/ +enum OpModeMask { + OpModeBreg = 2, /* B is a register */ + OpModeBrk, /* B is a register/constant */ + OpModeCrk, /* C is a register/constant */ + OpModesetA, /* instruction set register A */ + OpModeK, /* Bx is a constant */ + OpModeT /* operator is a test */ + +}; + + +extern const lu_byte luaP_opmodes[NUM_OPCODES]; + +#define getOpMode(m) (cast(enum OpMode, luaP_opmodes[m] & 3)) +#define testOpMode(m, b) (luaP_opmodes[m] & (1 << (b))) + + +#ifdef LUA_OPNAMES +extern const char *const luaP_opnames[]; /* opcode names */ +#endif + + + +/* number of list items to accumulate before a SETLIST instruction */ +/* (must be a power of 2) */ +#define LFIELDS_PER_FLUSH 32 + + +#endif diff --git a/stepmania/src/lua-5.0/src/lparser.c b/stepmania/src/lua-5.0/src/lparser.c new file mode 100644 index 0000000000..c69141601e --- /dev/null +++ b/stepmania/src/lua-5.0/src/lparser.c @@ -0,0 +1,1333 @@ +/* +** $Id$ +** Lua Parser +** See Copyright Notice in lua.h +*/ + + +#include + +#define lparser_c + +#include "lua.h" + +#include "lcode.h" +#include "ldebug.h" +#include "lfunc.h" +#include "llex.h" +#include "lmem.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lparser.h" +#include "lstate.h" +#include "lstring.h" + + + + +#define getlocvar(fs, i) ((fs)->f->locvars[(fs)->actvar[i]]) + + +#define enterlevel(ls) if (++(ls)->nestlevel > LUA_MAXPARSERLEVEL) \ + luaX_syntaxerror(ls, "too many syntax levels"); +#define leavelevel(ls) ((ls)->nestlevel--) + + +/* +** nodes for block list (list of active blocks) +*/ +typedef struct BlockCnt { + struct BlockCnt *previous; /* chain */ + int breaklist; /* list of jumps out of this loop */ + int nactvar; /* # active local variables outside the breakable structure */ + int upval; /* true if some variable in the block is an upvalue */ + int isbreakable; /* true if `block' is a loop */ +} BlockCnt; + + + +/* +** prototypes for recursive non-terminal functions +*/ +static void chunk (LexState *ls); +static void expr (LexState *ls, expdesc *v); + + + +static void 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 = luaX_lex(ls, &ls->t.seminfo); /* read next token */ +} + + +static void lookahead (LexState *ls) { + lua_assert(ls->lookahead.token == TK_EOS); + ls->lookahead.token = luaX_lex(ls, &ls->lookahead.seminfo); +} + + +static void error_expected (LexState *ls, int token) { + luaX_syntaxerror(ls, + luaO_pushfstring(ls->L, "`%s' expected", luaX_token2str(ls, token))); +} + + +static int testnext (LexState *ls, int c) { + if (ls->t.token == c) { + next(ls); + return 1; + } + else return 0; +} + + +static void check (LexState *ls, int c) { + if (!testnext(ls, c)) + error_expected(ls, c); +} + + +#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } + + + +static void check_match (LexState *ls, int what, int who, int where) { + if (!testnext(ls, what)) { + if (where == ls->linenumber) + error_expected(ls, what); + else { + luaX_syntaxerror(ls, luaO_pushfstring(ls->L, + "`%s' expected (to close `%s' at line %d)", + luaX_token2str(ls, what), luaX_token2str(ls, who), where)); + } + } +} + + +static TString *str_checkname (LexState *ls) { + TString *ts; + check_condition(ls, (ls->t.token == TK_NAME), " expected"); + ts = ls->t.seminfo.ts; + next(ls); + return ts; +} + + +static void init_exp (expdesc *e, expkind k, int i) { + e->f = e->t = NO_JUMP; + e->k = k; + e->info = i; +} + + +static void codestring (LexState *ls, expdesc *e, TString *s) { + init_exp(e, VK, luaK_stringK(ls->fs, s)); +} + + +static void checkname(LexState *ls, expdesc *e) { + codestring(ls, e, str_checkname(ls)); +} + + +static int luaI_registerlocalvar (LexState *ls, TString *varname) { + FuncState *fs = ls->fs; + Proto *f = fs->f; + luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars, + LocVar, MAX_INT, ""); + f->locvars[fs->nlocvars].varname = varname; + return fs->nlocvars++; +} + + +static void new_localvar (LexState *ls, TString *name, int n) { + FuncState *fs = ls->fs; + luaX_checklimit(ls, fs->nactvar+n+1, MAXVARS, "local variables"); + fs->actvar[fs->nactvar+n] = luaI_registerlocalvar(ls, name); +} + + +static void adjustlocalvars (LexState *ls, int nvars) { + FuncState *fs = ls->fs; + fs->nactvar += nvars; + for (; nvars; nvars--) { + getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc; + } +} + + +static void removevars (LexState *ls, int tolevel) { + FuncState *fs = ls->fs; + while (fs->nactvar > tolevel) + getlocvar(fs, --fs->nactvar).endpc = fs->pc; +} + + +static void new_localvarstr (LexState *ls, const char *name, int n) { + new_localvar(ls, luaS_new(ls->L, name), n); +} + + +static void create_local (LexState *ls, const char *name) { + new_localvarstr(ls, name, 0); + adjustlocalvars(ls, 1); +} + + +static int indexupvalue (FuncState *fs, TString *name, expdesc *v) { + int i; + Proto *f = fs->f; + for (i=0; inups; i++) { + if (fs->upvalues[i].k == v->k && fs->upvalues[i].info == v->info) { + lua_assert(fs->f->upvalues[i] == name); + return i; + } + } + /* new one */ + luaX_checklimit(fs->ls, f->nups + 1, MAXUPVALUES, "upvalues"); + luaM_growvector(fs->L, fs->f->upvalues, f->nups, fs->f->sizeupvalues, + TString *, MAX_INT, ""); + fs->f->upvalues[f->nups] = name; + fs->upvalues[f->nups] = *v; + return f->nups++; +} + + +static int searchvar (FuncState *fs, TString *n) { + int i; + for (i=fs->nactvar-1; i >= 0; i--) { + if (n == getlocvar(fs, i).varname) + return i; + } + return -1; /* not found */ +} + + +static void markupval (FuncState *fs, int level) { + BlockCnt *bl = fs->bl; + while (bl && bl->nactvar > level) bl = bl->previous; + if (bl) bl->upval = 1; +} + + +static void singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) { + if (fs == NULL) /* no more levels? */ + init_exp(var, VGLOBAL, NO_REG); /* default is global variable */ + else { + int v = searchvar(fs, n); /* look up at current level */ + if (v >= 0) { + init_exp(var, VLOCAL, v); + if (!base) + markupval(fs, v); /* local will be used as an upval */ + } + else { /* not found at current level; try upper one */ + singlevaraux(fs->prev, n, var, 0); + if (var->k == VGLOBAL) { + if (base) + var->info = luaK_stringK(fs, n); /* info points to global name */ + } + else { /* LOCAL or UPVAL */ + var->info = indexupvalue(fs, n, var); + var->k = VUPVAL; /* upvalue in this level */ + } + } + } +} + + +static TString *singlevar (LexState *ls, expdesc *var, int base) { + TString *varname = str_checkname(ls); + singlevaraux(ls->fs, varname, var, base); + return varname; +} + + +static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) { + FuncState *fs = ls->fs; + int extra = nvars - nexps; + if (e->k == VCALL) { + extra++; /* includes call itself */ + if (extra <= 0) extra = 0; + else luaK_reserveregs(fs, extra-1); + luaK_setcallreturns(fs, e, extra); /* call provides the difference */ + } + else { + if (e->k != VVOID) luaK_exp2nextreg(fs, e); /* close last expression */ + if (extra > 0) { + int reg = fs->freereg; + luaK_reserveregs(fs, extra); + luaK_nil(fs, reg, extra); + } + } +} + + +static void code_params (LexState *ls, int nparams, int dots) { + FuncState *fs = ls->fs; + adjustlocalvars(ls, nparams); + luaX_checklimit(ls, fs->nactvar, MAXPARAMS, "parameters"); + fs->f->numparams = cast(lu_byte, fs->nactvar); + fs->f->is_vararg = cast(lu_byte, dots); + if (dots) + create_local(ls, "arg"); + luaK_reserveregs(fs, fs->nactvar); /* reserve register for parameters */ +} + + +static void enterblock (FuncState *fs, BlockCnt *bl, int isbreakable) { + bl->breaklist = NO_JUMP; + bl->isbreakable = isbreakable; + bl->nactvar = fs->nactvar; + bl->upval = 0; + bl->previous = fs->bl; + fs->bl = bl; + lua_assert(fs->freereg == fs->nactvar); +} + + +static void leaveblock (FuncState *fs) { + BlockCnt *bl = fs->bl; + fs->bl = bl->previous; + removevars(fs->ls, bl->nactvar); + if (bl->upval) + luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0); + lua_assert(bl->nactvar == fs->nactvar); + fs->freereg = fs->nactvar; /* free registers */ + luaK_patchtohere(fs, bl->breaklist); +} + + +static void pushclosure (LexState *ls, FuncState *func, expdesc *v) { + FuncState *fs = ls->fs; + Proto *f = fs->f; + int i; + luaM_growvector(ls->L, f->p, fs->np, f->sizep, Proto *, + MAXARG_Bx, "constant table overflow"); + f->p[fs->np++] = func->f; + init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np-1)); + for (i=0; if->nups; i++) { + OpCode o = (func->upvalues[i].k == VLOCAL) ? OP_MOVE : OP_GETUPVAL; + luaK_codeABC(fs, o, 0, func->upvalues[i].info, 0); + } +} + + +static void open_func (LexState *ls, FuncState *fs) { + Proto *f = luaF_newproto(ls->L); + fs->f = f; + fs->prev = ls->fs; /* linked list of funcstates */ + fs->ls = ls; + fs->L = ls->L; + ls->fs = fs; + fs->pc = 0; + fs->lasttarget = 0; + fs->jpc = NO_JUMP; + fs->freereg = 0; + fs->nk = 0; + fs->h = luaH_new(ls->L, 0, 0); + fs->np = 0; + fs->nlocvars = 0; + fs->nactvar = 0; + fs->bl = NULL; + f->source = ls->source; + f->maxstacksize = 2; /* registers 0/1 are always valid */ +} + + +static void close_func (LexState *ls) { + lua_State *L = ls->L; + FuncState *fs = ls->fs; + Proto *f = fs->f; + removevars(ls, 0); + luaK_codeABC(fs, OP_RETURN, 0, 1, 0); /* final return */ + luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction); + f->sizecode = fs->pc; + luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int); + f->sizelineinfo = fs->pc; + luaM_reallocvector(L, f->k, f->sizek, fs->nk, TObject); + f->sizek = fs->nk; + luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *); + f->sizep = fs->np; + luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar); + f->sizelocvars = fs->nlocvars; + luaM_reallocvector(L, f->upvalues, f->sizeupvalues, f->nups, TString *); + f->sizeupvalues = f->nups; + lua_assert(luaG_checkcode(f)); + lua_assert(fs->bl == NULL); + ls->fs = fs->prev; +} + + +Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff) { + struct LexState lexstate; + struct FuncState funcstate; + lexstate.buff = buff; + lexstate.nestlevel = 0; + luaX_setinput(L, &lexstate, z, luaS_new(L, zname(z))); + open_func(&lexstate, &funcstate); + next(&lexstate); /* read first token */ + chunk(&lexstate); + check_condition(&lexstate, (lexstate.t.token == TK_EOS), " expected"); + close_func(&lexstate); + lua_assert(funcstate.prev == NULL); + lua_assert(funcstate.f->nups == 0); + lua_assert(lexstate.nestlevel == 0); + return funcstate.f; +} + + + +/*============================================================*/ +/* GRAMMAR RULES */ +/*============================================================*/ + + +static void luaY_field (LexState *ls, expdesc *v) { + /* field -> ['.' | ':'] NAME */ + FuncState *fs = ls->fs; + expdesc key; + luaK_exp2anyreg(fs, v); + next(ls); /* skip the dot or colon */ + checkname(ls, &key); + luaK_indexed(fs, v, &key); +} + + +static void luaY_index (LexState *ls, expdesc *v) { + /* index -> '[' expr ']' */ + next(ls); /* skip the '[' */ + expr(ls, v); + luaK_exp2val(ls->fs, v); + check(ls, ']'); +} + + +/* +** {====================================================================== +** Rules for Constructors +** ======================================================================= +*/ + + +struct ConsControl { + expdesc v; /* last list item read */ + expdesc *t; /* table descriptor */ + int nh; /* total number of `record' elements */ + int na; /* total number of array elements */ + int tostore; /* number of array elements pending to be stored */ +}; + + +static void recfield (LexState *ls, struct ConsControl *cc) { + /* recfield -> (NAME | `['exp1`]') = exp1 */ + FuncState *fs = ls->fs; + int reg = ls->fs->freereg; + expdesc key, val; + if (ls->t.token == TK_NAME) { + luaX_checklimit(ls, cc->nh, MAX_INT, "items in a constructor"); + cc->nh++; + checkname(ls, &key); + } + else /* ls->t.token == '[' */ + luaY_index(ls, &key); + check(ls, '='); + luaK_exp2RK(fs, &key); + expr(ls, &val); + luaK_codeABC(fs, OP_SETTABLE, cc->t->info, luaK_exp2RK(fs, &key), + luaK_exp2RK(fs, &val)); + fs->freereg = reg; /* free registers */ +} + + +static void closelistfield (FuncState *fs, struct ConsControl *cc) { + if (cc->v.k == VVOID) return; /* there is no list item */ + luaK_exp2nextreg(fs, &cc->v); + cc->v.k = VVOID; + if (cc->tostore == LFIELDS_PER_FLUSH) { + luaK_codeABx(fs, OP_SETLIST, cc->t->info, cc->na-1); /* flush */ + cc->tostore = 0; /* no more items pending */ + fs->freereg = cc->t->info + 1; /* free registers */ + } +} + + +static void lastlistfield (FuncState *fs, struct ConsControl *cc) { + if (cc->tostore == 0) return; + if (cc->v.k == VCALL) { + luaK_setcallreturns(fs, &cc->v, LUA_MULTRET); + luaK_codeABx(fs, OP_SETLISTO, cc->t->info, cc->na-1); + } + else { + if (cc->v.k != VVOID) + luaK_exp2nextreg(fs, &cc->v); + luaK_codeABx(fs, OP_SETLIST, cc->t->info, cc->na-1); + } + fs->freereg = cc->t->info + 1; /* free registers */ +} + + +static void listfield (LexState *ls, struct ConsControl *cc) { + expr(ls, &cc->v); + luaX_checklimit(ls, cc->na, MAXARG_Bx, "items in a constructor"); + cc->na++; + cc->tostore++; +} + + +static void constructor (LexState *ls, expdesc *t) { + /* constructor -> ?? */ + FuncState *fs = ls->fs; + int line = ls->linenumber; + int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0); + struct ConsControl cc; + cc.na = cc.nh = cc.tostore = 0; + cc.t = t; + init_exp(t, VRELOCABLE, pc); + init_exp(&cc.v, VVOID, 0); /* no value (yet) */ + luaK_exp2nextreg(ls->fs, t); /* fix it at stack top (for gc) */ + check(ls, '{'); + do { + lua_assert(cc.v.k == VVOID || cc.tostore > 0); + testnext(ls, ';'); /* compatibility only */ + if (ls->t.token == '}') break; + closelistfield(fs, &cc); + switch(ls->t.token) { + case TK_NAME: { /* may be listfields or recfields */ + lookahead(ls); + if (ls->lookahead.token != '=') /* expression? */ + listfield(ls, &cc); + else + recfield(ls, &cc); + break; + } + case '[': { /* constructor_item -> recfield */ + recfield(ls, &cc); + break; + } + default: { /* constructor_part -> listfield */ + listfield(ls, &cc); + break; + } + } + } while (testnext(ls, ',') || testnext(ls, ';')); + check_match(ls, '}', '{', line); + lastlistfield(fs, &cc); + SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */ + SETARG_C(fs->f->code[pc], luaO_log2(cc.nh)+1); /* set initial table size */ +} + +/* }====================================================================== */ + + + +static void parlist (LexState *ls) { + /* parlist -> [ param { `,' param } ] */ + int nparams = 0; + int dots = 0; + if (ls->t.token != ')') { /* is `parlist' not empty? */ + do { + switch (ls->t.token) { + case TK_DOTS: dots = 1; next(ls); break; + case TK_NAME: new_localvar(ls, str_checkname(ls), nparams++); break; + default: luaX_syntaxerror(ls, " or `...' expected"); + } + } while (!dots && testnext(ls, ',')); + } + code_params(ls, nparams, dots); +} + + +static void body (LexState *ls, expdesc *e, int needself, int line) { + /* body -> `(' parlist `)' chunk END */ + FuncState new_fs; + open_func(ls, &new_fs); + new_fs.f->lineDefined = line; + check(ls, '('); + if (needself) + create_local(ls, "self"); + parlist(ls); + check(ls, ')'); + chunk(ls); + check_match(ls, TK_END, TK_FUNCTION, line); + close_func(ls); + pushclosure(ls, &new_fs, e); +} + + +static int explist1 (LexState *ls, expdesc *v) { + /* explist1 -> expr { `,' expr } */ + int n = 1; /* at least one expression */ + expr(ls, v); + while (testnext(ls, ',')) { + luaK_exp2nextreg(ls->fs, v); + expr(ls, v); + n++; + } + return n; +} + + +static void funcargs (LexState *ls, expdesc *f) { + FuncState *fs = ls->fs; + expdesc args; + int base, nparams; + int line = ls->linenumber; + switch (ls->t.token) { + case '(': { /* funcargs -> `(' [ explist1 ] `)' */ + if (line != ls->lastline) + luaX_syntaxerror(ls,"ambiguous syntax (function call x new statement)"); + next(ls); + if (ls->t.token == ')') /* arg list is empty? */ + args.k = VVOID; + else { + explist1(ls, &args); + luaK_setcallreturns(fs, &args, LUA_MULTRET); + } + check_match(ls, ')', '(', line); + break; + } + case '{': { /* funcargs -> constructor */ + constructor(ls, &args); + break; + } + case TK_STRING: { /* funcargs -> STRING */ + codestring(ls, &args, ls->t.seminfo.ts); + next(ls); /* must use `seminfo' before `next' */ + break; + } + default: { + luaX_syntaxerror(ls, "function arguments expected"); + return; + } + } + lua_assert(f->k == VNONRELOC); + base = f->info; /* base register for call */ + if (args.k == VCALL) + nparams = LUA_MULTRET; /* open call */ + else { + if (args.k != VVOID) + luaK_exp2nextreg(fs, &args); /* close last argument */ + nparams = fs->freereg - (base+1); + } + init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2)); + luaK_fixline(fs, line); + fs->freereg = base+1; /* call remove function and arguments and leaves + (unless changed) one result */ +} + + + + +/* +** {====================================================================== +** Expression parsing +** ======================================================================= +*/ + + +static void prefixexp (LexState *ls, expdesc *v) { + /* prefixexp -> NAME | '(' expr ')' */ + switch (ls->t.token) { + case '(': { + int line = ls->linenumber; + next(ls); + expr(ls, v); + check_match(ls, ')', '(', line); + luaK_dischargevars(ls->fs, v); + return; + } + case TK_NAME: { + singlevar(ls, v, 1); + return; + } +#ifdef LUA_COMPATUPSYNTAX + case '%': { /* for compatibility only */ + TString *varname; + int line = ls->linenumber; + next(ls); /* skip `%' */ + varname = singlevar(ls, v, 1); + if (v->k != VUPVAL) + luaX_errorline(ls, "global upvalues are obsolete", + getstr(varname), line); + return; + } +#endif + default: { + luaX_syntaxerror(ls, "unexpected symbol"); + return; + } + } +} + + +static void primaryexp (LexState *ls, expdesc *v) { + /* primaryexp -> + prefixexp { `.' NAME | `[' exp `]' | `:' NAME funcargs | funcargs } */ + FuncState *fs = ls->fs; + prefixexp(ls, v); + for (;;) { + switch (ls->t.token) { + case '.': { /* field */ + luaY_field(ls, v); + break; + } + case '[': { /* `[' exp1 `]' */ + expdesc key; + luaK_exp2anyreg(fs, v); + luaY_index(ls, &key); + luaK_indexed(fs, v, &key); + break; + } + case ':': { /* `:' NAME funcargs */ + expdesc key; + next(ls); + checkname(ls, &key); + luaK_self(fs, v, &key); + funcargs(ls, v); + break; + } + case '(': case TK_STRING: case '{': { /* funcargs */ + luaK_exp2nextreg(fs, v); + funcargs(ls, v); + break; + } + default: return; + } + } +} + + +static void simpleexp (LexState *ls, expdesc *v) { + /* simpleexp -> NUMBER | STRING | NIL | constructor | FUNCTION body + | primaryexp */ + switch (ls->t.token) { + case TK_NUMBER: { + init_exp(v, VK, luaK_numberK(ls->fs, ls->t.seminfo.r)); + next(ls); /* must use `seminfo' before `next' */ + break; + } + case TK_STRING: { + codestring(ls, v, ls->t.seminfo.ts); + next(ls); /* must use `seminfo' before `next' */ + break; + } + case TK_NIL: { + init_exp(v, VNIL, 0); + next(ls); + break; + } + case TK_TRUE: { + init_exp(v, VTRUE, 0); + next(ls); + break; + } + case TK_FALSE: { + init_exp(v, VFALSE, 0); + next(ls); + break; + } + case '{': { /* constructor */ + constructor(ls, v); + break; + } + case TK_FUNCTION: { + next(ls); + body(ls, v, 0, ls->linenumber); + break; + } + default: { + primaryexp(ls, v); + break; + } + } +} + + +static UnOpr getunopr (int op) { + switch (op) { + case TK_NOT: return OPR_NOT; + case '-': return OPR_MINUS; + default: return OPR_NOUNOPR; + } +} + + +static BinOpr getbinopr (int op) { + switch (op) { + case '+': return OPR_ADD; + case '-': return OPR_SUB; + case '*': return OPR_MULT; + case '/': return OPR_DIV; + case '^': return OPR_POW; + case TK_CONCAT: return OPR_CONCAT; + case TK_NE: return OPR_NE; + case TK_EQ: return OPR_EQ; + case '<': return OPR_LT; + case TK_LE: return OPR_LE; + case '>': return OPR_GT; + case TK_GE: return OPR_GE; + case TK_AND: return OPR_AND; + case TK_OR: return OPR_OR; + default: return OPR_NOBINOPR; + } +} + + +static const struct { + lu_byte left; /* left priority for each binary operator */ + lu_byte right; /* right priority */ +} priority[] = { /* ORDER OPR */ + {6, 6}, {6, 6}, {7, 7}, {7, 7}, /* arithmetic */ + {10, 9}, {5, 4}, /* power and concat (right associative) */ + {3, 3}, {3, 3}, /* equality */ + {3, 3}, {3, 3}, {3, 3}, {3, 3}, /* order */ + {2, 2}, {1, 1} /* logical (and/or) */ +}; + +#define UNARY_PRIORITY 8 /* priority for unary operators */ + + +/* +** subexpr -> (simplexep | unop subexpr) { binop subexpr } +** where `binop' is any binary operator with a priority higher than `limit' +*/ +static BinOpr subexpr (LexState *ls, expdesc *v, int limit) { + BinOpr op; + UnOpr uop; + enterlevel(ls); + uop = getunopr(ls->t.token); + if (uop != OPR_NOUNOPR) { + next(ls); + subexpr(ls, v, UNARY_PRIORITY); + luaK_prefix(ls->fs, uop, v); + } + else simpleexp(ls, v); + /* expand while operators have priorities higher than `limit' */ + op = getbinopr(ls->t.token); + while (op != OPR_NOBINOPR && cast(int, priority[op].left) > limit) { + expdesc v2; + BinOpr nextop; + next(ls); + luaK_infix(ls->fs, op, v); + /* read sub-expression with higher priority */ + nextop = subexpr(ls, &v2, cast(int, priority[op].right)); + luaK_posfix(ls->fs, op, v, &v2); + op = nextop; + } + leavelevel(ls); + return op; /* return first untreated operator */ +} + + +static void expr (LexState *ls, expdesc *v) { + subexpr(ls, v, -1); +} + +/* }==================================================================== */ + + + +/* +** {====================================================================== +** Rules for Statements +** ======================================================================= +*/ + + +static int block_follow (int token) { + switch (token) { + case TK_ELSE: case TK_ELSEIF: case TK_END: + case TK_UNTIL: case TK_EOS: + return 1; + default: return 0; + } +} + + +static void block (LexState *ls) { + /* block -> chunk */ + FuncState *fs = ls->fs; + BlockCnt bl; + enterblock(fs, &bl, 0); + chunk(ls); + lua_assert(bl.breaklist == NO_JUMP); + leaveblock(fs); +} + + +/* +** structure to chain all variables in the left-hand side of an +** assignment +*/ +struct LHS_assign { + struct LHS_assign *prev; + expdesc v; /* variable (global, local, upvalue, or indexed) */ +}; + + +/* +** check whether, in an assignment to a local variable, the local variable +** is needed in a previous assignment (to a table). If so, save original +** local value in a safe place and use this safe copy in the previous +** assignment. +*/ +static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) { + FuncState *fs = ls->fs; + int extra = fs->freereg; /* eventual position to save local variable */ + int conflict = 0; + for (; lh; lh = lh->prev) { + if (lh->v.k == VINDEXED) { + if (lh->v.info == v->info) { /* conflict? */ + conflict = 1; + lh->v.info = extra; /* previous assignment will use safe copy */ + } + if (lh->v.aux == v->info) { /* conflict? */ + conflict = 1; + lh->v.aux = extra; /* previous assignment will use safe copy */ + } + } + } + if (conflict) { + luaK_codeABC(fs, OP_MOVE, fs->freereg, v->info, 0); /* make copy */ + luaK_reserveregs(fs, 1); + } +} + + +static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) { + expdesc e; + check_condition(ls, VLOCAL <= lh->v.k && lh->v.k <= VINDEXED, + "syntax error"); + if (testnext(ls, ',')) { /* assignment -> `,' primaryexp assignment */ + struct LHS_assign nv; + nv.prev = lh; + primaryexp(ls, &nv.v); + if (nv.v.k == VLOCAL) + check_conflict(ls, lh, &nv.v); + assignment(ls, &nv, nvars+1); + } + else { /* assignment -> `=' explist1 */ + int nexps; + check(ls, '='); + nexps = explist1(ls, &e); + if (nexps != nvars) { + adjust_assign(ls, nvars, nexps, &e); + if (nexps > nvars) + ls->fs->freereg -= nexps - nvars; /* remove extra values */ + } + else { + luaK_setcallreturns(ls->fs, &e, 1); /* close last expression */ + luaK_storevar(ls->fs, &lh->v, &e); + return; /* avoid default */ + } + } + init_exp(&e, VNONRELOC, ls->fs->freereg-1); /* default assignment */ + luaK_storevar(ls->fs, &lh->v, &e); +} + + +static void cond (LexState *ls, expdesc *v) { + /* cond -> exp */ + expr(ls, v); /* read condition */ + if (v->k == VNIL) v->k = VFALSE; /* `falses' are all equal here */ + luaK_goiftrue(ls->fs, v); + luaK_patchtohere(ls->fs, v->t); +} + + +/* +** The while statement optimizes its code by coding the condition +** after its body (and thus avoiding one jump in the loop). +*/ + +/* +** maximum size of expressions for optimizing `while' code +*/ +#ifndef MAXEXPWHILE +#define MAXEXPWHILE 100 +#endif + +/* +** the call `luaK_goiffalse' may grow the size of an expression by +** at most this: +*/ +#define EXTRAEXP 5 + +static void whilestat (LexState *ls, int line) { + /* whilestat -> WHILE cond DO block END */ + Instruction codeexp[MAXEXPWHILE + EXTRAEXP]; + int lineexp; + int i; + int sizeexp; + FuncState *fs = ls->fs; + int whileinit, blockinit, expinit; + expdesc v; + BlockCnt bl; + next(ls); /* skip WHILE */ + whileinit = luaK_jump(fs); /* jump to condition (which will be moved) */ + expinit = luaK_getlabel(fs); + expr(ls, &v); /* parse condition */ + if (v.k == VK) v.k = VTRUE; /* `trues' are all equal here */ + lineexp = ls->linenumber; + luaK_goiffalse(fs, &v); + luaK_concat(fs, &v.f, fs->jpc); + fs->jpc = NO_JUMP; + sizeexp = fs->pc - expinit; /* size of expression code */ + if (sizeexp > MAXEXPWHILE) + luaX_syntaxerror(ls, "`while' condition too complex"); + for (i = 0; i < sizeexp; i++) /* save `exp' code */ + codeexp[i] = fs->f->code[expinit + i]; + fs->pc = expinit; /* remove `exp' code */ + enterblock(fs, &bl, 1); + check(ls, TK_DO); + blockinit = luaK_getlabel(fs); + block(ls); + luaK_patchtohere(fs, whileinit); /* initial jump jumps to here */ + /* move `exp' back to code */ + if (v.t != NO_JUMP) v.t += fs->pc - expinit; + if (v.f != NO_JUMP) v.f += fs->pc - expinit; + for (i=0; i REPEAT block UNTIL cond */ + FuncState *fs = ls->fs; + int repeat_init = luaK_getlabel(fs); + expdesc v; + BlockCnt bl; + enterblock(fs, &bl, 1); + next(ls); + block(ls); + check_match(ls, TK_UNTIL, TK_REPEAT, line); + cond(ls, &v); + luaK_patchlist(fs, v.f, repeat_init); + leaveblock(fs); +} + + +static int exp1 (LexState *ls) { + expdesc e; + int k; + expr(ls, &e); + k = e.k; + luaK_exp2nextreg(ls->fs, &e); + return k; +} + + +static void forbody (LexState *ls, int base, int line, int nvars, int isnum) { + BlockCnt bl; + FuncState *fs = ls->fs; + int prep, endfor; + adjustlocalvars(ls, nvars); /* scope for all variables */ + check(ls, TK_DO); + enterblock(fs, &bl, 1); /* loop block */ + prep = luaK_getlabel(fs); + block(ls); + luaK_patchtohere(fs, prep-1); + endfor = (isnum) ? luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP) : + luaK_codeABC(fs, OP_TFORLOOP, base, 0, nvars - 3); + luaK_fixline(fs, line); /* pretend that `OP_FOR' starts the loop */ + luaK_patchlist(fs, (isnum) ? endfor : luaK_jump(fs), prep); + leaveblock(fs); +} + + +static void fornum (LexState *ls, TString *varname, int line) { + /* fornum -> NAME = exp1,exp1[,exp1] DO body */ + FuncState *fs = ls->fs; + int base = fs->freereg; + new_localvar(ls, varname, 0); + new_localvarstr(ls, "(for limit)", 1); + new_localvarstr(ls, "(for step)", 2); + check(ls, '='); + exp1(ls); /* initial value */ + check(ls, ','); + exp1(ls); /* limit */ + if (testnext(ls, ',')) + exp1(ls); /* optional step */ + else { /* default step = 1 */ + luaK_codeABx(fs, OP_LOADK, fs->freereg, luaK_numberK(fs, 1)); + luaK_reserveregs(fs, 1); + } + luaK_codeABC(fs, OP_SUB, fs->freereg - 3, fs->freereg - 3, fs->freereg - 1); + luaK_jump(fs); + forbody(ls, base, line, 3, 1); +} + + +static void forlist (LexState *ls, TString *indexname) { + /* forlist -> NAME {,NAME} IN explist1 DO body */ + FuncState *fs = ls->fs; + expdesc e; + int nvars = 0; + int line; + int base = fs->freereg; + new_localvarstr(ls, "(for generator)", nvars++); + new_localvarstr(ls, "(for state)", nvars++); + new_localvar(ls, indexname, nvars++); + while (testnext(ls, ',')) + new_localvar(ls, str_checkname(ls), nvars++); + check(ls, TK_IN); + line = ls->linenumber; + adjust_assign(ls, nvars, explist1(ls, &e), &e); + luaK_checkstack(fs, 3); /* extra space to call generator */ + luaK_codeAsBx(fs, OP_TFORPREP, base, NO_JUMP); + forbody(ls, base, line, nvars, 0); +} + + +static void forstat (LexState *ls, int line) { + /* forstat -> fornum | forlist */ + FuncState *fs = ls->fs; + TString *varname; + BlockCnt bl; + enterblock(fs, &bl, 0); /* block to control variable scope */ + next(ls); /* skip `for' */ + varname = str_checkname(ls); /* first variable name */ + switch (ls->t.token) { + case '=': fornum(ls, varname, line); break; + case ',': case TK_IN: forlist(ls, varname); break; + default: luaX_syntaxerror(ls, "`=' or `in' expected"); + } + check_match(ls, TK_END, TK_FOR, line); + leaveblock(fs); +} + + +static void test_then_block (LexState *ls, expdesc *v) { + /* test_then_block -> [IF | ELSEIF] cond THEN block */ + next(ls); /* skip IF or ELSEIF */ + cond(ls, v); + check(ls, TK_THEN); + block(ls); /* `then' part */ +} + + +static void ifstat (LexState *ls, int line) { + /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */ + FuncState *fs = ls->fs; + expdesc v; + int escapelist = NO_JUMP; + test_then_block(ls, &v); /* IF cond THEN block */ + while (ls->t.token == TK_ELSEIF) { + luaK_concat(fs, &escapelist, luaK_jump(fs)); + luaK_patchtohere(fs, v.f); + test_then_block(ls, &v); /* ELSEIF cond THEN block */ + } + if (ls->t.token == TK_ELSE) { + luaK_concat(fs, &escapelist, luaK_jump(fs)); + luaK_patchtohere(fs, v.f); + next(ls); /* skip ELSE (after patch, for correct line info) */ + block(ls); /* `else' part */ + } + else + luaK_concat(fs, &escapelist, v.f); + luaK_patchtohere(fs, escapelist); + check_match(ls, TK_END, TK_IF, line); +} + + +static void localfunc (LexState *ls) { + expdesc v, b; + FuncState *fs = ls->fs; + new_localvar(ls, str_checkname(ls), 0); + init_exp(&v, VLOCAL, fs->freereg); + luaK_reserveregs(fs, 1); + adjustlocalvars(ls, 1); + body(ls, &b, 0, ls->linenumber); + luaK_storevar(fs, &v, &b); + /* debug information will only see the variable after this point! */ + getlocvar(fs, fs->nactvar - 1).startpc = fs->pc; +} + + +static void localstat (LexState *ls) { + /* stat -> LOCAL NAME {`,' NAME} [`=' explist1] */ + int nvars = 0; + int nexps; + expdesc e; + do { + new_localvar(ls, str_checkname(ls), nvars++); + } while (testnext(ls, ',')); + if (testnext(ls, '=')) + nexps = explist1(ls, &e); + else { + e.k = VVOID; + nexps = 0; + } + adjust_assign(ls, nvars, nexps, &e); + adjustlocalvars(ls, nvars); +} + + +static int funcname (LexState *ls, expdesc *v) { + /* funcname -> NAME {field} [`:' NAME] */ + int needself = 0; + singlevar(ls, v, 1); + while (ls->t.token == '.') + luaY_field(ls, v); + if (ls->t.token == ':') { + needself = 1; + luaY_field(ls, v); + } + return needself; +} + + +static void funcstat (LexState *ls, int line) { + /* funcstat -> FUNCTION funcname body */ + int needself; + expdesc v, b; + next(ls); /* skip FUNCTION */ + needself = funcname(ls, &v); + body(ls, &b, needself, line); + luaK_storevar(ls->fs, &v, &b); + luaK_fixline(ls->fs, line); /* definition `happens' in the first line */ +} + + +static void exprstat (LexState *ls) { + /* stat -> func | assignment */ + FuncState *fs = ls->fs; + struct LHS_assign v; + primaryexp(ls, &v.v); + if (v.v.k == VCALL) { /* stat -> func */ + luaK_setcallreturns(fs, &v.v, 0); /* call statement uses no results */ + } + else { /* stat -> assignment */ + v.prev = NULL; + assignment(ls, &v, 1); + } +} + + +static void retstat (LexState *ls) { + /* stat -> RETURN explist */ + FuncState *fs = ls->fs; + expdesc e; + int first, nret; /* registers with returned values */ + next(ls); /* skip RETURN */ + if (block_follow(ls->t.token) || ls->t.token == ';') + first = nret = 0; /* return no values */ + else { + nret = explist1(ls, &e); /* optional return values */ + if (e.k == VCALL) { + luaK_setcallreturns(fs, &e, LUA_MULTRET); + if (nret == 1) { /* tail call? */ + SET_OPCODE(getcode(fs,&e), OP_TAILCALL); + lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar); + } + first = fs->nactvar; + nret = LUA_MULTRET; /* return all values */ + } + else { + if (nret == 1) /* only one single value? */ + first = luaK_exp2anyreg(fs, &e); + else { + luaK_exp2nextreg(fs, &e); /* values must go to the `stack' */ + first = fs->nactvar; /* return all `active' values */ + lua_assert(nret == fs->freereg - first); + } + } + } + luaK_codeABC(fs, OP_RETURN, first, nret+1, 0); +} + + +static void breakstat (LexState *ls) { + /* stat -> BREAK [NAME] */ + FuncState *fs = ls->fs; + BlockCnt *bl = fs->bl; + int upval = 0; + next(ls); /* skip BREAK */ + while (bl && !bl->isbreakable) { + upval |= bl->upval; + bl = bl->previous; + } + if (!bl) + luaX_syntaxerror(ls, "no loop to break"); + if (upval) + luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0); + luaK_concat(fs, &bl->breaklist, luaK_jump(fs)); +} + + +static int statement (LexState *ls) { + int line = ls->linenumber; /* may be needed for error messages */ + switch (ls->t.token) { + case TK_IF: { /* stat -> ifstat */ + ifstat(ls, line); + return 0; + } + case TK_WHILE: { /* stat -> whilestat */ + whilestat(ls, line); + return 0; + } + case TK_DO: { /* stat -> DO block END */ + next(ls); /* skip DO */ + block(ls); + check_match(ls, TK_END, TK_DO, line); + return 0; + } + case TK_FOR: { /* stat -> forstat */ + forstat(ls, line); + return 0; + } + case TK_REPEAT: { /* stat -> repeatstat */ + repeatstat(ls, line); + return 0; + } + case TK_FUNCTION: { + funcstat(ls, line); /* stat -> funcstat */ + return 0; + } + case TK_LOCAL: { /* stat -> localstat */ + next(ls); /* skip LOCAL */ + if (testnext(ls, TK_FUNCTION)) /* local function? */ + localfunc(ls); + else + localstat(ls); + return 0; + } + case TK_RETURN: { /* stat -> retstat */ + retstat(ls); + return 1; /* must be last statement */ + } + case TK_BREAK: { /* stat -> breakstat */ + breakstat(ls); + return 1; /* must be last statement */ + } + default: { + exprstat(ls); + return 0; /* to avoid warnings */ + } + } +} + + +static void chunk (LexState *ls) { + /* chunk -> { stat [`;'] } */ + int islast = 0; + enterlevel(ls); + while (!islast && !block_follow(ls->t.token)) { + islast = statement(ls); + testnext(ls, ';'); + lua_assert(ls->fs->freereg >= ls->fs->nactvar); + ls->fs->freereg = ls->fs->nactvar; /* free registers */ + } + leavelevel(ls); +} + +/* }====================================================================== */ diff --git a/stepmania/src/lua-5.0/src/lparser.h b/stepmania/src/lua-5.0/src/lparser.h new file mode 100644 index 0000000000..a5d315e668 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lparser.h @@ -0,0 +1,71 @@ +/* +** $Id$ +** Lua Parser +** See Copyright Notice in lua.h +*/ + +#ifndef lparser_h +#define lparser_h + +#include "llimits.h" +#include "lobject.h" +#include "ltable.h" +#include "lzio.h" + + +/* +** Expression descriptor +*/ + +typedef enum { + VVOID, /* no value */ + VNIL, + VTRUE, + VFALSE, + VK, /* info = index of constant in `k' */ + VLOCAL, /* info = local register */ + VUPVAL, /* info = index of upvalue in `upvalues' */ + VGLOBAL, /* info = index of table; aux = index of global name in `k' */ + VINDEXED, /* info = table register; aux = index register (or `k') */ + VJMP, /* info = instruction pc */ + VRELOCABLE, /* info = instruction pc */ + VNONRELOC, /* info = result register */ + VCALL /* info = result register */ +} expkind; + +typedef struct expdesc { + expkind k; + int info, aux; + int t; /* patch list of `exit when true' */ + int f; /* patch list of `exit when false' */ +} expdesc; + + +struct BlockCnt; /* defined in lparser.c */ + + +/* state needed to generate code for a given function */ +typedef struct FuncState { + Proto *f; /* current function header */ + Table *h; /* table to find (and reuse) elements in `k' */ + struct FuncState *prev; /* enclosing function */ + struct LexState *ls; /* lexical state */ + struct lua_State *L; /* copy of the Lua state */ + struct BlockCnt *bl; /* chain of current blocks */ + int pc; /* next position to code (equivalent to `ncode') */ + int lasttarget; /* `pc' of last `jump target' */ + int jpc; /* list of pending jumps to `pc' */ + int freereg; /* first free register */ + int nk; /* number of elements in `k' */ + int np; /* number of elements in `p' */ + int nlocvars; /* number of elements in `locvars' */ + int nactvar; /* number of active local variables */ + expdesc upvalues[MAXUPVALUES]; /* upvalues */ + int actvar[MAXVARS]; /* declared-variable stack */ +} FuncState; + + +Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff); + + +#endif diff --git a/stepmania/src/lua-5.0/src/lstate.c b/stepmania/src/lua-5.0/src/lstate.c new file mode 100644 index 0000000000..4e39fec3db --- /dev/null +++ b/stepmania/src/lua-5.0/src/lstate.c @@ -0,0 +1,220 @@ +/* +** $Id$ +** Global State +** See Copyright Notice in lua.h +*/ + + +#include + +#define lstate_c + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lgc.h" +#include "llex.h" +#include "lmem.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" + + +/* +** macro to allow the inclusion of user information in Lua state +*/ +#ifndef LUA_USERSTATE +#define EXTRASPACE 0 +#else +union UEXTRASPACE {L_Umaxalign a; LUA_USERSTATE b;}; +#define EXTRASPACE (sizeof(union UEXTRASPACE)) +#endif + + + +/* +** you can change this function through the official API: +** call `lua_setpanicf' +*/ +static int default_panic (lua_State *L) { + UNUSED(L); + return 0; +} + + +static lua_State *mallocstate (lua_State *L) { + lu_byte *block = (lu_byte *)luaM_malloc(L, sizeof(lua_State) + EXTRASPACE); + if (block == NULL) return NULL; + else { + block += EXTRASPACE; + return cast(lua_State *, block); + } +} + + +static void freestate (lua_State *L, lua_State *L1) { + luaM_free(L, cast(lu_byte *, L1) - EXTRASPACE, + sizeof(lua_State) + EXTRASPACE); +} + + +static void stack_init (lua_State *L1, lua_State *L) { + L1->stack = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, TObject); + L1->stacksize = BASIC_STACK_SIZE + EXTRA_STACK; + L1->top = L1->stack; + L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1; + L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo); + L1->ci = L1->base_ci; + L1->ci->state = CI_C; /* not a Lua function */ + setnilvalue(L1->top++); /* `function' entry for this `ci' */ + L1->base = L1->ci->base = L1->top; + L1->ci->top = L1->top + LUA_MINSTACK; + L1->size_ci = BASIC_CI_SIZE; + L1->end_ci = L1->base_ci + L1->size_ci; +} + + +static void freestack (lua_State *L, lua_State *L1) { + luaM_freearray(L, L1->base_ci, L1->size_ci, CallInfo); + luaM_freearray(L, L1->stack, L1->stacksize, TObject); +} + + +/* +** open parts that may cause memory-allocation errors +*/ +static void f_luaopen (lua_State *L, void *ud) { + /* create a new global state */ + global_State *g = luaM_new(NULL, global_State); + UNUSED(ud); + if (g == NULL) luaD_throw(L, LUA_ERRMEM); + L->l_G = g; + g->mainthread = L; + g->GCthreshold = 0; /* mark it as unfinished state */ + g->strt.size = 0; + g->strt.nuse = 0; + g->strt.hash = NULL; + setnilvalue(defaultmeta(L)); + setnilvalue(registry(L)); + luaZ_initbuffer(L, &g->buff); + g->panic = default_panic; + g->rootgc = NULL; + g->rootudata = NULL; + g->tmudata = NULL; + setnilvalue(gkey(g->dummynode)); + setnilvalue(gval(g->dummynode)); + g->dummynode->next = NULL; + g->nblocks = sizeof(lua_State) + sizeof(global_State); + stack_init(L, L); /* init stack */ + /* create default meta table with a dummy table, and then close the loop */ + defaultmeta(L)->tt = LUA_TTABLE; + sethvalue(defaultmeta(L), luaH_new(L, 0, 0)); + hvalue(defaultmeta(L))->metatable = hvalue(defaultmeta(L)); + sethvalue(gt(L), luaH_new(L, 0, 4)); /* table of globals */ + sethvalue(registry(L), luaH_new(L, 4, 4)); /* registry */ + luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */ + luaT_init(L); + luaX_init(L); + luaS_fix(luaS_newliteral(L, MEMERRMSG)); + g->GCthreshold = 4*G(L)->nblocks; +} + + +static void preinit_state (lua_State *L) { + L->stack = NULL; + L->stacksize = 0; + L->errorJmp = NULL; + L->hook = NULL; + L->hookmask = L->hookinit = 0; + L->basehookcount = 0; + L->allowhook = 1; + resethookcount(L); + L->openupval = NULL; + L->size_ci = 0; + L->nCcalls = 0; + L->base_ci = L->ci = NULL; + L->errfunc = 0; + setnilvalue(gt(L)); +} + + +static void close_state (lua_State *L) { + luaF_close(L, L->stack); /* close all upvalues for this thread */ + if (G(L)) { /* close global state */ + luaC_sweep(L, 1); /* collect all elements */ + lua_assert(G(L)->rootgc == NULL); + lua_assert(G(L)->rootudata == NULL); + luaS_freeall(L); + luaZ_freebuffer(L, &G(L)->buff); + } + freestack(L, L); + if (G(L)) { + lua_assert(G(L)->nblocks == sizeof(lua_State) + sizeof(global_State)); + luaM_freelem(NULL, G(L)); + } + freestate(NULL, L); +} + + +lua_State *luaE_newthread (lua_State *L) { + lua_State *L1 = mallocstate(L); + luaC_link(L, valtogco(L1), LUA_TTHREAD); + preinit_state(L1); + L1->l_G = L->l_G; + stack_init(L1, L); /* init stack */ + setobj2n(gt(L1), gt(L)); /* share table of globals */ + return L1; +} + + +void luaE_freethread (lua_State *L, lua_State *L1) { + luaF_close(L1, L1->stack); /* close all upvalues for this thread */ + lua_assert(L1->openupval == NULL); + freestack(L, L1); + freestate(L, L1); +} + + +LUA_API lua_State *lua_open (void) { + lua_State *L = mallocstate(NULL); + if (L) { /* allocation OK? */ + L->tt = LUA_TTHREAD; + L->marked = 0; + L->next = L->gclist = NULL; + preinit_state(L); + L->l_G = NULL; + if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) { + /* memory allocation error: free partial state */ + close_state(L); + L = NULL; + } + } + lua_userstateopen(L); + return L; +} + + +static void callallgcTM (lua_State *L, void *ud) { + UNUSED(ud); + luaC_callGCTM(L); /* call GC metamethods for all udata */ +} + + +LUA_API void lua_close (lua_State *L) { + lua_lock(L); + L = G(L)->mainthread; /* only the main thread can be closed */ + luaF_close(L, L->stack); /* close all upvalues for this thread */ + luaC_separateudata(L); /* separate udata that have GC metamethods */ + L->errfunc = 0; /* no error function during GC metamethods */ + do { /* repeat until no more errors */ + L->ci = L->base_ci; + L->base = L->top = L->ci->base; + L->nCcalls = 0; + } while (luaD_rawrunprotected(L, callallgcTM, NULL) != 0); + lua_assert(G(L)->tmudata == NULL); + close_state(L); +} + diff --git a/stepmania/src/lua-5.0/src/lstate.h b/stepmania/src/lua-5.0/src/lstate.h new file mode 100644 index 0000000000..9cdf46a7dd --- /dev/null +++ b/stepmania/src/lua-5.0/src/lstate.h @@ -0,0 +1,195 @@ +/* +** $Id$ +** Global State +** See Copyright Notice in lua.h +*/ + +#ifndef lstate_h +#define lstate_h + +#include "lua.h" + +#include "lobject.h" +#include "ltm.h" +#include "lzio.h" + + +/* +** macros for thread synchronization inside Lua core machine: +** all accesses to the global state and to global objects are synchronized. +** Because threads can read the stack of other threads +** (when running garbage collection), +** a thread must also synchronize any write-access to its own stack. +** Unsynchronized accesses are allowed only when reading its own stack, +** or when reading immutable fields from global objects +** (such as string values and udata values). +*/ +#ifndef lua_lock +#define lua_lock(L) ((void) 0) +#endif + +#ifndef lua_unlock +#define lua_unlock(L) ((void) 0) +#endif + + +#ifndef lua_userstateopen +#define lua_userstateopen(l) +#endif + + + +struct lua_longjmp; /* defined in ldo.c */ + + +/* default meta table (both for tables and udata) */ +#define defaultmeta(L) (&G(L)->_defaultmeta) + +/* table of globals */ +#define gt(L) (&L->_gt) + +/* registry */ +#define registry(L) (&G(L)->_registry) + + +/* extra stack space to handle TM calls and some other extras */ +#define EXTRA_STACK 5 + + +#define BASIC_CI_SIZE 8 + +#define BASIC_STACK_SIZE (2*LUA_MINSTACK) + + + +typedef struct stringtable { + GCObject **hash; + ls_nstr nuse; /* number of elements */ + int size; +} stringtable; + + +/* +** informations about a call +*/ +typedef struct CallInfo { + StkId base; /* base for called function */ + StkId top; /* top for this function */ + int state; /* bit fields; see below */ + union { + struct { /* for Lua functions */ + const Instruction *savedpc; + const Instruction **pc; /* points to `pc' variable in `luaV_execute' */ + int tailcalls; /* number of tail calls lost under this entry */ + } l; + struct { /* for C functions */ + int dummy; /* just to avoid an empty struct */ + } c; + } u; +} CallInfo; + + +/* +** bit fields for `CallInfo.state' +*/ +#define CI_C (1<<0) /* 1 if function is a C function */ +/* 1 if (Lua) function has an active `luaV_execute' running it */ +#define CI_HASFRAME (1<<1) +/* 1 if Lua function is calling another Lua function (and therefore its + `pc' is being used by the other, and therefore CI_SAVEDPC is 1 too) */ +#define CI_CALLING (1<<2) +#define CI_SAVEDPC (1<<3) /* 1 if `savedpc' is updated */ +#define CI_YIELD (1<<4) /* 1 if thread is suspended */ + + +#define ci_func(ci) (clvalue((ci)->base - 1)) + + +/* +** `global state', shared by all threads of this state +*/ +typedef struct global_State { + stringtable strt; /* hash table for strings */ + GCObject *rootgc; /* list of (almost) all collectable objects */ + GCObject *rootudata; /* (separated) list of all userdata */ + GCObject *tmudata; /* list of userdata to be GC */ + Mbuffer buff; /* temporary buffer for string concatentation */ + lu_mem GCthreshold; + lu_mem nblocks; /* number of `bytes' currently allocated */ + lua_CFunction panic; /* to be called in unprotected errors */ + TObject _registry; + TObject _defaultmeta; + struct lua_State *mainthread; + Node dummynode[1]; /* common node array for all empty tables */ + TString *tmname[TM_N]; /* array with tag-method names */ +} global_State; + + +/* +** `per thread' state +*/ +struct lua_State { + CommonHeader; + StkId top; /* first free slot in the stack */ + StkId base; /* base of current function */ + global_State *l_G; + CallInfo *ci; /* call info for current function */ + StkId stack_last; /* last free slot in the stack */ + StkId stack; /* stack base */ + int stacksize; + CallInfo *end_ci; /* points after end of ci array*/ + CallInfo *base_ci; /* array of CallInfo's */ + unsigned short size_ci; /* size of array `base_ci' */ + unsigned short nCcalls; /* number of nested C calls */ + lu_byte hookmask; + lu_byte allowhook; + lu_byte hookinit; + int basehookcount; + int hookcount; + lua_Hook hook; + TObject _gt; /* table of globals */ + GCObject *openupval; /* list of open upvalues in this stack */ + GCObject *gclist; + struct lua_longjmp *errorJmp; /* current error recover point */ + ptrdiff_t errfunc; /* current error handling function (stack index) */ +}; + + +#define G(L) (L->l_G) + + +/* +** Union of all collectable objects +*/ +union GCObject { + GCheader gch; + union TString ts; + union Udata u; + union Closure cl; + struct Table h; + struct Proto p; + struct UpVal uv; + struct lua_State th; /* thread */ +}; + + +/* macros to convert a GCObject into a specific value */ +#define gcotots(o) check_exp((o)->gch.tt == LUA_TSTRING, &((o)->ts)) +#define gcotou(o) check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u)) +#define gcotocl(o) check_exp((o)->gch.tt == LUA_TFUNCTION, &((o)->cl)) +#define gcotoh(o) check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h)) +#define gcotop(o) check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p)) +#define gcotouv(o) check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv)) +#define ngcotouv(o) \ + check_exp((o) == NULL || (o)->gch.tt == LUA_TUPVAL, &((o)->uv)) +#define gcototh(o) check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th)) + +/* macro to convert any value into a GCObject */ +#define valtogco(v) (cast(GCObject *, (v))) + + +lua_State *luaE_newthread (lua_State *L); +void luaE_freethread (lua_State *L, lua_State *L1); + +#endif + diff --git a/stepmania/src/lua-5.0/src/lstring.c b/stepmania/src/lua-5.0/src/lstring.c new file mode 100644 index 0000000000..ad68f26f14 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lstring.c @@ -0,0 +1,102 @@ +/* +** $Id$ +** String table (keeps all strings handled by Lua) +** See Copyright Notice in lua.h +*/ + + +#include + +#define lstring_c + +#include "lua.h" + +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" + + + +void luaS_freeall (lua_State *L) { + lua_assert(G(L)->strt.nuse==0); + luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *); +} + + +void luaS_resize (lua_State *L, int newsize) { + GCObject **newhash = luaM_newvector(L, newsize, GCObject *); + stringtable *tb = &G(L)->strt; + int i; + for (i=0; isize; i++) { + GCObject *p = tb->hash[i]; + while (p) { /* for each node in the list */ + GCObject *next = p->gch.next; /* save next */ + lu_hash h = gcotots(p)->tsv.hash; + int h1 = lmod(h, newsize); /* new position */ + lua_assert(cast(int, h%newsize) == lmod(h, newsize)); + p->gch.next = newhash[h1]; /* chain it */ + newhash[h1] = p; + p = next; + } + } + luaM_freearray(L, tb->hash, tb->size, TString *); + tb->size = newsize; + tb->hash = newhash; +} + + +static TString *newlstr (lua_State *L, const char *str, size_t l, lu_hash h) { + TString *ts = cast(TString *, luaM_malloc(L, sizestring(l))); + stringtable *tb; + ts->tsv.len = l; + ts->tsv.hash = h; + ts->tsv.marked = 0; + ts->tsv.tt = LUA_TSTRING; + ts->tsv.reserved = 0; + memcpy(ts+1, str, l*sizeof(char)); + ((char *)(ts+1))[l] = '\0'; /* ending 0 */ + tb = &G(L)->strt; + h = lmod(h, tb->size); + ts->tsv.next = tb->hash[h]; /* chain new entry */ + tb->hash[h] = valtogco(ts); + tb->nuse++; + if (tb->nuse > cast(ls_nstr, tb->size) && tb->size <= MAX_INT/2) + luaS_resize(L, tb->size*2); /* too crowded */ + return ts; +} + + +TString *luaS_newlstr (lua_State *L, const char *str, size_t l) { + GCObject *o; + lu_hash h = (lu_hash)l; /* seed */ + size_t step = (l>>5)+1; /* if string is too long, don't hash all its chars */ + size_t l1; + for (l1=l; l1>=step; l1-=step) /* compute hash */ + h = h ^ ((h<<5)+(h>>2)+(unsigned char)(str[l1-1])); + for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)]; + o != NULL; + o = o->gch.next) { + TString *ts = gcotots(o); + if (ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0)) + return ts; + } + return newlstr(L, str, l, h); /* not found */ +} + + +Udata *luaS_newudata (lua_State *L, size_t s) { + Udata *u; + u = cast(Udata *, luaM_malloc(L, sizeudata(s))); + u->uv.marked = (1<<1); /* is not finalized */ + u->uv.tt = LUA_TUSERDATA; + u->uv.len = s; + u->uv.metatable = hvalue(defaultmeta(L)); + /* chain it on udata list */ + u->uv.next = G(L)->rootudata; + G(L)->rootudata = valtogco(u); + return u; +} + diff --git a/stepmania/src/lua-5.0/src/lstring.h b/stepmania/src/lua-5.0/src/lstring.h new file mode 100644 index 0000000000..64583a93bb --- /dev/null +++ b/stepmania/src/lua-5.0/src/lstring.h @@ -0,0 +1,33 @@ +/* +** $Id$ +** String table (keep all strings handled by Lua) +** See Copyright Notice in lua.h +*/ + +#ifndef lstring_h +#define lstring_h + + +#include "lobject.h" +#include "lstate.h" + + + +#define sizestring(l) (cast(lu_mem, sizeof(union TString))+ \ + (cast(lu_mem, l)+1)*sizeof(char)) + +#define sizeudata(l) (cast(lu_mem, sizeof(union Udata))+(l)) + +#define luaS_new(L, s) (luaS_newlstr(L, s, strlen(s))) +#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ + (sizeof(s)/sizeof(char))-1)) + +#define luaS_fix(s) ((s)->tsv.marked |= (1<<4)) + +void luaS_resize (lua_State *L, int newsize); +Udata *luaS_newudata (lua_State *L, size_t s); +void luaS_freeall (lua_State *L); +TString *luaS_newlstr (lua_State *L, const char *str, size_t l); + + +#endif diff --git a/stepmania/src/lua-5.0/src/ltable.c b/stepmania/src/lua-5.0/src/ltable.c new file mode 100644 index 0000000000..93fe2cee91 --- /dev/null +++ b/stepmania/src/lua-5.0/src/ltable.c @@ -0,0 +1,509 @@ +/* +** $Id$ +** Lua tables (hash) +** See Copyright Notice in lua.h +*/ + + +/* +** Implementation of tables (aka arrays, objects, or hash tables). +** Tables keep its elements in two parts: an array part and a hash part. +** Non-negative integer keys are all candidates to be kept in the array +** part. The actual size of the array is the largest `n' such that at +** least half the slots between 0 and n are in use. +** Hash uses a mix of chained scatter table with Brent's variation. +** A main invariant of these tables is that, if an element is not +** in its main position (i.e. the `original' position that its hash gives +** to it), then the colliding element is in its own main position. +** In other words, there are collisions only when two elements have the +** same main position (i.e. the same hash values for that table size). +** Because of that, the load factor of these tables can be 100% without +** performance penalties. +*/ + +#include + +#define ltable_c + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lgc.h" +#include "lmem.h" +#include "lobject.h" +#include "lstate.h" +#include "ltable.h" + + +/* +** max size of array part is 2^MAXBITS +*/ +#if BITS_INT > 26 +#define MAXBITS 24 +#else +#define MAXBITS (BITS_INT-2) +#endif + +/* check whether `x' < 2^MAXBITS */ +#define toobig(x) ((((x)-1) >> MAXBITS) != 0) + + +/* function to convert a lua_Number to int (with any rounding method) */ +#ifndef lua_number2int +#define lua_number2int(i,n) ((i)=(int)(n)) +#endif + + +#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) + +#define hashstr(t,str) hashpow2(t, (str)->tsv.hash) +#define hashboolean(t,p) hashpow2(t, p) + + +/* +** for some types, it is better to avoid modulus by power of 2, as +** they tend to have many 2 factors. +*/ +#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) + + +#define hashpointer(t,p) hashmod(t, IntPoint(p)) + + +/* +** number of ints inside a lua_Number +*/ +#define numints cast(int, sizeof(lua_Number)/sizeof(int)) + + +/* +** hash for lua_Numbers +*/ +static Node *hashnum (const Table *t, lua_Number n) { + unsigned int a[numints]; + int i; + n += 1; /* normalize number (avoid -0) */ + lua_assert(sizeof(a) <= sizeof(n)); + memcpy(a, &n, sizeof(a)); + for (i = 1; i < numints; i++) a[0] += a[i]; + return hashmod(t, cast(lu_hash, a[0])); +} + + + +/* +** returns the `main' position of an element in a table (that is, the index +** of its hash value) +*/ +Node *luaH_mainposition (const Table *t, const TObject *key) { + switch (ttype(key)) { + case LUA_TNUMBER: + return hashnum(t, nvalue(key)); + case LUA_TSTRING: + return hashstr(t, tsvalue(key)); + case LUA_TBOOLEAN: + return hashboolean(t, bvalue(key)); + case LUA_TLIGHTUSERDATA: + return hashpointer(t, pvalue(key)); + default: + return hashpointer(t, gcvalue(key)); + } +} + + +/* +** returns the index for `key' if `key' is an appropriate key to live in +** the array part of the table, -1 otherwise. +*/ +static int arrayindex (const TObject *key) { + if (ttisnumber(key)) { + int k; + lua_number2int(k, (nvalue(key))); + if (cast(lua_Number, k) == nvalue(key) && k >= 1 && !toobig(k)) + return k; + } + return -1; /* `key' did not match some condition */ +} + + +/* +** returns the index of a `key' for table traversals. First goes all +** elements in the array part, then elements in the hash part. The +** beginning and end of a traversal are signalled by -1. +*/ +static int luaH_index (lua_State *L, Table *t, StkId key) { + int i; + if (ttisnil(key)) return -1; /* first iteration */ + i = arrayindex(key); + if (0 <= i && i <= t->sizearray) { /* is `key' inside array part? */ + return i-1; /* yes; that's the index (corrected to C) */ + } + else { + const TObject *v = luaH_get(t, key); + if (v == &luaO_nilobject) + luaG_runerror(L, "invalid key for `next'"); + i = cast(int, (cast(const lu_byte *, v) - + cast(const lu_byte *, gval(gnode(t, 0)))) / sizeof(Node)); + return i + t->sizearray; /* hash elements are numbered after array ones */ + } +} + + +int luaH_next (lua_State *L, Table *t, StkId key) { + int i = luaH_index(L, t, key); /* find original element */ + for (i++; i < t->sizearray; i++) { /* try first array part */ + if (!ttisnil(&t->array[i])) { /* a non-nil value? */ + setnvalue(key, cast(lua_Number, i+1)); + setobj2s(key+1, &t->array[i]); + return 1; + } + } + for (i -= t->sizearray; i < sizenode(t); i++) { /* then hash part */ + if (!ttisnil(gval(gnode(t, i)))) { /* a non-nil value? */ + setobj2s(key, gkey(gnode(t, i))); + setobj2s(key+1, gval(gnode(t, i))); + return 1; + } + } + return 0; /* no more elements */ +} + + +/* +** {============================================================= +** Rehash +** ============================================================== +*/ + + +static void computesizes (int nums[], int ntotal, int *narray, int *nhash) { + int i; + int a = nums[0]; /* number of elements smaller than 2^i */ + int na = a; /* number of elements to go to array part */ + int n = (na == 0) ? -1 : 0; /* (log of) optimal size for array part */ + for (i = 1; a < *narray && *narray >= twoto(i-1); i++) { + if (nums[i] > 0) { + a += nums[i]; + if (a >= twoto(i-1)) { /* more than half elements in use? */ + n = i; + na = a; + } + } + } + lua_assert(na <= *narray && *narray <= ntotal); + *nhash = ntotal - na; + *narray = (n == -1) ? 0 : twoto(n); + lua_assert(na <= *narray && na >= *narray/2); +} + + +static void numuse (const Table *t, int *narray, int *nhash) { + int nums[MAXBITS+1]; + int i, lg; + int totaluse = 0; + /* count elements in array part */ + for (i=0, lg=0; lg<=MAXBITS; lg++) { /* for each slice [2^(lg-1) to 2^lg) */ + int ttlg = twoto(lg); /* 2^lg */ + if (ttlg > t->sizearray) { + ttlg = t->sizearray; + if (i >= ttlg) break; + } + nums[lg] = 0; + for (; iarray[i])) { + nums[lg]++; + totaluse++; + } + } + } + for (; lg<=MAXBITS; lg++) nums[lg] = 0; /* reset other counts */ + *narray = totaluse; /* all previous uses were in array part */ + /* count elements in hash part */ + i = sizenode(t); + while (i--) { + Node *n = &t->node[i]; + if (!ttisnil(gval(n))) { + int k = arrayindex(gkey(n)); + if (k >= 0) { /* is `key' an appropriate array index? */ + nums[luaO_log2(k-1)+1]++; /* count as such */ + (*narray)++; + } + totaluse++; + } + } + computesizes(nums, totaluse, narray, nhash); +} + + +static void setarrayvector (lua_State *L, Table *t, int size) { + int i; + luaM_reallocvector(L, t->array, t->sizearray, size, TObject); + for (i=t->sizearray; iarray[i]); + t->sizearray = size; +} + + +static void setnodevector (lua_State *L, Table *t, int lsize) { + int i; + int size = twoto(lsize); + if (lsize > MAXBITS) + luaG_runerror(L, "table overflow"); + if (lsize == 0) { /* no elements to hash part? */ + t->node = G(L)->dummynode; /* use common `dummynode' */ + lua_assert(ttisnil(gkey(t->node))); /* assert invariants: */ + lua_assert(ttisnil(gval(t->node))); + lua_assert(t->node->next == NULL); /* (`dummynode' must be empty) */ + } + else { + t->node = luaM_newvector(L, size, Node); + for (i=0; inode[i].next = NULL; + setnilvalue(gkey(gnode(t, i))); + setnilvalue(gval(gnode(t, i))); + } + } + t->lsizenode = cast(lu_byte, lsize); + t->firstfree = gnode(t, size-1); /* first free position to be used */ +} + + +static void resize (lua_State *L, Table *t, int nasize, int nhsize) { + int i; + int oldasize = t->sizearray; + int oldhsize = t->lsizenode; + Node *nold; + Node temp[1]; + if (oldhsize) + nold = t->node; /* save old hash ... */ + else { /* old hash is `dummynode' */ + lua_assert(t->node == G(L)->dummynode); + temp[0] = t->node[0]; /* copy it to `temp' */ + nold = temp; + setnilvalue(gkey(G(L)->dummynode)); /* restate invariant */ + setnilvalue(gval(G(L)->dummynode)); + lua_assert(G(L)->dummynode->next == NULL); + } + if (nasize > oldasize) /* array part must grow? */ + setarrayvector(L, t, nasize); + /* create new hash part with appropriate size */ + setnodevector(L, t, nhsize); + /* re-insert elements */ + if (nasize < oldasize) { /* array part must shrink? */ + t->sizearray = nasize; + /* re-insert elements from vanishing slice */ + for (i=nasize; iarray[i])) + setobjt2t(luaH_setnum(L, t, i+1), &t->array[i]); + } + /* shrink array */ + luaM_reallocvector(L, t->array, oldasize, nasize, TObject); + } + /* re-insert elements in hash part */ + for (i = twoto(oldhsize) - 1; i >= 0; i--) { + Node *old = nold+i; + if (!ttisnil(gval(old))) + setobjt2t(luaH_set(L, t, gkey(old)), gval(old)); + } + if (oldhsize) + luaM_freearray(L, nold, twoto(oldhsize), Node); /* free old array */ +} + + +static void rehash (lua_State *L, Table *t) { + int nasize, nhsize; + numuse(t, &nasize, &nhsize); /* compute new sizes for array and hash parts */ + resize(L, t, nasize, luaO_log2(nhsize)+1); +} + + + +/* +** }============================================================= +*/ + + +Table *luaH_new (lua_State *L, int narray, int lnhash) { + Table *t = luaM_new(L, Table); + luaC_link(L, valtogco(t), LUA_TTABLE); + t->metatable = hvalue(defaultmeta(L)); + t->flags = cast(lu_byte, ~0); + /* temporary values (kept only if some malloc fails) */ + t->array = NULL; + t->sizearray = 0; + t->lsizenode = 0; + t->node = NULL; + setarrayvector(L, t, narray); + setnodevector(L, t, lnhash); + return t; +} + + +void luaH_free (lua_State *L, Table *t) { + if (t->lsizenode) + luaM_freearray(L, t->node, sizenode(t), Node); + luaM_freearray(L, t->array, t->sizearray, TObject); + luaM_freelem(L, t); +} + + +#if 0 +/* +** try to remove an element from a hash table; cannot move any element +** (because gc can call `remove' during a table traversal) +*/ +void luaH_remove (Table *t, Node *e) { + Node *mp = luaH_mainposition(t, gkey(e)); + if (e != mp) { /* element not in its main position? */ + while (mp->next != e) mp = mp->next; /* find previous */ + mp->next = e->next; /* remove `e' from its list */ + } + else { + if (e->next != NULL) ?? + } + lua_assert(ttisnil(gval(node))); + setnilvalue(gkey(e)); /* clear node `e' */ + e->next = NULL; +} +#endif + + +/* +** inserts a new key into a hash table; first, check whether key's main +** position is free. If not, check whether colliding node is in its main +** position or not: if it is not, move colliding node to an empty place and +** put new key in its main position; otherwise (colliding node is in its main +** position), new key goes to an empty position. +*/ +static TObject *newkey (lua_State *L, Table *t, const TObject *key) { + TObject *val; + Node *mp = luaH_mainposition(t, key); + if (!ttisnil(gval(mp))) { /* main position is not free? */ + Node *othern = luaH_mainposition(t, gkey(mp)); /* `mp' of colliding node */ + Node *n = t->firstfree; /* get a free place */ + if (othern != mp) { /* is colliding node out of its main position? */ + /* yes; move colliding node into free position */ + while (othern->next != mp) othern = othern->next; /* find previous */ + othern->next = n; /* redo the chain with `n' in place of `mp' */ + *n = *mp; /* copy colliding node into free pos. (mp->next also goes) */ + mp->next = NULL; /* now `mp' is free */ + setnilvalue(gval(mp)); + } + else { /* colliding node is in its own main position */ + /* new node will go into free position */ + n->next = mp->next; /* chain new position */ + mp->next = n; + mp = n; + } + } + setobj2t(gkey(mp), key); /* write barrier */ + lua_assert(ttisnil(gval(mp))); + for (;;) { /* correct `firstfree' */ + if (ttisnil(gkey(t->firstfree))) + return gval(mp); /* OK; table still has a free place */ + else if (t->firstfree == t->node) break; /* cannot decrement from here */ + else (t->firstfree)--; + } + /* no more free places; must create one */ + setbvalue(gval(mp), 0); /* avoid new key being removed */ + rehash(L, t); /* grow table */ + val = cast(TObject *, luaH_get(t, key)); /* get new position */ + lua_assert(ttisboolean(val)); + setnilvalue(val); + return val; +} + + +/* +** generic search function +*/ +static const TObject *luaH_getany (Table *t, const TObject *key) { + if (ttisnil(key)) return &luaO_nilobject; + else { + Node *n = luaH_mainposition(t, key); + do { /* check whether `key' is somewhere in the chain */ + if (luaO_rawequalObj(gkey(n), key)) return gval(n); /* that's it */ + else n = n->next; + } while (n); + return &luaO_nilobject; + } +} + + +/* +** search function for integers +*/ +const TObject *luaH_getnum (Table *t, int key) { + if (1 <= key && key <= t->sizearray) + return &t->array[key-1]; + else { + lua_Number nk = cast(lua_Number, key); + Node *n = hashnum(t, nk); + do { /* check whether `key' is somewhere in the chain */ + if (ttisnumber(gkey(n)) && nvalue(gkey(n)) == nk) + return gval(n); /* that's it */ + else n = n->next; + } while (n); + return &luaO_nilobject; + } +} + + +/* +** search function for strings +*/ +const TObject *luaH_getstr (Table *t, TString *key) { + Node *n = hashstr(t, key); + do { /* check whether `key' is somewhere in the chain */ + if (ttisstring(gkey(n)) && tsvalue(gkey(n)) == key) + return gval(n); /* that's it */ + else n = n->next; + } while (n); + return &luaO_nilobject; +} + + +/* +** main search function +*/ +const TObject *luaH_get (Table *t, const TObject *key) { + switch (ttype(key)) { + case LUA_TSTRING: return luaH_getstr(t, tsvalue(key)); + case LUA_TNUMBER: { + int k; + lua_number2int(k, (nvalue(key))); + if (cast(lua_Number, k) == nvalue(key)) /* is an integer index? */ + return luaH_getnum(t, k); /* use specialized version */ + /* else go through */ + } + default: return luaH_getany(t, key); + } +} + + +TObject *luaH_set (lua_State *L, Table *t, const TObject *key) { + const TObject *p = luaH_get(t, key); + t->flags = 0; + if (p != &luaO_nilobject) + return cast(TObject *, p); + else { + if (ttisnil(key)) luaG_runerror(L, "table index is nil"); + else if (ttisnumber(key) && nvalue(key) != nvalue(key)) + luaG_runerror(L, "table index is NaN"); + return newkey(L, t, key); + } +} + + +TObject *luaH_setnum (lua_State *L, Table *t, int key) { + const TObject *p = luaH_getnum(t, key); + if (p != &luaO_nilobject) + return cast(TObject *, p); + else { + TObject k; + setnvalue(&k, cast(lua_Number, key)); + return newkey(L, t, &k); + } +} + diff --git a/stepmania/src/lua-5.0/src/ltable.h b/stepmania/src/lua-5.0/src/ltable.h new file mode 100644 index 0000000000..7b81c18367 --- /dev/null +++ b/stepmania/src/lua-5.0/src/ltable.h @@ -0,0 +1,31 @@ +/* +** $Id$ +** Lua tables (hash) +** See Copyright Notice in lua.h +*/ + +#ifndef ltable_h +#define ltable_h + +#include "lobject.h" + + +#define gnode(t,i) (&(t)->node[i]) +#define gkey(n) (&(n)->i_key) +#define gval(n) (&(n)->i_val) + + +const TObject *luaH_getnum (Table *t, int key); +TObject *luaH_setnum (lua_State *L, Table *t, int key); +const TObject *luaH_getstr (Table *t, TString *key); +const TObject *luaH_get (Table *t, const TObject *key); +TObject *luaH_set (lua_State *L, Table *t, const TObject *key); +Table *luaH_new (lua_State *L, int narray, int lnhash); +void luaH_free (lua_State *L, Table *t); +int luaH_next (lua_State *L, Table *t, StkId key); + +/* exported only for debugging */ +Node *luaH_mainposition (const Table *t, const TObject *key); + + +#endif diff --git a/stepmania/src/lua-5.0/src/ltests.c b/stepmania/src/lua-5.0/src/ltests.c new file mode 100644 index 0000000000..ce30345816 --- /dev/null +++ b/stepmania/src/lua-5.0/src/ltests.c @@ -0,0 +1,852 @@ +/* +** $Id$ +** Internal Module for Debugging of the Lua Implementation +** See Copyright Notice in lua.h +*/ + + +#include +#include +#include +#include +#include + +#define ltests_c + +#include "lua.h" + +#include "lapi.h" +#include "lauxlib.h" +#include "lcode.h" +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lmem.h" +#include "lopcodes.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "lualib.h" + + + +/* +** The whole module only makes sense with LUA_DEBUG on +*/ +#ifdef LUA_DEBUG + + +#define lua_pushintegral(L,i) lua_pushnumber(L, cast(lua_Number, (i))) + + +static lua_State *lua_state = NULL; + +int islocked = 0; + + +#define func_at(L,k) (L->ci->base+(k) - 1) + + +static void setnameval (lua_State *L, const char *name, int val) { + lua_pushstring(L, name); + lua_pushintegral(L, val); + lua_settable(L, -3); +} + + +/* +** {====================================================================== +** Controlled version for realloc. +** ======================================================================= +*/ + +#define MARK 0x55 /* 01010101 (a nice pattern) */ + +#ifndef EXTERNMEMCHECK +/* full memory check */ +#define HEADER (sizeof(L_Umaxalign)) /* ensures maximum alignment for HEADER */ +#define MARKSIZE 16 /* size of marks after each block */ +#define blockhead(b) (cast(char *, b) - HEADER) +#define setsize(newblock, size) (*cast(size_t *, newblock) = size) +#define checkblocksize(b, size) (size == (*cast(size_t *, blockhead(b)))) +#define fillmem(mem,size) memset(mem, -MARK, size) +#else +/* external memory check: don't do it twice */ +#define HEADER 0 +#define MARKSIZE 0 +#define blockhead(b) (b) +#define setsize(newblock, size) /* empty */ +#define checkblocksize(b,size) (1) +#define fillmem(mem,size) /* empty */ +#endif + +unsigned long memdebug_numblocks = 0; +unsigned long memdebug_total = 0; +unsigned long memdebug_maxmem = 0; +unsigned long memdebug_memlimit = ULONG_MAX; + + +static void *checkblock (void *block, size_t size) { + void *b = blockhead(block); + int i; + for (i=0;i 0); + if (size == 0) { + freeblock(block, oldsize); + return NULL; + } + else if (size > oldsize && memdebug_total+size-oldsize > memdebug_memlimit) + return NULL; /* to test memory allocation errors */ + else { + void *newblock; + int i; + size_t realsize = HEADER+size+MARKSIZE; + size_t commonsize = (oldsize < size) ? oldsize : size; + if (realsize < size) return NULL; /* overflow! */ + newblock = malloc(realsize); /* alloc a new block */ + if (newblock == NULL) return NULL; + if (block) { + memcpy(cast(char *, newblock)+HEADER, block, commonsize); + freeblock(block, oldsize); /* erase (and check) old copy */ + } + /* initialize new part of the block with something `weird' */ + fillmem(cast(char *, newblock)+HEADER+commonsize, size-commonsize); + memdebug_total += size; + if (memdebug_total > memdebug_maxmem) + memdebug_maxmem = memdebug_total; + memdebug_numblocks++; + setsize(newblock, size); + for (i=0;icode[pc]; + OpCode o = GET_OPCODE(i); + const char *name = luaP_opnames[o]; + int line = getline(p, pc); + sprintf(buff, "(%4d) %4d - ", line, pc); + switch (getOpMode(o)) { + case iABC: + sprintf(buff+strlen(buff), "%-12s%4d %4d %4d", name, + GETARG_A(i), GETARG_B(i), GETARG_C(i)); + break; + case iABx: + sprintf(buff+strlen(buff), "%-12s%4d %4d", name, GETARG_A(i), GETARG_Bx(i)); + break; + case iAsBx: + sprintf(buff+strlen(buff), "%-12s%4d %4d", name, GETARG_A(i), GETARG_sBx(i)); + break; + } + return buff; +} + + +#if 0 +void luaI_printcode (Proto *pt, int size) { + int pc; + for (pc=0; pcl.p; + lua_newtable(L); + setnameval(L, "maxstack", p->maxstacksize); + setnameval(L, "numparams", p->numparams); + for (pc=0; pcsizecode; pc++) { + char buff[100]; + lua_pushintegral(L, pc+1); + lua_pushstring(L, buildop(p, pc, buff)); + lua_settable(L, -3); + } + return 1; +} + + +static int listk (lua_State *L) { + Proto *p; + int i; + luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), + 1, "Lua function expected"); + p = clvalue(func_at(L, 1))->l.p; + lua_newtable(L); + for (i=0; isizek; i++) { + lua_pushintegral(L, i+1); + luaA_pushobject(L, p->k+i); + lua_settable(L, -3); + } + return 1; +} + + +static int listlocals (lua_State *L) { + Proto *p; + int pc = luaL_checkint(L, 2) - 1; + int i = 0; + const char *name; + luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), + 1, "Lua function expected"); + p = clvalue(func_at(L, 1))->l.p; + while ((name = luaF_getlocalname(p, ++i, pc)) != NULL) + lua_pushstring(L, name); + return i-1; +} + +/* }====================================================== */ + + + + +static int get_limits (lua_State *L) { + lua_newtable(L); + setnameval(L, "BITS_INT", BITS_INT); + setnameval(L, "LFPF", LFIELDS_PER_FLUSH); + setnameval(L, "MAXVARS", MAXVARS); + setnameval(L, "MAXPARAMS", MAXPARAMS); + setnameval(L, "MAXSTACK", MAXSTACK); + setnameval(L, "MAXUPVALUES", MAXUPVALUES); + return 1; +} + + +static int mem_query (lua_State *L) { + if (lua_isnone(L, 1)) { + lua_pushintegral(L, memdebug_total); + lua_pushintegral(L, memdebug_numblocks); + lua_pushintegral(L, memdebug_maxmem); + return 3; + } + else { + memdebug_memlimit = luaL_checkint(L, 1); + return 0; + } +} + + +static int hash_query (lua_State *L) { + if (lua_isnone(L, 2)) { + luaL_argcheck(L, lua_type(L, 1) == LUA_TSTRING, 1, "string expected"); + lua_pushintegral(L, tsvalue(func_at(L, 1))->tsv.hash); + } + else { + TObject *o = func_at(L, 1); + Table *t; + luaL_checktype(L, 2, LUA_TTABLE); + t = hvalue(func_at(L, 2)); + lua_pushintegral(L, luaH_mainposition(t, o) - t->node); + } + return 1; +} + + +static int stacklevel (lua_State *L) { + unsigned long a = 0; + lua_pushintegral(L, (int)(L->top - L->stack)); + lua_pushintegral(L, (int)(L->stack_last - L->stack)); + lua_pushintegral(L, (int)(L->ci - L->base_ci)); + lua_pushintegral(L, (int)(L->end_ci - L->base_ci)); + lua_pushintegral(L, (unsigned long)&a); + return 5; +} + + +static int table_query (lua_State *L) { + const Table *t; + int i = luaL_optint(L, 2, -1); + luaL_checktype(L, 1, LUA_TTABLE); + t = hvalue(func_at(L, 1)); + if (i == -1) { + lua_pushintegral(L, t->sizearray); + lua_pushintegral(L, sizenode(t)); + lua_pushintegral(L, t->firstfree - t->node); + } + else if (i < t->sizearray) { + lua_pushintegral(L, i); + luaA_pushobject(L, &t->array[i]); + lua_pushnil(L); + } + else if ((i -= t->sizearray) < sizenode(t)) { + if (!ttisnil(gval(gnode(t, i))) || + ttisnil(gkey(gnode(t, i))) || + ttisnumber(gkey(gnode(t, i)))) { + luaA_pushobject(L, gkey(gnode(t, i))); + } + else + lua_pushstring(L, ""); + luaA_pushobject(L, gval(gnode(t, i))); + if (t->node[i].next) + lua_pushintegral(L, t->node[i].next - t->node); + else + lua_pushnil(L); + } + return 3; +} + + +static int string_query (lua_State *L) { + stringtable *tb = &G(L)->strt; + int s = luaL_optint(L, 2, 0) - 1; + if (s==-1) { + lua_pushintegral(L ,tb->nuse); + lua_pushintegral(L ,tb->size); + return 2; + } + else if (s < tb->size) { + GCObject *ts; + int n = 0; + for (ts = tb->hash[s]; ts; ts = ts->gch.next) { + setsvalue2s(L->top, gcotots(ts)); + incr_top(L); + n++; + } + return n; + } + return 0; +} + + +static int tref (lua_State *L) { + int level = lua_gettop(L); + int lock = luaL_optint(L, 2, 1); + luaL_checkany(L, 1); + lua_pushvalue(L, 1); + lua_pushintegral(L, lua_ref(L, lock)); + assert(lua_gettop(L) == level+1); /* +1 for result */ + return 1; +} + +static int getref (lua_State *L) { + int level = lua_gettop(L); + lua_getref(L, luaL_checkint(L, 1)); + assert(lua_gettop(L) == level+1); + return 1; +} + +static int unref (lua_State *L) { + int level = lua_gettop(L); + lua_unref(L, luaL_checkint(L, 1)); + assert(lua_gettop(L) == level); + return 0; +} + +static int metatable (lua_State *L) { + luaL_checkany(L, 1); + if (lua_isnone(L, 2)) { + if (lua_getmetatable(L, 1) == 0) + lua_pushnil(L); + } + else { + lua_settop(L, 2); + luaL_checktype(L, 2, LUA_TTABLE); + lua_setmetatable(L, 1); + } + return 1; +} + + +static int upvalue (lua_State *L) { + int n = luaL_checkint(L, 2); + luaL_checktype(L, 1, LUA_TFUNCTION); + if (lua_isnone(L, 3)) { + const char *name = lua_getupvalue(L, 1, n); + if (name == NULL) return 0; + lua_pushstring(L, name); + return 2; + } + else { + const char *name = lua_setupvalue(L, 1, n); + lua_pushstring(L, name); + return 1; + } +} + + +static int newuserdata (lua_State *L) { + size_t size = luaL_checkint(L, 1); + char *p = cast(char *, lua_newuserdata(L, size)); + while (size--) *p++ = '\0'; + return 1; +} + + +static int pushuserdata (lua_State *L) { + lua_pushlightuserdata(L, cast(void *, luaL_checkint(L, 1))); + return 1; +} + + +static int udataval (lua_State *L) { + lua_pushintegral(L, cast(int, lua_touserdata(L, 1))); + return 1; +} + + +static int doonnewstack (lua_State *L) { + lua_State *L1 = lua_newthread(L); + size_t l; + const char *s = luaL_checklstring(L, 1, &l); + int status = luaL_loadbuffer(L1, s, l, s); + if (status == 0) + status = lua_pcall(L1, 0, 0, 0); + lua_pushintegral(L, status); + return 1; +} + + +static int s2d (lua_State *L) { + lua_pushnumber(L, *cast(const double *, luaL_checkstring(L, 1))); + return 1; +} + +static int d2s (lua_State *L) { + double d = luaL_checknumber(L, 1); + lua_pushlstring(L, cast(char *, &d), sizeof(d)); + return 1; +} + + +static int newstate (lua_State *L) { + lua_State *L1 = lua_open(); + if (L1) { + lua_userstateopen(L1); /* init lock */ + lua_pushintegral(L, (unsigned long)L1); + } + else + lua_pushnil(L); + return 1; +} + + +static int loadlib (lua_State *L) { + static const luaL_reg libs[] = { + {"mathlibopen", luaopen_math}, + {"strlibopen", luaopen_string}, + {"iolibopen", luaopen_io}, + {"tablibopen", luaopen_table}, + {"dblibopen", luaopen_debug}, + {"baselibopen", luaopen_base}, + {NULL, NULL} + }; + lua_State *L1 = cast(lua_State *, + cast(unsigned long, luaL_checknumber(L, 1))); + lua_pushvalue(L1, LUA_GLOBALSINDEX); + luaL_openlib(L1, NULL, libs, 0); + return 0; +} + +static int closestate (lua_State *L) { + lua_State *L1 = cast(lua_State *, cast(unsigned long, luaL_checknumber(L, 1))); + lua_close(L1); + lua_unlock(L); /* close cannot unlock that */ + return 0; +} + +static int doremote (lua_State *L) { + lua_State *L1 = cast(lua_State *,cast(unsigned long,luaL_checknumber(L, 1))); + size_t lcode; + const char *code = luaL_checklstring(L, 2, &lcode); + int status; + lua_settop(L1, 0); + status = luaL_loadbuffer(L1, code, lcode, code); + if (status == 0) + status = lua_pcall(L1, 0, LUA_MULTRET, 0); + if (status != 0) { + lua_pushnil(L); + lua_pushintegral(L, status); + lua_pushstring(L, lua_tostring(L1, -1)); + return 3; + } + else { + int i = 0; + while (!lua_isnone(L1, ++i)) + lua_pushstring(L, lua_tostring(L1, i)); + lua_pop(L1, i-1); + return i-1; + } +} + + +static int log2_aux (lua_State *L) { + lua_pushintegral(L, luaO_log2(luaL_checkint(L, 1))); + return 1; +} + +static int int2fb_aux (lua_State *L) { + int b = luaO_int2fb(luaL_checkint(L, 1)); + lua_pushintegral(L, b); + lua_pushintegral(L, fb2int(b)); + return 2; +} + + +static int test_do (lua_State *L) { + const char *p = luaL_checkstring(L, 1); + if (*p == '@') + lua_dofile(L, p+1); + else + lua_dostring(L, p); + return lua_gettop(L); +} + + + +/* +** {====================================================== +** function to test the API with C. It interprets a kind of assembler +** language with calls to the API, so the test can be driven by Lua code +** ======================================================= +*/ + +static const char *const delimits = " \t\n,;"; + +static void skip (const char **pc) { + while (**pc != '\0' && strchr(delimits, **pc)) (*pc)++; +} + +static int getnum_aux (lua_State *L, const char **pc) { + int res = 0; + int sig = 1; + skip(pc); + if (**pc == '.') { + res = cast(int, lua_tonumber(L, -1)); + lua_pop(L, 1); + (*pc)++; + return res; + } + else if (**pc == '-') { + sig = -1; + (*pc)++; + } + while (isdigit(cast(int, **pc))) res = res*10 + (*(*pc)++) - '0'; + return sig*res; +} + +static const char *getname_aux (char *buff, const char **pc) { + int i = 0; + skip(pc); + while (**pc != '\0' && !strchr(delimits, **pc)) + buff[i++] = *(*pc)++; + buff[i] = '\0'; + return buff; +} + + +#define EQ(s1) (strcmp(s1, inst) == 0) + +#define getnum (getnum_aux(L, &pc)) +#define getname (getname_aux(buff, &pc)) + + +static int testC (lua_State *L) { + char buff[30]; + const char *pc = luaL_checkstring(L, 1); + for (;;) { + const char *inst = getname; + if EQ("") return 0; + else if EQ("isnumber") { + lua_pushintegral(L, lua_isnumber(L, getnum)); + } + else if EQ("isstring") { + lua_pushintegral(L, lua_isstring(L, getnum)); + } + else if EQ("istable") { + lua_pushintegral(L, lua_istable(L, getnum)); + } + else if EQ("iscfunction") { + lua_pushintegral(L, lua_iscfunction(L, getnum)); + } + else if EQ("isfunction") { + lua_pushintegral(L, lua_isfunction(L, getnum)); + } + else if EQ("isuserdata") { + lua_pushintegral(L, lua_isuserdata(L, getnum)); + } + else if EQ("isudataval") { + lua_pushintegral(L, lua_islightuserdata(L, getnum)); + } + else if EQ("isnil") { + lua_pushintegral(L, lua_isnil(L, getnum)); + } + else if EQ("isnull") { + lua_pushintegral(L, lua_isnone(L, getnum)); + } + else if EQ("tonumber") { + lua_pushnumber(L, lua_tonumber(L, getnum)); + } + else if EQ("tostring") { + const char *s = lua_tostring(L, getnum); + lua_pushstring(L, s); + } + else if EQ("strlen") { + lua_pushintegral(L, lua_strlen(L, getnum)); + } + else if EQ("tocfunction") { + lua_pushcfunction(L, lua_tocfunction(L, getnum)); + } + else if EQ("return") { + return getnum; + } + else if EQ("gettop") { + lua_pushintegral(L, lua_gettop(L)); + } + else if EQ("settop") { + lua_settop(L, getnum); + } + else if EQ("pop") { + lua_pop(L, getnum); + } + else if EQ("pushnum") { + lua_pushintegral(L, getnum); + } + else if EQ("pushnil") { + lua_pushnil(L); + } + else if EQ("pushbool") { + lua_pushboolean(L, getnum); + } + else if EQ("tobool") { + lua_pushintegral(L, lua_toboolean(L, getnum)); + } + else if EQ("pushvalue") { + lua_pushvalue(L, getnum); + } + else if EQ("pushcclosure") { + lua_pushcclosure(L, testC, getnum); + } + else if EQ("pushupvalues") { + lua_pushupvalues(L); + } + else if EQ("remove") { + lua_remove(L, getnum); + } + else if EQ("insert") { + lua_insert(L, getnum); + } + else if EQ("replace") { + lua_replace(L, getnum); + } + else if EQ("gettable") { + lua_gettable(L, getnum); + } + else if EQ("settable") { + lua_settable(L, getnum); + } + else if EQ("next") { + lua_next(L, -2); + } + else if EQ("concat") { + lua_concat(L, getnum); + } + else if EQ("lessthan") { + int a = getnum; + lua_pushboolean(L, lua_lessthan(L, a, getnum)); + } + else if EQ("equal") { + int a = getnum; + lua_pushboolean(L, lua_equal(L, a, getnum)); + } + else if EQ("rawcall") { + int narg = getnum; + int nres = getnum; + lua_call(L, narg, nres); + } + else if EQ("call") { + int narg = getnum; + int nres = getnum; + lua_pcall(L, narg, nres, 0); + } + else if EQ("loadstring") { + size_t sl; + const char *s = luaL_checklstring(L, getnum, &sl); + luaL_loadbuffer(L, s, sl, s); + } + else if EQ("loadfile") { + luaL_loadfile(L, luaL_checkstring(L, getnum)); + } + else if EQ("setmetatable") { + lua_setmetatable(L, getnum); + } + else if EQ("getmetatable") { + if (lua_getmetatable(L, getnum) == 0) + lua_pushnil(L); + } + else if EQ("type") { + lua_pushstring(L, lua_typename(L, lua_type(L, getnum))); + } + else if EQ("getn") { + int i = getnum; + lua_pushintegral(L, luaL_getn(L, i)); + } + else if EQ("setn") { + int i = getnum; + int n = cast(int, lua_tonumber(L, -1)); + luaL_setn(L, i, n); + lua_pop(L, 1); + } + else luaL_error(L, "unknown instruction %s", buff); + } + return 0; +} + +/* }====================================================== */ + + +/* +** {====================================================== +** tests for yield inside hooks +** ======================================================= +*/ + +static void yieldf (lua_State *L, lua_Debug *ar) { + lua_yield(L, 0); +} + +static int setyhook (lua_State *L) { + if (lua_isnoneornil(L, 1)) + lua_sethook(L, NULL, 0, 0); /* turn off hooks */ + else { + const char *smask = luaL_checkstring(L, 1); + int count = luaL_optint(L, 2, 0); + int mask = 0; + if (strchr(smask, 'l')) mask |= LUA_MASKLINE; + if (count > 0) mask |= LUA_MASKCOUNT; + lua_sethook(L, yieldf, mask, count); + } + return 0; +} + + +static int coresume (lua_State *L) { + int status; + lua_State *co = lua_tothread(L, 1); + luaL_argcheck(L, co, 1, "coroutine expected"); + status = lua_resume(co, 0); + if (status != 0) { + lua_pushboolean(L, 0); + lua_insert(L, -2); + return 2; /* return false + error message */ + } + else { + lua_pushboolean(L, 1); + return 1; + } +} + +/* }====================================================== */ + + + +static const struct luaL_reg tests_funcs[] = { + {"hash", hash_query}, + {"limits", get_limits}, + {"listcode", listcode}, + {"listk", listk}, + {"listlocals", listlocals}, + {"loadlib", loadlib}, + {"stacklevel", stacklevel}, + {"querystr", string_query}, + {"querytab", table_query}, + {"doit", test_do}, + {"testC", testC}, + {"ref", tref}, + {"getref", getref}, + {"unref", unref}, + {"d2s", d2s}, + {"s2d", s2d}, + {"metatable", metatable}, + {"upvalue", upvalue}, + {"newuserdata", newuserdata}, + {"pushuserdata", pushuserdata}, + {"udataval", udataval}, + {"doonnewstack", doonnewstack}, + {"newstate", newstate}, + {"closestate", closestate}, + {"doremote", doremote}, + {"log2", log2_aux}, + {"int2fb", int2fb_aux}, + {"totalmem", mem_query}, + {"resume", coresume}, + {"setyhook", setyhook}, + {NULL, NULL} +}; + + +static void fim (void) { + if (!islocked) + lua_close(lua_state); + lua_assert(memdebug_numblocks == 0); + lua_assert(memdebug_total == 0); +} + + +static int l_panic (lua_State *L) { + UNUSED(L); + fprintf(stderr, "unable to recover; exiting\n"); + return 0; +} + + +int luaB_opentests (lua_State *L) { + lua_atpanic(L, l_panic); + lua_userstateopen(L); /* init lock */ + lua_state = L; /* keep first state to be opened */ + luaL_openlib(L, "T", tests_funcs, 0); + atexit(fim); + return 0; +} + + +#undef main +int main (int argc, char *argv[]) { + char *limit = getenv("MEMLIMIT"); + if (limit) + memdebug_memlimit = strtoul(limit, NULL, 10); + l_main(argc, argv); + return 0; +} + +#endif diff --git a/stepmania/src/lua-5.0/src/ltm.c b/stepmania/src/lua-5.0/src/ltm.c new file mode 100644 index 0000000000..0001cb9c05 --- /dev/null +++ b/stepmania/src/lua-5.0/src/ltm.c @@ -0,0 +1,70 @@ +/* +** $Id$ +** Tag methods +** See Copyright Notice in lua.h +*/ + + +#include + +#define ltm_c + +#include "lua.h" + +#include "lobject.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" + + + +const char *const luaT_typenames[] = { + "nil", "boolean", "userdata", "number", + "string", "table", "function", "userdata", "thread" +}; + + +void luaT_init (lua_State *L) { + static const char *const luaT_eventname[] = { /* ORDER TM */ + "__index", "__newindex", + "__gc", "__mode", "__eq", + "__add", "__sub", "__mul", "__div", + "__pow", "__unm", "__lt", "__le", + "__concat", "__call" + }; + int i; + for (i=0; itmname[i] = luaS_new(L, luaT_eventname[i]); + luaS_fix(G(L)->tmname[i]); /* never collect these names */ + } +} + + +/* +** function to be used with macro "fasttm": optimized for absence of +** tag methods +*/ +const TObject *luaT_gettm (Table *events, TMS event, TString *ename) { + const TObject *tm = luaH_getstr(events, ename); + lua_assert(event <= TM_EQ); + if (ttisnil(tm)) { /* no tag method? */ + events->flags |= cast(lu_byte, 1u<tmname[event]; + switch (ttype(o)) { + case LUA_TTABLE: + return luaH_getstr(hvalue(o)->metatable, ename); + case LUA_TUSERDATA: + return luaH_getstr(uvalue(o)->uv.metatable, ename); + default: + return &luaO_nilobject; + } +} + diff --git a/stepmania/src/lua-5.0/src/ltm.h b/stepmania/src/lua-5.0/src/ltm.h new file mode 100644 index 0000000000..b874c49907 --- /dev/null +++ b/stepmania/src/lua-5.0/src/ltm.h @@ -0,0 +1,51 @@ +/* +** $Id$ +** Tag methods +** See Copyright Notice in lua.h +*/ + +#ifndef ltm_h +#define ltm_h + + +#include "lobject.h" + + +/* +* WARNING: if you change the order of this enumeration, +* grep "ORDER TM" +*/ +typedef enum { + TM_INDEX, + TM_NEWINDEX, + TM_GC, + TM_MODE, + TM_EQ, /* last tag method with `fast' access */ + TM_ADD, + TM_SUB, + TM_MUL, + TM_DIV, + TM_POW, + TM_UNM, + TM_LT, + TM_LE, + TM_CONCAT, + TM_CALL, + TM_N /* number of elements in the enum */ +} TMS; + + + +#define gfasttm(g,et,e) \ + (((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) + +#define fasttm(l,et,e) gfasttm(G(l), et, e) + + +const TObject *luaT_gettm (Table *events, TMS event, TString *ename); +const TObject *luaT_gettmbyobj (lua_State *L, const TObject *o, TMS event); +void luaT_init (lua_State *L); + +extern const char *const luaT_typenames[]; + +#endif diff --git a/stepmania/src/lua-5.0/src/lundump.c b/stepmania/src/lua-5.0/src/lundump.c new file mode 100644 index 0000000000..26a2b88ab2 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lundump.c @@ -0,0 +1,286 @@ +/* +** $Id$ +** load pre-compiled Lua chunks +** See Copyright Notice in lua.h +*/ + +#define lundump_c + +#include "lua.h" + +#include "ldebug.h" +#include "lfunc.h" +#include "lmem.h" +#include "lopcodes.h" +#include "lstring.h" +#include "lundump.h" +#include "lzio.h" + +#define LoadByte (lu_byte) ezgetc + +typedef struct { + lua_State* L; + ZIO* Z; + Mbuffer* b; + int swap; + const char* name; +} LoadState; + +static void unexpectedEOZ (LoadState* S) +{ + luaG_runerror(S->L,"unexpected end of file in %s",S->name); +} + +static int ezgetc (LoadState* S) +{ + int c=zgetc(S->Z); + if (c==EOZ) unexpectedEOZ(S); + return c; +} + +static void ezread (LoadState* S, void* b, int n) +{ + int r=luaZ_read(S->Z,b,n); + if (r!=0) unexpectedEOZ(S); +} + +static void LoadBlock (LoadState* S, void* b, size_t size) +{ + if (S->swap) + { + char* p=(char*) b+size-1; + int n=size; + while (n--) *p--=(char)ezgetc(S); + } + else + ezread(S,b,size); +} + +static void LoadVector (LoadState* S, void* b, int m, size_t size) +{ + if (S->swap) + { + char* q=(char*) b; + while (m--) + { + char* p=q+size-1; + int n=size; + while (n--) *p--=(char)ezgetc(S); + q+=size; + } + } + else + ezread(S,b,m*size); +} + +static int LoadInt (LoadState* S) +{ + int x; + LoadBlock(S,&x,sizeof(x)); + if (x<0) luaG_runerror(S->L,"bad integer in %s",S->name); + return x; +} + +static size_t LoadSize (LoadState* S) +{ + size_t x; + LoadBlock(S,&x,sizeof(x)); + return x; +} + +static lua_Number LoadNumber (LoadState* S) +{ + lua_Number x; + LoadBlock(S,&x,sizeof(x)); + return x; +} + +static TString* LoadString (LoadState* S) +{ + size_t size=LoadSize(S); + if (size==0) + return NULL; + else + { + char* s=luaZ_openspace(S->L,S->b,size); + ezread(S,s,size); + return luaS_newlstr(S->L,s,size-1); /* remove trailing '\0' */ + } +} + +static void LoadCode (LoadState* S, Proto* f) +{ + int size=LoadInt(S); + f->code=luaM_newvector(S->L,size,Instruction); + f->sizecode=size; + LoadVector(S,f->code,size,sizeof(*f->code)); +} + +static void LoadLocals (LoadState* S, Proto* f) +{ + int i,n; + n=LoadInt(S); + f->locvars=luaM_newvector(S->L,n,LocVar); + f->sizelocvars=n; + for (i=0; ilocvars[i].varname=LoadString(S); + f->locvars[i].startpc=LoadInt(S); + f->locvars[i].endpc=LoadInt(S); + } +} + +static void LoadLines (LoadState* S, Proto* f) +{ + int size=LoadInt(S); + f->lineinfo=luaM_newvector(S->L,size,int); + f->sizelineinfo=size; + LoadVector(S,f->lineinfo,size,sizeof(*f->lineinfo)); +} + +static void LoadUpvalues (LoadState* S, Proto* f) +{ + int i,n; + n=LoadInt(S); + if (n!=0 && n!=f->nups) + luaG_runerror(S->L,"bad nupvalues in %s: read %d; expected %d", + S->name,n,f->nups); + f->upvalues=luaM_newvector(S->L,n,TString*); + f->sizeupvalues=n; + for (i=0; iupvalues[i]=LoadString(S); +} + +static Proto* LoadFunction (LoadState* S, TString* p); + +static void LoadConstants (LoadState* S, Proto* f) +{ + int i,n; + n=LoadInt(S); + f->k=luaM_newvector(S->L,n,TObject); + f->sizek=n; + for (i=0; ik[i]; + int t=LoadByte(S); + switch (t) + { + case LUA_TNUMBER: + setnvalue(o,LoadNumber(S)); + break; + case LUA_TSTRING: + setsvalue2n(o,LoadString(S)); + break; + case LUA_TNIL: + setnilvalue(o); + break; + default: + luaG_runerror(S->L,"bad constant type (%d) in %s",t,S->name); + break; + } + } + n=LoadInt(S); + f->p=luaM_newvector(S->L,n,Proto*); + f->sizep=n; + for (i=0; ip[i]=LoadFunction(S,f->source); +} + +static Proto* LoadFunction (LoadState* S, TString* p) +{ + Proto* f=luaF_newproto(S->L); + f->source=LoadString(S); if (f->source==NULL) f->source=p; + f->lineDefined=LoadInt(S); + f->nups=LoadByte(S); + f->numparams=LoadByte(S); + f->is_vararg=LoadByte(S); + f->maxstacksize=LoadByte(S); + LoadLines(S,f); + LoadLocals(S,f); + LoadUpvalues(S,f); + LoadConstants(S,f); + LoadCode(S,f); +#ifndef TRUST_BINARIES + if (!luaG_checkcode(f)) luaG_runerror(S->L,"bad code in %s",S->name); +#endif + return f; +} + +static void LoadSignature (LoadState* S) +{ + const char* s=LUA_SIGNATURE; + while (*s!=0 && ezgetc(S)==*s) + ++s; + if (*s!=0) luaG_runerror(S->L,"bad signature in %s",S->name); +} + +static void TestSize (LoadState* S, int s, const char* what) +{ + int r=LoadByte(S); + if (r!=s) + luaG_runerror(S->L,"virtual machine mismatch in %s: " + "size of %s is %d but read %d",S->name,what,s,r); +} + +#define TESTSIZE(s,w) TestSize(S,s,w) +#define V(v) v/16,v%16 + +static void LoadHeader (LoadState* S) +{ + int version; + lua_Number x,tx=TEST_NUMBER; + LoadSignature(S); + version=LoadByte(S); + if (version>VERSION) + luaG_runerror(S->L,"%s too new: " + "read version %d.%d; expected at most %d.%d", + S->name,V(version),V(VERSION)); + if (versionL,"%s too old: " + "read version %d.%d; expected at least %d.%d", + S->name,V(version),V(VERSION0)); + S->swap=(luaU_endianness()!=LoadByte(S)); /* need to swap bytes? */ + TESTSIZE(sizeof(int),"int"); + TESTSIZE(sizeof(size_t), "size_t"); + TESTSIZE(sizeof(Instruction), "Instruction"); + TESTSIZE(SIZE_OP, "OP"); + TESTSIZE(SIZE_A, "A"); + TESTSIZE(SIZE_B, "B"); + TESTSIZE(SIZE_C, "C"); + TESTSIZE(sizeof(lua_Number), "number"); + x=LoadNumber(S); + if ((long)x!=(long)tx) /* disregard errors in last bits of fraction */ + luaG_runerror(S->L,"unknown number format in %s",S->name); +} + +static Proto* LoadChunk (LoadState* S) +{ + LoadHeader(S); + return LoadFunction(S,NULL); +} + +/* +** load precompiled chunk +*/ +Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff) +{ + LoadState S; + const char* s=zname(Z); + if (*s=='@' || *s=='=') + S.name=s+1; + else if (*s==LUA_SIGNATURE[0]) + S.name="binary string"; + else + S.name=s; + S.L=L; + S.Z=Z; + S.b=buff; + return LoadChunk(&S); +} + +/* +** find byte order +*/ +int luaU_endianness (void) +{ + int x=1; + return *(char*)&x; +} diff --git a/stepmania/src/lua-5.0/src/lundump.h b/stepmania/src/lua-5.0/src/lundump.h new file mode 100644 index 0000000000..e280d3694b --- /dev/null +++ b/stepmania/src/lua-5.0/src/lundump.h @@ -0,0 +1,34 @@ +/* +** $Id$ +** load pre-compiled Lua chunks +** See Copyright Notice in lua.h +*/ + +#ifndef lundump_h +#define lundump_h + +#include "lobject.h" +#include "lzio.h" + +/* load one chunk; from lundump.c */ +Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff); + +/* find byte order; from lundump.c */ +int luaU_endianness (void); + +/* dump one chunk; from ldump.c */ +void luaU_dump (lua_State* L, const Proto* Main, lua_Chunkwriter w, void* data); + +/* print one chunk; from print.c */ +void luaU_print (const Proto* Main); + +/* definitions for headers of binary files */ +#define LUA_SIGNATURE "\033Lua" /* binary files start with "Lua" */ +#define VERSION 0x50 /* last format change was in 5.0 */ +#define VERSION0 0x50 /* last major change was in 5.0 */ + +/* a multiple of PI for testing native format */ +/* multiplying by 1E7 gives non-trivial integer values */ +#define TEST_NUMBER ((lua_Number)3.14159265358979323846E7) + +#endif diff --git a/stepmania/src/lua-5.0/src/lvm.c b/stepmania/src/lua-5.0/src/lvm.c new file mode 100644 index 0000000000..db221b5387 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lvm.c @@ -0,0 +1,781 @@ +/* +** $Id$ +** Lua virtual machine +** See Copyright Notice in lua.h +*/ + + +#include +#include +#include + +/* needed only when `lua_number2str' uses `sprintf' */ +#include + +#define lvm_c + +#include "lua.h" + +#include "ldebug.h" +#include "ldo.h" +#include "lfunc.h" +#include "lgc.h" +#include "lobject.h" +#include "lopcodes.h" +#include "lstate.h" +#include "lstring.h" +#include "ltable.h" +#include "ltm.h" +#include "lvm.h" + + + +/* function to convert a lua_Number to a string */ +#ifndef lua_number2str +#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n)) +#endif + + +/* limit for table tag-method chains (to avoid loops) */ +#define MAXTAGLOOP 100 + + +const TObject *luaV_tonumber (const TObject *obj, TObject *n) { + lua_Number num; + if (ttisnumber(obj)) return obj; + if (ttisstring(obj) && luaO_str2d(svalue(obj), &num)) { + setnvalue(n, num); + return n; + } + else + return NULL; +} + + +int luaV_tostring (lua_State *L, StkId obj) { + if (!ttisnumber(obj)) + return 0; + else { + char s[32]; /* 16 digits, sign, point and \0 (+ some extra...) */ + lua_number2str(s, nvalue(obj)); + setsvalue2s(obj, luaS_new(L, s)); + return 1; + } +} + + +static void traceexec (lua_State *L) { + lu_byte mask = L->hookmask; + if (mask & LUA_MASKCOUNT) { /* instruction-hook set? */ + if (L->hookcount == 0) { + resethookcount(L); + luaD_callhook(L, LUA_HOOKCOUNT, -1); + return; + } + } + if (mask & LUA_MASKLINE) { + CallInfo *ci = L->ci; + Proto *p = ci_func(ci)->l.p; + int newline = getline(p, pcRel(*ci->u.l.pc, p)); + if (!L->hookinit) { + luaG_inithooks(L); + return; + } + lua_assert(ci->state & CI_HASFRAME); + if (pcRel(*ci->u.l.pc, p) == 0) /* tracing may be starting now? */ + ci->u.l.savedpc = *ci->u.l.pc; /* initialize `savedpc' */ + /* calls linehook when enters a new line or jumps back (loop) */ + if (*ci->u.l.pc <= ci->u.l.savedpc || + newline != getline(p, pcRel(ci->u.l.savedpc, p))) { + luaD_callhook(L, LUA_HOOKLINE, newline); + ci = L->ci; /* previous call may reallocate `ci' */ + } + ci->u.l.savedpc = *ci->u.l.pc; + } +} + + +static void callTMres (lua_State *L, const TObject *f, + const TObject *p1, const TObject *p2) { + setobj2s(L->top, f); /* push function */ + setobj2s(L->top+1, p1); /* 1st argument */ + setobj2s(L->top+2, p2); /* 2nd argument */ + luaD_checkstack(L, 3); /* cannot check before (could invalidate p1, p2) */ + L->top += 3; + luaD_call(L, L->top - 3, 1); + L->top--; /* result will be in L->top */ +} + + + +static void callTM (lua_State *L, const TObject *f, + const TObject *p1, const TObject *p2, const TObject *p3) { + setobj2s(L->top, f); /* push function */ + setobj2s(L->top+1, p1); /* 1st argument */ + setobj2s(L->top+2, p2); /* 2nd argument */ + setobj2s(L->top+3, p3); /* 3th argument */ + luaD_checkstack(L, 4); /* cannot check before (could invalidate p1...p3) */ + L->top += 4; + luaD_call(L, L->top - 4, 0); +} + + +static const TObject *luaV_index (lua_State *L, const TObject *t, + TObject *key, int loop) { + const TObject *tm = fasttm(L, hvalue(t)->metatable, TM_INDEX); + if (tm == NULL) return &luaO_nilobject; /* no TM */ + if (ttisfunction(tm)) { + callTMres(L, tm, t, key); + return L->top; + } + else return luaV_gettable(L, tm, key, loop); +} + +static const TObject *luaV_getnotable (lua_State *L, const TObject *t, + TObject *key, int loop) { + const TObject *tm = luaT_gettmbyobj(L, t, TM_INDEX); + if (ttisnil(tm)) + luaG_typeerror(L, t, "index"); + if (ttisfunction(tm)) { + callTMres(L, tm, t, key); + return L->top; + } + else return luaV_gettable(L, tm, key, loop); +} + + +/* +** Function to index a table. +** Receives the table at `t' and the key at `key'. +** leaves the result at `res'. +*/ +const TObject *luaV_gettable (lua_State *L, const TObject *t, TObject *key, + int loop) { + if (loop > MAXTAGLOOP) + luaG_runerror(L, "loop in gettable"); + if (ttistable(t)) { /* `t' is a table? */ + Table *h = hvalue(t); + const TObject *v = luaH_get(h, key); /* do a primitive get */ + if (!ttisnil(v)) return v; + else return luaV_index(L, t, key, loop+1); + } + else return luaV_getnotable(L, t, key, loop+1); +} + + +/* +** Receives table at `t', key at `key' and value at `val'. +*/ +void luaV_settable (lua_State *L, const TObject *t, TObject *key, StkId val) { + const TObject *tm; + int loop = 0; + do { + if (ttistable(t)) { /* `t' is a table? */ + Table *h = hvalue(t); + TObject *oldval = luaH_set(L, h, key); /* do a primitive set */ + if (!ttisnil(oldval) || /* result is no nil? */ + (tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL) { /* or no TM? */ + setobj2t(oldval, val); /* write barrier */ + return; + } + /* else will try the tag method */ + } + else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))) + luaG_typeerror(L, t, "index"); + if (ttisfunction(tm)) { + callTM(L, tm, t, key, val); + return; + } + t = tm; /* else repeat with `tm' */ + } while (++loop <= MAXTAGLOOP); + luaG_runerror(L, "loop in settable"); +} + + +static int call_binTM (lua_State *L, const TObject *p1, const TObject *p2, + StkId res, TMS event) { + ptrdiff_t result = savestack(L, res); + const TObject *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */ + if (ttisnil(tm)) + tm = luaT_gettmbyobj(L, p2, event); /* try second operand */ + if (!ttisfunction(tm)) return 0; + callTMres(L, tm, p1, p2); + res = restorestack(L, result); /* previous call may change stack */ + setobjs2s(res, L->top); + return 1; +} + + +static const TObject *get_compTM (lua_State *L, Table *mt1, Table *mt2, + TMS event) { + const TObject *tm1 = fasttm(L, mt1, event); + const TObject *tm2; + if (tm1 == NULL) return NULL; /* no metamethod */ + if (mt1 == mt2) return tm1; /* same metatables => same metamethods */ + tm2 = fasttm(L, mt2, event); + if (tm2 == NULL) return NULL; /* no metamethod */ + if (luaO_rawequalObj(tm1, tm2)) /* same metamethods? */ + return tm1; + return NULL; +} + + +static int call_orderTM (lua_State *L, const TObject *p1, const TObject *p2, + TMS event) { + const TObject *tm1 = luaT_gettmbyobj(L, p1, event); + const TObject *tm2; + if (ttisnil(tm1)) return -1; /* no metamethod? */ + tm2 = luaT_gettmbyobj(L, p2, event); + if (!luaO_rawequalObj(tm1, tm2)) /* different metamethods? */ + return -1; + callTMres(L, tm1, p1, p2); + return !l_isfalse(L->top); +} + + +static int luaV_strcmp (const TString *ls, const TString *rs) { + const char *l = getstr(ls); + size_t ll = ls->tsv.len; + const char *r = getstr(rs); + size_t lr = rs->tsv.len; + for (;;) { + int temp = strcoll(l, r); + if (temp != 0) return temp; + else { /* strings are equal up to a `\0' */ + size_t len = strlen(l); /* index of first `\0' in both strings */ + if (len == lr) /* r is finished? */ + return (len == ll) ? 0 : 1; + else if (len == ll) /* l is finished? */ + return -1; /* l is smaller than r (because r is not finished) */ + /* both strings longer than `len'; go on comparing (after the `\0') */ + len++; + l += len; ll -= len; r += len; lr -= len; + } + } +} + + +int luaV_lessthan (lua_State *L, const TObject *l, const TObject *r) { + int res; + if (ttype(l) != ttype(r)) + return luaG_ordererror(L, l, r); + else if (ttisnumber(l)) + return nvalue(l) < nvalue(r); + else if (ttisstring(l)) + return luaV_strcmp(tsvalue(l), tsvalue(r)) < 0; + else if ((res = call_orderTM(L, l, r, TM_LT)) != -1) + return res; + return luaG_ordererror(L, l, r); +} + + +static int luaV_lessequal (lua_State *L, const TObject *l, const TObject *r) { + int res; + if (ttype(l) != ttype(r)) + return luaG_ordererror(L, l, r); + else if (ttisnumber(l)) + return nvalue(l) <= nvalue(r); + else if (ttisstring(l)) + return luaV_strcmp(tsvalue(l), tsvalue(r)) <= 0; + else if ((res = call_orderTM(L, l, r, TM_LE)) != -1) /* first try `le' */ + return res; + else if ((res = call_orderTM(L, r, l, TM_LT)) != -1) /* else try `lt' */ + return !res; + return luaG_ordererror(L, l, r); +} + + +int luaV_equalval (lua_State *L, const TObject *t1, const TObject *t2) { + const TObject *tm; + lua_assert(ttype(t1) == ttype(t2)); + switch (ttype(t1)) { + case LUA_TNIL: return 1; + case LUA_TNUMBER: return nvalue(t1) == nvalue(t2); + case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2); /* true must be 1 !! */ + case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2); + case LUA_TUSERDATA: { + if (uvalue(t1) == uvalue(t2)) return 1; + tm = get_compTM(L, uvalue(t1)->uv.metatable, uvalue(t2)->uv.metatable, + TM_EQ); + break; /* will try TM */ + } + case LUA_TTABLE: { + if (hvalue(t1) == hvalue(t2)) return 1; + tm = get_compTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ); + break; /* will try TM */ + } + default: return gcvalue(t1) == gcvalue(t2); + } + if (tm == NULL) return 0; /* no TM? */ + callTMres(L, tm, t1, t2); /* call TM */ + return !l_isfalse(L->top); +} + + +void luaV_concat (lua_State *L, int total, int last) { + do { + StkId top = L->base + last + 1; + int n = 2; /* number of elements handled in this pass (at least 2) */ + if (!tostring(L, top-2) || !tostring(L, top-1)) { + if (!call_binTM(L, top-2, top-1, top-2, TM_CONCAT)) + luaG_concaterror(L, top-2, top-1); + } else if (tsvalue(top-1)->tsv.len > 0) { /* if len=0, do nothing */ + /* at least two string values; get as many as possible */ + lu_mem tl = cast(lu_mem, tsvalue(top-1)->tsv.len) + + cast(lu_mem, tsvalue(top-2)->tsv.len); + char *buffer; + int i; + while (n < total && tostring(L, top-n-1)) { /* collect total length */ + tl += tsvalue(top-n-1)->tsv.len; + n++; + } + if (tl > MAX_SIZET) luaG_runerror(L, "string size overflow"); + buffer = luaZ_openspace(L, &G(L)->buff, tl); + tl = 0; + for (i=n; i>0; i--) { /* concat all strings */ + size_t l = tsvalue(top-i)->tsv.len; + memcpy(buffer+tl, svalue(top-i), l); + tl += l; + } + setsvalue2s(top-n, luaS_newlstr(L, buffer, tl)); + } + total -= n-1; /* got `n' strings to create 1 new */ + last -= n-1; + } while (total > 1); /* repeat until only 1 result left */ +} + + +static void Arith (lua_State *L, StkId ra, + const TObject *rb, const TObject *rc, TMS op) { + TObject tempb, tempc; + const TObject *b, *c; + if ((b = luaV_tonumber(rb, &tempb)) != NULL && + (c = luaV_tonumber(rc, &tempc)) != NULL) { + switch (op) { + case TM_ADD: setnvalue(ra, nvalue(b) + nvalue(c)); break; + case TM_SUB: setnvalue(ra, nvalue(b) - nvalue(c)); break; + case TM_MUL: setnvalue(ra, nvalue(b) * nvalue(c)); break; + case TM_DIV: setnvalue(ra, nvalue(b) / nvalue(c)); break; + case TM_POW: { + const TObject *f = luaH_getstr(hvalue(gt(L)), G(L)->tmname[TM_POW]); + ptrdiff_t res = savestack(L, ra); + if (!ttisfunction(f)) + luaG_runerror(L, "`__pow' (`^' operator) is not a function"); + callTMres(L, f, b, c); + ra = restorestack(L, res); /* previous call may change stack */ + setobjs2s(ra, L->top); + break; + } + default: lua_assert(0); break; + } + } + else if (!call_binTM(L, rb, rc, ra, op)) + luaG_aritherror(L, rb, rc); +} + + + +/* +** some macros for common tasks in `luaV_execute' +*/ + +#define runtime_check(L, c) { if (!(c)) return 0; } + +#define RA(i) (base+GETARG_A(i)) +/* to be used after possible stack reallocation */ +#define XRA(i) (L->base+GETARG_A(i)) +#define RB(i) (base+GETARG_B(i)) +#define RKB(i) ((GETARG_B(i) < MAXSTACK) ? RB(i) : k+GETARG_B(i)-MAXSTACK) +#define RC(i) (base+GETARG_C(i)) +#define RKC(i) ((GETARG_C(i) < MAXSTACK) ? RC(i) : k+GETARG_C(i)-MAXSTACK) +#define KBx(i) (k+GETARG_Bx(i)) + + +#define dojump(pc, i) ((pc) += (i)) + + +StkId luaV_execute (lua_State *L) { + LClosure *cl; + TObject *k; + const Instruction *pc; + callentry: /* entry point when calling new functions */ + if (L->hookmask & LUA_MASKCALL) { + L->ci->u.l.pc = &pc; + luaD_callhook(L, LUA_HOOKCALL, -1); + } + retentry: /* entry point when returning to old functions */ + L->ci->u.l.pc = &pc; + lua_assert(L->ci->state == CI_SAVEDPC || + L->ci->state == (CI_SAVEDPC | CI_CALLING)); + L->ci->state = CI_HASFRAME; /* activate frame */ + pc = L->ci->u.l.savedpc; + cl = &clvalue(L->base - 1)->l; + k = cl->p->k; + /* main loop of interpreter */ + for (;;) { + const Instruction i = *pc++; + StkId base, ra; + if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) && + (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) { + traceexec(L); + if (L->ci->state & CI_YIELD) { /* did hook yield? */ + L->ci->u.l.savedpc = pc - 1; + L->ci->state = CI_YIELD | CI_SAVEDPC; + return NULL; + } + } + /* warning!! several calls may realloc the stack and invalidate `ra' */ + base = L->base; + ra = RA(i); + lua_assert(L->ci->state & CI_HASFRAME); + lua_assert(base == L->ci->base); + lua_assert(L->top <= L->stack + L->stacksize && L->top >= base); + lua_assert(L->top == L->ci->top || + GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL || + GET_OPCODE(i) == OP_RETURN || GET_OPCODE(i) == OP_SETLISTO); + switch (GET_OPCODE(i)) { + case OP_MOVE: { + setobjs2s(ra, RB(i)); + break; + } + case OP_LOADK: { + setobj2s(ra, KBx(i)); + break; + } + case OP_LOADBOOL: { + setbvalue(ra, GETARG_B(i)); + if (GETARG_C(i)) pc++; /* skip next instruction (if C) */ + break; + } + case OP_LOADNIL: { + TObject *rb = RB(i); + do { + setnilvalue(rb--); + } while (rb >= ra); + break; + } + case OP_GETUPVAL: { + int b = GETARG_B(i); + setobj2s(ra, cl->upvals[b]->v); + break; + } + case OP_GETGLOBAL: { + TObject *rb = KBx(i); + const TObject *v; + lua_assert(ttisstring(rb) && ttistable(&cl->g)); + v = luaH_getstr(hvalue(&cl->g), tsvalue(rb)); + if (!ttisnil(v)) { setobj2s(ra, v); } + else + setobj2s(XRA(i), luaV_index(L, &cl->g, rb, 0)); + break; + } + case OP_GETTABLE: { + StkId rb = RB(i); + TObject *rc = RKC(i); + if (ttistable(rb)) { + const TObject *v = luaH_get(hvalue(rb), rc); + if (!ttisnil(v)) { setobj2s(ra, v); } + else + setobj2s(XRA(i), luaV_index(L, rb, rc, 0)); + } + else + setobj2s(XRA(i), luaV_getnotable(L, rb, rc, 0)); + break; + } + case OP_SETGLOBAL: { + lua_assert(ttisstring(KBx(i)) && ttistable(&cl->g)); + luaV_settable(L, &cl->g, KBx(i), ra); + break; + } + case OP_SETUPVAL: { + int b = GETARG_B(i); + setobj(cl->upvals[b]->v, ra); /* write barrier */ + break; + } + case OP_SETTABLE: { + luaV_settable(L, ra, RKB(i), RKC(i)); + break; + } + case OP_NEWTABLE: { + int b = GETARG_B(i); + b = fb2int(b); + sethvalue(ra, luaH_new(L, b, GETARG_C(i))); + luaC_checkGC(L); + break; + } + case OP_SELF: { + StkId rb = RB(i); + TObject *rc = RKC(i); + runtime_check(L, ttisstring(rc)); + setobjs2s(ra+1, rb); + if (ttistable(rb)) { + const TObject *v = luaH_getstr(hvalue(rb), tsvalue(rc)); + if (!ttisnil(v)) { setobj2s(ra, v); } + else + setobj2s(XRA(i), luaV_index(L, rb, rc, 0)); + } + else + setobj2s(XRA(i), luaV_getnotable(L, rb, rc, 0)); + break; + } + case OP_ADD: { + TObject *rb = RKB(i); + TObject *rc = RKC(i); + if (ttisnumber(rb) && ttisnumber(rc)) { + setnvalue(ra, nvalue(rb) + nvalue(rc)); + } + else + Arith(L, ra, rb, rc, TM_ADD); + break; + } + case OP_SUB: { + TObject *rb = RKB(i); + TObject *rc = RKC(i); + if (ttisnumber(rb) && ttisnumber(rc)) { + setnvalue(ra, nvalue(rb) - nvalue(rc)); + } + else + Arith(L, ra, rb, rc, TM_SUB); + break; + } + case OP_MUL: { + TObject *rb = RKB(i); + TObject *rc = RKC(i); + if (ttisnumber(rb) && ttisnumber(rc)) { + setnvalue(ra, nvalue(rb) * nvalue(rc)); + } + else + Arith(L, ra, rb, rc, TM_MUL); + break; + } + case OP_DIV: { + TObject *rb = RKB(i); + TObject *rc = RKC(i); + if (ttisnumber(rb) && ttisnumber(rc)) { + setnvalue(ra, nvalue(rb) / nvalue(rc)); + } + else + Arith(L, ra, rb, rc, TM_DIV); + break; + } + case OP_POW: { + Arith(L, ra, RKB(i), RKC(i), TM_POW); + break; + } + case OP_UNM: { + const TObject *rb = RB(i); + TObject temp; + if (tonumber(rb, &temp)) { + setnvalue(ra, -nvalue(rb)); + } + else { + setnilvalue(&temp); + if (!call_binTM(L, RB(i), &temp, ra, TM_UNM)) + luaG_aritherror(L, RB(i), &temp); + } + break; + } + case OP_NOT: { + int res = l_isfalse(RB(i)); /* next assignment may change this value */ + setbvalue(ra, res); + break; + } + case OP_CONCAT: { + int b = GETARG_B(i); + int c = GETARG_C(i); + luaV_concat(L, c-b+1, c); /* may change `base' (and `ra') */ + base = L->base; + setobjs2s(RA(i), base+b); + luaC_checkGC(L); + break; + } + case OP_JMP: { + dojump(pc, GETARG_sBx(i)); + break; + } + case OP_EQ: { + if (equalobj(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++; + else dojump(pc, GETARG_sBx(*pc) + 1); + break; + } + case OP_LT: { + if (luaV_lessthan(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++; + else dojump(pc, GETARG_sBx(*pc) + 1); + break; + } + case OP_LE: { + if (luaV_lessequal(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++; + else dojump(pc, GETARG_sBx(*pc) + 1); + break; + } + case OP_TEST: { + TObject *rb = RB(i); + if (l_isfalse(rb) == GETARG_C(i)) pc++; + else { + setobjs2s(ra, rb); + dojump(pc, GETARG_sBx(*pc) + 1); + } + break; + } + case OP_CALL: + case OP_TAILCALL: { + StkId firstResult; + int b = GETARG_B(i); + int nresults; + if (b != 0) L->top = ra+b; /* else previous instruction set top */ + nresults = GETARG_C(i) - 1; + firstResult = luaD_precall(L, ra); + if (firstResult) { + if (firstResult > L->top) { /* yield? */ + lua_assert(L->ci->state == (CI_C | CI_YIELD)); + (L->ci - 1)->u.l.savedpc = pc; + (L->ci - 1)->state = CI_SAVEDPC; + return NULL; + } + /* it was a C function (`precall' called it); adjust results */ + luaD_poscall(L, nresults, firstResult); + if (nresults >= 0) L->top = L->ci->top; + } + else { /* it is a Lua function */ + if (GET_OPCODE(i) == OP_CALL) { /* regular call? */ + (L->ci-1)->u.l.savedpc = pc; /* save `pc' to return later */ + (L->ci-1)->state = (CI_SAVEDPC | CI_CALLING); + } + else { /* tail call: put new frame in place of previous one */ + int aux; + base = (L->ci - 1)->base; /* `luaD_precall' may change the stack */ + ra = RA(i); + if (L->openupval) luaF_close(L, base); + for (aux = 0; ra+aux < L->top; aux++) /* move frame down */ + setobjs2s(base+aux-1, ra+aux); + (L->ci - 1)->top = L->top = base+aux; /* correct top */ + lua_assert(L->ci->state & CI_SAVEDPC); + (L->ci - 1)->u.l.savedpc = L->ci->u.l.savedpc; + (L->ci - 1)->u.l.tailcalls++; /* one more call lost */ + (L->ci - 1)->state = CI_SAVEDPC; + L->ci--; /* remove new frame */ + L->base = L->ci->base; + } + goto callentry; + } + break; + } + case OP_RETURN: { + CallInfo *ci = L->ci - 1; /* previous function frame */ + int b = GETARG_B(i); + if (b != 0) L->top = ra+b-1; + lua_assert(L->ci->state & CI_HASFRAME); + if (L->openupval) luaF_close(L, base); + L->ci->state = CI_SAVEDPC; /* deactivate current function */ + L->ci->u.l.savedpc = pc; + /* previous function was running `here'? */ + if (!(ci->state & CI_CALLING)) { + lua_assert((ci->state & CI_C) || ci->u.l.pc != &pc); + return ra; /* no: return */ + } + else { /* yes: continue its execution */ + int nresults; + lua_assert(ttisfunction(ci->base - 1) && (ci->state & CI_SAVEDPC)); + lua_assert(GET_OPCODE(*(ci->u.l.savedpc - 1)) == OP_CALL); + nresults = GETARG_C(*(ci->u.l.savedpc - 1)) - 1; + luaD_poscall(L, nresults, ra); + if (nresults >= 0) L->top = L->ci->top; + goto retentry; + } + } + case OP_FORLOOP: { + lua_Number step, idx, limit; + const TObject *plimit = ra+1; + const TObject *pstep = ra+2; + if (!ttisnumber(ra)) + luaG_runerror(L, "`for' initial value must be a number"); + if (!tonumber(plimit, ra+1)) + luaG_runerror(L, "`for' limit must be a number"); + if (!tonumber(pstep, ra+2)) + luaG_runerror(L, "`for' step must be a number"); + step = nvalue(pstep); + idx = nvalue(ra) + step; /* increment index */ + limit = nvalue(plimit); + if (step > 0 ? idx <= limit : idx >= limit) { + dojump(pc, GETARG_sBx(i)); /* jump back */ + chgnvalue(ra, idx); /* update index */ + } + break; + } + case OP_TFORLOOP: { + int nvar = GETARG_C(i) + 1; + StkId cb = ra + nvar + 2; /* call base */ + setobjs2s(cb, ra); + setobjs2s(cb+1, ra+1); + setobjs2s(cb+2, ra+2); + L->top = cb+3; /* func. + 2 args (state and index) */ + luaD_call(L, cb, nvar); + L->top = L->ci->top; + ra = XRA(i) + 2; /* final position of first result */ + cb = ra + nvar; + do { /* move results to proper positions */ + nvar--; + setobjs2s(ra+nvar, cb+nvar); + } while (nvar > 0); + if (ttisnil(ra)) /* break loop? */ + pc++; /* skip jump (break loop) */ + else + dojump(pc, GETARG_sBx(*pc) + 1); /* jump back */ + break; + } + case OP_TFORPREP: { /* for compatibility only */ + if (ttistable(ra)) { + setobjs2s(ra+1, ra); + setobj2s(ra, luaH_getstr(hvalue(gt(L)), luaS_new(L, "next"))); + } + dojump(pc, GETARG_sBx(i)); + break; + } + case OP_SETLIST: + case OP_SETLISTO: { + int bc; + int n; + Table *h; + runtime_check(L, ttistable(ra)); + h = hvalue(ra); + bc = GETARG_Bx(i); + if (GET_OPCODE(i) == OP_SETLIST) + n = (bc&(LFIELDS_PER_FLUSH-1)) + 1; + else { + n = L->top - ra - 1; + L->top = L->ci->top; + } + bc &= ~(LFIELDS_PER_FLUSH-1); /* bc = bc - bc%FPF */ + for (; n > 0; n--) + setobj2t(luaH_setnum(L, h, bc+n), ra+n); /* write barrier */ + break; + } + case OP_CLOSE: { + luaF_close(L, ra); + break; + } + case OP_CLOSURE: { + Proto *p; + Closure *ncl; + int nup, j; + p = cl->p->p[GETARG_Bx(i)]; + nup = p->nups; + ncl = luaF_newLclosure(L, nup, &cl->g); + ncl->l.p = p; + for (j=0; jl.upvals[j] = cl->upvals[GETARG_B(*pc)]; + else { + lua_assert(GET_OPCODE(*pc) == OP_MOVE); + ncl->l.upvals[j] = luaF_findupval(L, base + GETARG_B(*pc)); + } + } + setclvalue(ra, ncl); + luaC_checkGC(L); + break; + } + } + } +} + + diff --git a/stepmania/src/lua-5.0/src/lvm.h b/stepmania/src/lua-5.0/src/lvm.h new file mode 100644 index 0000000000..73deae4eda --- /dev/null +++ b/stepmania/src/lua-5.0/src/lvm.h @@ -0,0 +1,35 @@ +/* +** $Id$ +** Lua virtual machine +** See Copyright Notice in lua.h +*/ + +#ifndef lvm_h +#define lvm_h + + +#include "ldo.h" +#include "lobject.h" +#include "ltm.h" + + +#define tostring(L,o) ((ttype(o) == LUA_TSTRING) || (luaV_tostring(L, o))) + +#define tonumber(o,n) (ttype(o) == LUA_TNUMBER || \ + (((o) = luaV_tonumber(o,n)) != NULL)) + +#define equalobj(L,o1,o2) \ + (ttype(o1) == ttype(o2) && luaV_equalval(L, o1, o2)) + + +int luaV_lessthan (lua_State *L, const TObject *l, const TObject *r); +int luaV_equalval (lua_State *L, const TObject *t1, const TObject *t2); +const TObject *luaV_tonumber (const TObject *obj, TObject *n); +int luaV_tostring (lua_State *L, StkId obj); +const TObject *luaV_gettable (lua_State *L, const TObject *t, TObject *key, + int loop); +void luaV_settable (lua_State *L, const TObject *t, TObject *key, StkId val); +StkId luaV_execute (lua_State *L); +void luaV_concat (lua_State *L, int total, int last); + +#endif diff --git a/stepmania/src/lua-5.0/src/lzio.c b/stepmania/src/lua-5.0/src/lzio.c new file mode 100644 index 0000000000..5a49621890 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lzio.c @@ -0,0 +1,81 @@ +/* +** $Id$ +** a generic input stream interface +** See Copyright Notice in lua.h +*/ + + +#include + +#define lzio_c + +#include "lua.h" + +#include "llimits.h" +#include "lmem.h" +#include "lzio.h" + + +int luaZ_fill (ZIO *z) { + size_t size; + const char *buff = z->reader(NULL, z->data, &size); + if (buff == NULL || size == 0) return EOZ; + z->n = size - 1; + z->p = buff; + return char2int(*(z->p++)); +} + + +int luaZ_lookahead (ZIO *z) { + if (z->n == 0) { + int c = luaZ_fill(z); + if (c == EOZ) return c; + z->n++; + z->p--; + } + return char2int(*z->p); +} + + +void luaZ_init (ZIO *z, lua_Chunkreader reader, void *data, const char *name) { + z->reader = reader; + z->data = data; + z->name = name; + z->n = 0; + z->p = NULL; +} + + +/* --------------------------------------------------------------- read --- */ +size_t luaZ_read (ZIO *z, void *b, size_t n) { + while (n) { + size_t m; + if (z->n == 0) { + if (luaZ_fill(z) == EOZ) + return n; /* return number of missing bytes */ + else { + ++z->n; /* filbuf removed first byte; put back it */ + --z->p; + } + } + m = (n <= z->n) ? n : z->n; /* min. between n and z->n */ + memcpy(b, z->p, m); + z->n -= m; + z->p += m; + b = (char *)b + m; + n -= m; + } + return 0; +} + +/* ------------------------------------------------------------------------ */ +char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n) { + if (n > buff->buffsize) { + if (n < LUA_MINBUFFER) n = LUA_MINBUFFER; + luaM_reallocvector(L, buff->buffer, buff->buffsize, n, char); + buff->buffsize = n; + } + return buff->buffer; +} + + diff --git a/stepmania/src/lua-5.0/src/lzio.h b/stepmania/src/lua-5.0/src/lzio.h new file mode 100644 index 0000000000..17ed5efd57 --- /dev/null +++ b/stepmania/src/lua-5.0/src/lzio.h @@ -0,0 +1,64 @@ +/* +** $Id$ +** Buffered streams +** See Copyright Notice in lua.h +*/ + + +#ifndef lzio_h +#define lzio_h + +#include "lua.h" + + +#define EOZ (-1) /* end of stream */ + +typedef struct Zio ZIO; + + +#define char2int(c) cast(int, cast(unsigned char, (c))) + +#define zgetc(z) (((z)->n--)>0 ? char2int(*(z)->p++) : luaZ_fill(z)) + +#define zname(z) ((z)->name) + +void luaZ_init (ZIO *z, lua_Chunkreader reader, void *data, const char *name); +size_t luaZ_read (ZIO* z, void* b, size_t n); /* read next n bytes */ +int luaZ_lookahead (ZIO *z); + + + +typedef struct Mbuffer { + char *buffer; + size_t buffsize; +} Mbuffer; + + +char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n); + +#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0) + +#define luaZ_sizebuffer(buff) ((buff)->buffsize) +#define luaZ_buffer(buff) ((buff)->buffer) + +#define luaZ_resizebuffer(L, buff, size) \ + (luaM_reallocvector(L, (buff)->buffer, (buff)->buffsize, size, char), \ + (buff)->buffsize = size) + +#define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0) + + +/* --------- Private Part ------------------ */ + +struct Zio { + size_t n; /* bytes still unread */ + const char *p; /* current position in buffer */ + lua_Chunkreader reader; + void* data; /* additional data */ + const char *name; +}; + + +int luaZ_fill (ZIO *z); + +#endif