来源于： http://www.tecgraf.puc-rio.br/~rcerq/luacom/pub/1.3/luacom-htmldoc/ lua5.1 带的在 C:\Lua\5.1\docs\luacom 但，是PDF格式的

从 http://code.google.com/p/msysgit/ 下载 git gui 使用 git gui 从 http://luaplus.org/ 上说明的 http://git.luaplus.org/luaplus51-all.git 处下载 1100 里面的 lua 为 5.1.4 本下载为 luaplus51 的第2部分

从 http://code.google.com/p/msysgit/ 下载 git gui 使用 git gui 从 http://luaplus.org/ 上说明的 http://git.luaplus.org/luaplus51-all.git 处下载 1100 里面的 lua 为 5.1.4 本下载为 luaplus51 的第1部分

http://www.cnpopsoft.com/article.asp?id=13 http://www.codeproject.com/KB/edit/autoricheditctrl.aspx

来源： http://unxutils.sourceforge.net/ Here are some ports of common GNU utilities to native Win32. In this context, native means the executables do only depend on the Microsoft C-runtime (msvcrt.dll) and not an emulation layer like that provided by Cygwin tools.

摘自 http://wiki.github.com/bmatzelle/gow/ Gow – The lightweight alternative to Cygwin 下面是 zip.exe 信息： Copyright (c) 1990-2008 Info-ZIP - Type 'zip "-L"' for software license. Zip 3.0 (July 5th 2008). Usage: zip [-options] [-b path] [-t mmddyyyy] [-n suffixes] [zipfile list] [-xi list] The default action is to add or replace zipfile entries from list, which can include the special name - to compress standard input. If zipfile and list are omitted, zip compresses stdin to stdout. -f freshen: only changed files -u update: only changed or new files -d delete entries in zipfile -m move into zipfile (delete OS files) -r recurse into directories -j junk (don't record) directory names -0 store only -l convert LF to CR LF (-ll CR LF to LF) -1 compress faster -9 compress better -q quiet operation -v verbose operation/print version info -c add one-line comments -z add zipfile comment -@ read names from stdin -o make zipfile as old as latest entry -x exclude the following names -i include only the following names -F fix zipfile (-FF try harder) -D do not add directory entries -A adjust self-extracting exe -J junk zipfile prefix (unzipsfx) -T test zipfile integrity -X eXclude eXtra file attributes -! use privileges (if granted) to obtain all aspects of WinNT security -$ include volume label -S include system and hidden files -e encrypt -n don't compress these suffixes -h2 show more help

MinGW-5.1.6.part2.rar 这是压缩包的第二部分 (2/2)

MinGW-5.1.6.part1.rar 这是压缩包的第一部分 (1/2)

来源 : http://linux.solidot.org/article.pl?sid=10/08/08/1417245 riku 写道 "如果你是 Linux 及 Windows 的双料用户，而且是深度 CLI 控的话，可能会像我一样在用 Win 的时候会不知不觉间输入一些 Linux 的命令， 当然这肯定无法执行的。现在，有一个名为 Gow 的工具包就可以发挥作用了。 Gow 是一个相当于 Cygwin 的轻量级替代品，里面封装了130 多个的开源工具及 Linux 命令，其中包括： Shell ： bash , zsh 压缩工具： gzip, zip, bzip2, compress SSH： putty, psftp, pscp, pageant, plink 下载工具 ： cURL, wget FTP: NcFTP 编辑器 ：vim 字处理 ： grep, agrep, less, cat, tail, head 文件工具： mv, cp, du, ls, pwd, rmdir, whereis 开发工具： make, diff, diff3, sleep, cvs, dos2unix, unix2dos 用户下载一个 Win 安装程序并安装后，它会自动设置好相应的环境变量，这样无论在哪个目录下都能使用这些命令了。详细介绍见这里"

Decoda is a professional development environment for debugging Lua script in your applications. It's familiar and fast and you'll wonder how you ever worked without it. 来源: http://www.unknownworlds.com/decoda/

C:\Program Files\IconCool Software\IconCool Editor\Sample

该压缩包为 http://www.tecgraf.puc-rio.br/~lhf/ftp/lua/ 的离线境像

来源： http://www.luaedit.org/ LuaEdit is an IDE/Text Editor/Debugger for the Lua language. Its interface looks like MS Studio .Net® and includes syntax highlighting, code completion, advance breakpoint management, efficient search engines, etc. Free for commercial and personal uses.

来源： http://www.cppblog.com/tuuzed/archive/2008/12/27/70516.html 最近在研究Lua脚本语言（个人觉得它是Basic、C、C++的结合体），可是“强大”的UltraEdit默认安装后是不支持Lua语法高亮显示的，满屏幕“黑黑”的鸡肠字符让人感觉编程是那么的索然无味，没有了灵感。 终于有一天GOOGLE了一下，发现了很多解决办法，最好的办法就是：先去UltraEdit的官网下载支持Lua的Wordfiles文件(这里),是个文本文件（lua.txt）。打开UltraEdit安装目录下的wordfile.txt，把lua.txt文件中的内容拷贝粘贴到wordfile.txt的末尾，存盘，OK，于是UltraEdit语法高亮项多出Lua一项，可以选择使用了。比起网上说的02年版的lua.txt，这个04版（也是很旧）已经完美支持“注释块”和“注释行”高亮了，所以无需在改它的第一行。 但是，使用一段时间后，还是发现有问题，比如：有部分关键字没有加亮（如：os，pair, ipair等）；不支持代码折叠（不能很好地知道结束关键字end是属于哪个while、for、function等）；对UltraEdit的F8（函数列表）功能支持得不完美。还好，看了UltraEdit帮助后，自己修改了一下，解决了上述问题，下面就贴出我的lua.txt（在这里下载修改后的Lua.txt）。

请参阅 MSDN 原文： http://support.microsoft.com/kb/237870/zh-cn 此为 lua 版，但只更新了 FILEVERSION PRODUCTVERSION 两个字段，还需要后续改进. 使用方法： 在 VC 6 中的工程设置中，设置 Post-build step 中写入以下命令： C:\Lua\5.1\lua.exe -i update_version.lua resource.rc

FontFrenzy tames the frenzy of fonts that can clutter and slow down Windows. The DeFrenzy function removes and stores all fonts except those that were present when Windows was first installed. In short, it cleans up your font folder so that Windows boots quicker and runs smoother. 来源： http://www.sdsoftware.org/default.asp?id=5936

from codeguru 共两个工程 VersionInfo GetVersionInfo

来源: http://www.naughter.com/shelexec.html Welcome to ShelExec, A very simple utility to allow you to call the ShellExecute API from the command line. Places where you might find ShelExec useful are in adding an autorun.inf file to your CD / DVD +/- RW discs. For example suppose you have a HTML page called index.htm on the root of your CD which you would like to run automatically whenever the user inserts the CD. All you need to do is put ShelExec.exe, some ico file (this is optional as is the icon=... in the autorun.inf file) and the index.htm files into the root directory and create a autorun.inf file with the following contents: [autorun] open=ShelExec.exe @EXEDRV@\index.html icon=youricon.ico Note that it is important to use the @EXEDRV@ or @EXEDIR@ replacement parameters as this helps ensures that ShelExec uses a fully quoted path when it runs your program. Otherwise you can get some problems on various versions of Windows with your AutoRun CD's. Items that ShelExec can handle include any file which is registered with the shell e.g. Word .Doc files, Text Files, batch files etc etc. It can also handle URLS such as "http://www.naughter.com", "ftp://ftp.microsoft.com " and "mailto:pjna@naughter.com". The more technically minded of you may say why is there a need to have this program since you can use "start filename" on autorun CD's without any apparent problems. The problem with this approach is that it does not work on NT / 2000 / XP and 2003 because on these operating systems "start" is implemented as an "Internal" command in cmd.exe (as opposed to a standard exe on 95/98) with the upshot that your CD's will not AutoRun on these operating systems. Using ShelExec will mean that your CD's will autorun on all OS's which support it. The enclosed zip file contains the ShelExec source code and a prebuilt version of ShelExec. Copyright You are allowed to include the source code in any product (commercial, shareware, freeware or otherwise) when your product is released in binary form. You are allowed to modify the source code in any way you want except you cannot modify the copyright details at the top of each module. If you want to distribute source code with your application, then you are only allowed to distribute versions released by the author. This is to maintain a single distribution point for the source code. The executable file itself, namely "ShelExec.exe" can be freely redistributed by anyone.

What is LUA? LUA is a scripting language, its power lies in the fact that it can be embedded in your C++ programs. Scripts give you the possibility to change the behaviour of your C++ programs without any need to recompile your program. A real world example would be game programming: you only have to change the script(s) and you can create a whole new game using the same engine. LUA is fully customizable, you can create your own script functions and expose them to a 3th party. Or you can create scripts, encrypt them and then decrypt them at run-time so that only a number of limited people can script for your program. Allowing the end-user to modify your program, gives your program a point ahead to the competition. Using LUA in your program does require some thinking ahead... You have to choose what kind of functions you allow in the scripts. For example: a function savegame would be logic and usefull and so could be a function deletesavegame but making a function such as deletefile public can be dangerous. The LUA version discussed is 5.0.2. Don't forget that this document is only a quick introduction and that it is not a complete tutorial about LUA. How to embed LAU into C++? Another way to formulate this question : "How can I use LUA in my Visual C++ Project?". The answer is actually pretty easy, you download it from lua.org and you follow the instructions below. Know that there are several ways to add LUA to your project and I only explain one of them. NOTE: I'm assuming that you know the basics about how to use your compiler, the instructions outlined below are ment for Microsoft Visual C++ 6. Installation : dowload LUA here (links to official website) Extract the files to a folder, for example "c:\Program Files\LUA SDK" Configuration : In your Microsoft Visual C++ IDE Go to Tools->Options. Select Directories and add the LUA include-directory. Add LUA to your project (non-MFC) : Create a new folder in your project's workspace and call it LUA. Add the files. Select and insert all the files in the LUA src-directory (from lapi.c to lzio.h). Add LUA to your project (MFC) : Create a new folder in your project's workspace and call it LUA. Add the files. Select and insert all the files in the LUA src-directory (from lapi.c to lzio.h). MFC uses precompiled headers, LUA doesn't, so let's disable them. Select the LUA folder in your workspace and press the right mouse button, then select Settings from the menu. Select "All Configurations". Then open the LUA folder and select all the .c-files (make sure your selection doesn't include a folder or a .h file!). On the right side a C++-tab will appear. In that C++-tab select the "Precompiled Headers"-catagory. And select "Not using precompiled headers". Press the OK-button to finish. About ANSI C and C++ LUA is pure ANSI C code, this means that if you build the code with a C++ compiler it will complain with "error LNK2001: unresolved external symbol" messages. Two easy ways exist to resolve this problem without modifying the original source files : Tell the compiler that the function definitions are C style by enclosing the include directive with the extern keyword : extern "C" { #include <lua.h> } You can also define LUA_API before including lua.h : #define LUA_API extern "C" #include <lua.h> I recommend that you use the first method. The LUA State In order to use LUA you have to initialize it and when you're done with it you have to deinitialize LUA. This is done by respectivily opening and closing an LUA state. // Open the LUA state lua_State *L = lua_open(); // Use LUA... ; // Close the LUA state lua_close(L); You can have multiple LUA states in your program which are all indepedent of each other. The LUA Stack LUA is stack-based. The communication between the script and the C/C++ application happens between a stack maintained by LUA. Note that each LUA state has its own stack. A clean programmer will ensure that the stack is zero at the end of his program. You can verify this by calling the lua_gettop function, the result must be zero, it's a good candidate for the _ASSERT macro (defined in crtdbg.h). // Open the LUA state lua_State *L = lua_open(); // Use LUA... ; // Verify the stack // (don't forget to include crtdbg.h) _ASSERT(lua_gettop(L) == 0); // Close the LUA state lua_close(L); LUA defines lua_pushXXX (where XXX can be "string", "number", "boolean", ...) but it doesn't define the lua_popXXX versions. Here's an example how to define them by yourself : inline LUA_API lua_Number lua_popnumber(lua_State *L) { register lua_Number tmp = lua_tonumber(L, lua_gettop(L)); lua_pop(L, 1); return tmp; } inline LUA_API const char *lua_popstring(lua_State *L) { register const char *tmp = lua_tostring(L, lua_gettop(L)); lua_pop(L, 1); return tmp; } When popping the values they are converted automaticly when possible : // Push -1 as a number lua_pushnumber(L, -1); // And pop it again as a string (s --> "-1") const char *s = lua_popstring(L); If the conversion is impossible then NULL/0 will be returned. For example we can't convert a boolean to a string : // Push 1 (true) lua_pushboolean(L, 1); // And pop it again as a string (s --> NULL) const char *s = lua_popstring(L); There are many other stack manipulation functions and there are also functions to verify the value type on the stack. I suggest that you check out the LUA manual that comes with the distribution. Executing an LUA script Executing an LUA script isn't that straight-forward at first but at the end it turns out the be very simple. I'm explaining you the full implementation of how to execute a script by creating your own "reader". LUA comes with its own library that contains ready-to-use functions but I prefer you to explain the complete version so you can understand better how LUA works. In order to execute LUA scripts you have to load them first and call them afterwarts, this is done by respectivily calling the lua_load and the lua_call or lua_pcall function. The lua_load function takes four parameters : LUA_API int lua_load (lua_State *L, lua_Chunkreader reader, void *data, const char *chunkname); The first one is the pointer to the LUA state, the second one is a pointer to a user-defined reader function, the third pointer is a user-defined value that the reader function will receive, and the fourth one is a name we decide ourselves for debugging purposes. As you can see from this call, there is no argument accepting a script. We have to define this ourselves using the data argument. Let's take a look at this structure (taken from the LUA library), we will define : typedef struct luaMemFile { const char *text; size_t size; } luaMemFile; The text variable will be our script line(s) and the size variable will tell us if we have finished reading or not (see later). A value of zero will mean : we are no longer reading. We now define a simple callback function : const char *readMemFile(lua_State *, void *ud, size_t *size) { // Convert the ud pointer (UserData) to a pointer of our structure luaMemFile *luaMF = (luaMemFile *) ud; // Are we done? if(luaMF->size == 0) return NULL; // Read everything at once // And set size to zero to tell the next call we're done *size = luaMF->size; luaMF->size = 0; // Return a pointer to the readed text return luaMF->text; } Once the script has been loaded, a simple call to lua_pcall will suffice. I prefer lua_pcall above lua_call because the later one will terminate the program if there was an error. The lua_call takes three parameters and the lua_pcall function takes four parameters : LUA_API void lua_call (lua_State *L, int nargs, int nresults); LUA_API int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc); The first parameter is the pointer to the LUA state, the second parameter is the number of arguments on the stack that the command takes (and when executing a loaded script this can remain 0). The third parameter is the number of result parameters the command will return on the stack. If nresult equals LUA_MULTRET then the number of parameters that will be pushed on the stack is controlled by the called function! Yes indeed, an LUA function can return more than one parameter, for example : return "i", "return", 5, "strings", "and", 2, "numbers" The fourth parameter (errfunc) is only valid for the lua_pcall function and is used for controlling the error-handling. Please read the LUA manual for more information about this parameter. A note about the nresults argument: if we take the example return statement above, then we see that 7 values would be returned. If we execute this script with nresult==LUA_MULTRET then 7 values would be returned, if we would call the function with nresult==3 then only the 3 first values would be returned ("i", "return" and 5). This is the test script we will execute : const char *testscript = { "function double(n)\n" " return n * 2\n" "end\n" "\n" "return double(1)\n" }; function double(n) return n * 2 end return double(1) A quick but nasty way of executing would be this : // luaMemFile luaMF; // Load the command and try to execute it... luaMF.text = testscript; luaMF.size = strlen(luaMF.text); lua_load(L, readMemFile, &luaMF, "test script"); lua_pcall(L, 0, 0, 0); You may ask why is this a bad method? Well, there is no error checking, if the script contains error or an execution error occur than the stack will be messed-up, LUA functions push their error values on the stack so you need to check the result of both lua_load and lua_pcall and act accordingly! This is the implementation that I prefer : // luaMemFile luaMF; // Load the command and try to execute it... luaMF.text = testscript; luaMF.size = strlen(luaMF.text); if(lua_load(L, readMemFile, &luaMF, "test script") == 0) { // Execute the loaded command... // The function takes 0 parameters and will return 1 result if(lua_pcall(L, 0, 1, 0) == 0) { // There was no error // Let's get the result from the stack lua_Number result = lua_tonumber(L, lua_gettop(L)); } // Clean-up the stack lua_pop(L, 1); } else { // There was a lua_load error... // Pop the error value from the stack lua_pop(L, 1); } Calling C functions from LUA In order to make this topic more accessible, a whole new page has been assigned to it, please follow this link : Calling C functions from LUA or How to expose C function to LUA scripts. 来源： http://www.codegurus.be/codegurus/Programming/luaintroduction_en.htm

This article is an update to my previous articles on the same topic. I started this utility to get some basic information about the hardware. After that I have received some emails from some of our fellow programmers, who are frequent visitors of this site, asking to extend this utility to spit out some more information. In this update I have added the information about CPU vendor (Intel, Cyrix, AMD, etc.) ,CPU speed, and Physical memory status of sustem . CPU Information: To get CPU information I could not find any direct and simple API call. Then I thought of our friendly Registry, which contains all the system information. And there it was all the information I wanted. If you look under HKEY_LOCAL_MACHINE/Hardware/Description/System/CentralProcessor/0 key in registry, you will find the answers to your questions. ~MHz subkey gives the CPU speed and VendorIdentifier gives the vendor information. We will make use of RegQueryValueEx API call to get the information. LONG RegQueryValueEx( HKEY hKey, // handle to key to query LPTSTR lpValueName, // address of name of value to query LPDWORD lpReserved, // reserved LPDWORD lpType, // address of buffer for value type LPBYTE lpData, // address of data buffer LPDWORD lpcbData // address of data buffer size ); Before making this call, it is necessary to create the handle to registry key which needs to be queried. For this make use of RegCreateKeyEx API call. This is how the code looks like in the included code for this utility. // Get the processor speed info. result = ::RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Hardware\\Description\\System\\CentralProcessor\\0", 0, KEY_QUERY_VALUE, &hKey); // Check if the function has succeeded. if (result == ERROR_SUCCESS) { result = ::RegQueryValueEx (hKey, _T("~MHz"), NULL, NULL, (LPBYTE)&data, &dataSize); m_stCPUSpeed.Format ("%d", data); m_stCPUSpeed += _T (" MHz"); dataSize = sizeof (vendorData); result = ::RegQueryValueEx (hKey, _T("VendorIdentifier"), NULL, NULL, (LPBYTE)vendorData, &dataSize); m_stVendorInfo.Format ("%s", vendorData); } // Make sure to close the reg key RegCloseKey (hKey); Since I don't have access to any other CPU than Intel. So I couldn't test this code on CPU's from Cyrix, AMD, etc. Post a comment Email Article Print Article Share Articles Digg del.icio.us Newsvine Facebook Google LinkedIn MySpace Reddit Slashdot StumbleUpon Technorati Twitter Windows Live YahooBuzz FriendFeed Physical Memory Status: To get the information about the memory status of the system we can take routes. First one, which is not easy for a person who does not know assembly language, involves getting the required information from CMOS data. Second one which simply involves making GlobalMemoryStatus API call. And I chose the second one (Ofcourse I am not assembly language pro). VOID GlobalMemoryStatus ( LPMEMORYSTATUS lpBuffer // pointer to the memory status structure ); The information is returned in MEMORYSTATUS data structure. typedef struct _MEMORYSTATUS { // mst DWORD dwLength; // sizeof(MEMORYSTATUS) DWORD dwMemoryLoad; // percent of memory in use DWORD dwTotalPhys; // bytes of physical memory DWORD dwAvailPhys; // free physical memory bytes DWORD dwTotalPageFile; // bytes of paging file DWORD dwAvailPageFile; // free bytes of paging file DWORD dwTotalVirtual; // user bytes of address space DWORD dwAvailVirtual; // free user bytes } MEMORYSTATUS, *LPMEMORYSTATUS; The information returned by the GlobalMemoryStatus function is volatile. There is no guarantee that two sequential calls to this function will return the same information. This API call has been made in GetMemoryInfo function of the application attached. I gets the information for memory usage, total physical memory instaled, physical memory available, and total virtual memory. 来源： http://www.codeguru.com/cpp/w-p/system/hardwareinformation/article.php/c2833/

从 https://nodeload.github.com/jasonsantos/luajava/zipball/master 下载的 luajava 中是没有 luajava.h 文件的 该文件需要由 JDK 的 javah 生成 在此希望能帮到一些生成luajava.h因难的人 :)

来源： 【弱电通】 http://www.ruodiantong.com/index.php?action-modelview-name-Down-itemid-28700#

http://www.microsoft.com/download/en/confirmation.aspx?id=1251 Windows CNG SDK Version 1.3 The CNG SDK contains documentation, code, and tools designed to help you develop cryptographic applications and libraries targeting the Windows Vista SP1 and Windows Server 2008 Operating Systems.

-1. 部分文件列表 EXE or DLL size ------------------------ lsqlite3.dll 61,236 sqlite3.dll 447,579 sqlite3.exe 46,080 0. lua http://www.lua.org 下载 LuaForWindows v5.1.4 1. sqlite http://www.sqlite.org/download.html 从下面网址下载 sqlite-3070701 源码 http://www.sqlite.org/sqlite-amalgamation-3070701.zip 使用 mingw 编译出 sqlite3.dll 和 sqlite3.exe 2. lsqlite3 (也是本压缩包的原型) http://lua.sqlite.org 从下面网址下载 Version 0.8 http://lua.sqlite.org/index.cgi/zip/lsqlite3_svn08.zip?uuid=svn_8 使用 mingw 编译出 lsqlite3.dll 其他： 0. lsqlite3 链接 lua 使用了LuaForWindows v5.1.4 的 lua5.1.lib 库，故运行时需要 lua5.1.dll 1. lsqlite3 链接 sqlite 使用的 sqlite3.lib 来源于 M$ 的 lib.exe 应用，参阅 http://hi.baidu.com/opaquefog/blog/item/9b21b6deb324e25dccbf1ab7.html

来源： http://lavixu.livejournal.com/14738.html 压缩包中除上述网址的dll2lib.py外还含有 VC 6 的如下几个文件： DUMPBIN.EXE LIB.EXE LINK.EXE MSPDB60.DLL 该python脚本对一个 A.dll 文件会生成如下三个文件: A.lib A.def A.exp 因为是 python 写的，所以需要下载 python （目前为 2.7 ，不要使用 3.X 版的，因为 3.X 版认为 print "string" 是语法错误的） ------------------- 传说中的分隔线 ------------------- 你可能对下面的内容也感兴趣： 标题： How can an MSVC program call an MinGW DLL, and vice versa? 网址： http://wyw.dcweb.cn/dllfaq.htm ------------------- 下面是传说中价格为$999的 DLL to Lib (d2l) 它能把 dll 转为静态库 :) DLL to Lib 3.0 (Free to try; $999.00 to buy) http://download.cnet.com/DLL-to-Lib/3000-18487_4-10064902.html

sqlite(中文).chm sqlite-3_7_3-docs.chm SQLITE3 使用总结.doc SQLite数据库的DB-API.pdf SQLite权威指南.pdf SQLite权威指南_v100.doc 嵌入式数据库SQLITE3使用指南.pdf 来源： http://www.sqlite.com.cn/bbs/topicdisp.asp?tid=558 http://www.sqlite.com.cn/bbs/topicdisp.asp?tid=1617 等...

DVB和MPEG-II中的表格 DVB中的业务信息（SI） Sipsi

DVB和MPEG-II中的表格.html DVB中的业务信息（SI）.htm Sipsi.doc 数字电视EPG信息解析系统的设计与实现

DVB和MPEG-II中的表格.html DVB中的业务信息（SI）.htm Sipsi.doc

iso13818规范.pdf PSI-SI理解入门.doc 来源：　百度文库

Docada+破解版 游戏程序王上传 lua

来源： http://www.cppdoc.com 共三个文件： CppDoc2.zip CppDocCommentMaker.zip CppDoc Help.mht

来源:http://www.onlinedown.net/soft/21532.htm Windows XP Service Pack 2 Support Tools 概述 适用于 Microsoft Windows XP 的 Windows 支持工具之目的是提供 Microsoft 支持人员与有经验的使用者使用，以协助诊断与解决计算机问题。如需个别工具的描述，请参阅 Windows 支持工具文件 (Suptools.chm)。 适用于 Windows XP 的 Windows 支持工具只能安装在执行 Windows XP 操作系统的计算机上。适用于 Windows XP 的 Windows 支持工具无法用来升级安装在 Windows NT 或 Windows 2000 上的 Microsoft Windows NT 或 Microsoft Windows 2000 支持工具。 执行支持工具安装程序前，强烈建议您移除所有旧版支持工具 (包括适用于 Microsoft Windows XP 的 Windows 支持工具的 Beta 版本)。 重要： 这些工具尚未有中文版，而仅在英文环境撰写与测试。在英文版以外的 Microsoft Windows XP 可能无法使用这些工具

http://guacamole.googlecode.com/svn-history/r454/trunk/lua/bindings/win32/init.lua

来源: http://luaforge.net/projects/icu-lua/ 从 http://luaforge.net/projects/icu-lua/ 下载的 icu.dll 需要一系列的 dll 这些 dll 来源于： http://code.google.com/p/icu4net 该下载来源此.

Gawk for Windows -------------------------------------------------------------------------------- Gawk: pattern scanning and processing language Version 3.1.6 Description Several kinds of tasks occur repeatedly when working with text files. You might want to extract certain lines and discard the rest. Or you may need to make changes wherever certain patterns appear, but leave the rest of the file alone. Writing single-use programs for these tasks in languages such as C, C++ or Pascal is time-consuming and inconvenient. Such jobs are often easier with awk. The awk utility interprets a special-purpose programming language that makes it easy to handle simple data-reformatting jobs. The GNU implementation of awk is called gawk; it is fully compatible with the System V Release 4 version of awk. gawk is also compatible with the POSIX specification of the awk language. This means that all properly written awk programs should work with gawk. Thus, we usually don’t distinguish between gawk and other awk implementations. Using awk allows you to: Manage small, personal databases Generate reports Validate data Produce indexes and perform other document preparation tasks Experiment with algorithms that you can adapt later to other computer languages. In addition, gawk provides facilities that make it easy to: Extract bits and pieces of data for processing Sort data Perform simple network communications. The Win32 port has some limitations, In particular the ‘|&’ operator and TCP/IP networking are not supported 来源: http://gnuwin32.sourceforge.net/packages/gawk.htm

Gawk: pattern scanning and processing language Version 3.1.6 Description Several kinds of tasks occur repeatedly when working with text files. You might want to extract certain lines and discard the rest. Or you may need to make changes wherever certain patterns appear, but leave the rest of the file alone. Writing single-use programs for these tasks in languages such as C, C++ or Pascal is time-consuming and inconvenient. Such jobs are often easier with awk. The awk utility interprets a special-purpose programming language that makes it easy to handle simple data-reformatting jobs. The GNU implementation of awk is called gawk; it is fully compatible with the System V Release 4 version of awk. gawk is also compatible with the POSIX specification of the awk language. This means that all properly written awk programs should work with gawk. Thus, we usually don’t distinguish between gawk and other awk implementations. Using awk allows you to: Manage small, personal databases Generate reports Validate data Produce indexes and perform other document preparation tasks Experiment with algorithms that you can adapt later to other computer languages. In addition, gawk provides facilities that make it easy to: Extract bits and pieces of data for processing Sort data Perform simple network communications. The Win32 port has some limitations, In particular the ‘|&’ operator and TCP/IP networking are not supported.

Gawk: pattern scanning and processing language Version 3.1.6 Description Several kinds of tasks occur repeatedly when working with text files. You might want to extract certain lines and discard the rest. Or you may need to make changes wherever certain patterns appear, but leave the rest of the file alone. Writing single-use programs for these tasks in languages such as C, C++ or Pascal is time-consuming and inconvenient. Such jobs are often easier with awk. The awk utility interprets a special-purpose programming language that makes it easy to handle simple data-reformatting jobs. The GNU implementation of awk is called gawk; it is fully compatible with the System V Release 4 version of awk. gawk is also compatible with the POSIX specification of the awk language. This means that all properly written awk programs should work with gawk. Thus, we usually don’t distinguish between gawk and other awk implementations. Using awk allows you to: Manage small, personal databases Generate reports Validate data Produce indexes and perform other document preparation tasks Experiment with algorithms that you can adapt later to other computer languages. In addition, gawk provides facilities that make it easy to: Extract bits and pieces of data for processing Sort data Perform simple network communications. The Win32 port has some limitations, In particular the ‘|&’ operator and TCP/IP networking are not supported.

来源：http://nayruden.com/?p=115

来源： http://lua-users.org/wiki/LuaUnicode 目录： | LuaUnicode.url | +---0.13A | ICU4Lua-0.13A-src.zip | ICU4Lua-0.13A-win32-dll.zip | \---0.2B ICU4Lua-0.2B-docs.zip ICU4Lua-0.2B-src.zip ICU4Lua-0.2B-win32dll.zip 下面的来源于： http://lua-users.org/wiki/LuaUnicode This is an attempt to answer the LuaFaq : Can I use unicode strings? or Does Lua support unicode? In short, yes and no. Lua gives you the bare bones support and enough rope and not much else. Unicode is a large and complex standard and questions like "does lua support unicode" are extremely vague. Some of the issues are: Can I store and retrieve Unicode strings? Can my Lua programs be written in Unicode? Can I compare Unicode strings for equality? Sorting strings. Pattern matching. Can I determine the length of a Unicode string? Support for bracket matching, bidirectional printing, arbitrary composition of characters, and other issues that arise in high quality typesetting. Lua strings are fully 8-bit clean, so simple uses are supported (like storing and retrieving), but there's no built in support for more sophisticated uses. For a fuller story, see below. Unicode strings and Lua strings A Lua string is an aribitrary sequence of values which have at least 8 bits (octets); they map directly into the char type of the C compiler. (This may be wider than eight bits, but eight bits are guaranteed.) Lua does not reserve any value, including NUL. That means that you can store a UTF-8 string in Lua without problems. Note that UTF-8 is just one option for storing Unicode strings. There are many other encoding schemes, including UTF-16 and UTF-32 and their various big-endian/little-endian variants. However, all of these are simply sequences of octets and can be stored in a Lua string without problems. Input and output of strings in Lua (using the io library) uses C's stdio library. ANSI C does not require the stdio library to handle arbitrary octet sequences unless the file is opened in binary mode; furthermore, in non-binary mode, some octet sequences are converted into other ones (in order to deal with varying end-of-line markers on different platforms). This may affect your ability to do non-binary file input and output of Unicode strings in formats other than UTF-8. UTF-8 strings will probably be safe because UTF-8 does not use control characters such as \n and \r as part of multi-octet encodings. However, there are no guarantees; if you need to be certain, you must use binary mode input and output. (If you do so, line-endings will not be converted.) Unix file IO has been 8-bit clean for a long while. If you are not concerned with portability and are only using Unix and Unix-like operating systems, you can almost certainly not worry about the above. If your use of Unicode is restricted to passing the strings to external libraries which support Unicode, you should be OK. For example, you should be able to extract a Unicode string from a database and pass it to a Unicode-aware graphics library. But see the sections below on pattern matching and string equality. Unicode Lua programs Literal Unicode strings can appear in your lua programs. Either a UTF-8 encoded string can appear directly with 8-bit characters or you can use the \ddd syntax (note that ddd is a decimal number, unlike some other languages). However, there is no facility for encoding multi-octet sequences (such as \U+20B4); you would need to either manually encode them to UTF-8, or insert individual octets in the correct big-endian/little-endian order (for UTF-16 or UTF-32). Unless you are using an operating system in which a char is more than eight bits wide, you will not be able to use arbitrary Unicode characters in Lua identifers (for the names of variables and so on). You may be able to use eight-bit characters outside of the ANSI range. Lua uses the C functions isalpha and isalnum to identify valid characters in identifiers, so it will depend on the current locale. To be honest, using characters outside of the ANSI range in Lua identifiers is not a good idea, since your programs will not compile in the standard C locale. Comparison and Sorting Lua string comparison (using the == operator) is done byte-by-byte. That means that == can only be used to compare Unicode strings for equality if the strings have been normalized in one of the four Unicode normalizations. (See the [Unicode FAQ on normalization] for details.) The standard Lua library does not provide any facility for normalizing Unicode strings. Consequently, non-normalized Unicode strings cannot be reliably used as table keys. If you want to use the Unicode notion of string equality, or use Unicode strings as table keys, and you cannot guarantee that your strings are normalized, then you'll have to write or find a normalization function and use that; this is non-trivial exercise! The Lua comparison operators on strings (< and <=) use the C function strcoll which is locale dependent. This means that two strings can compare in different ways according to what the current locale is. For example, strings will compare differently when using Spanish Traditional sorting to that when using Welsh sorting. It may be that your operating system has a locale that implements the sorting algorithm that you want, in which case you can just use that, otherwise you will have to write a function to sort Unicode strings. This is an even more non-trivial exercise. UTF-8 was designed so that a naive octet-by-octet string comparison of an octet sequence would produce the same result if a naive octet-by-octet string comparison were done on the UTF-8 encoding of the octet sequence. This is also true of UTF-32BE but I do not know of any system which uses that encoding. Unfortunately, naive octet-by-octet comparison is not the collation order used by any language. (Note: sometimes people use the terms UCS-2 and UCS-4 for "two-byte" and four-byte encodings. These are not Unicode standards; they come from the closely corresponding ISO standard ISO/IEC 10646-1:2000 and currently differ in that they allow codes outside of the Unicode range, which runs from 0x0 to 0x10FFFF.) Pattern Matching Lua's pattern matching facilities work character by character. In general, this will not work for Unicode pattern matching, although some things will work as you want. For example, "%u" will not match all Unicode upper case letters. You can match individual Unicode characters in a normalized Unicode string, but you might want to worry about combining character sequences. If there are no following combining characters, "a" will match only the letter a in a UTF-8 string. In UTF-16LE you could match "a%z". (Remember that you cannot use \0 in a Lua pattern.) Length and string indexing If you want to know the length of a Unicode string there are different answers you might want according to the circumstances. If you just want to know how many bytes the string occupies, so that you can make space for copying it into a buffer for example, then the existing Lua function string.len will work. You might want to know how many Unicode characters are in a string. Depending on the encoding used, a single Unicode character may occupy up to four bytes. Only UTF-32LE and UTF-32BE are constant length encodings (four bytes per character); UTF-32 is mostly a constant length encoding but the first element in a UTF-32 sequence should be a "Byte Order Mark", which does not count as a character. (UTF-32 and variants are part of Unicode with the latest version, Unicode 4.0.) Some implementations of UTF-16 assume that all characters are two bytes long, but this has not been true since Unicode version 3.0. Happily UTF-8 is designed so that it is relatively easy to count the number of unicode symbols in a string: simply count the number of octets that are in the ranges 0x00 to 0x7f (inclusive) or 0xC2 to 0xF4 (inclusive). (In decimal, 0-127 and 194-244.) These are the codes which can start a UTF-8 character code. Octets 0xC0, 0xC1 and 0xF5 to 0xFF (192, 193 and 245-255) cannot appear in a conforming UTF-8 sequence; octets in the range 0x80 to 0xBF (128-191) can only appear in the second and subsequent octets of a multi-octet encoding. Remember that you cannot use \0 in a Lua pattern. For example, you could use the following code snippet to count UTF-8 characters in a string you knew to be conforming (it will incorrectly count some invalid characters): local _, count = string.gsub(unicode_string, "[^\128-\193]", "") If you want to know how many printing columns a Unicode string will occupy when you print it out using a fixed-width font (imagine you are writing something like the Unix ls program that formats its output into several columns), then that is a different answer again. That's because some Unicode characters do not have a printing width, while others are double-width characters. Combining characters are used to add accents to other letters, and generally they do not take up any extra space when printed. So that's at least 3 different notions of length that you might want at different times. Lua provides one of them (string.len) the others you'll need to write functions for. There's a similar issue with indexing the characters of a string by position. string.sub(s, -3) will return the last 3 bytes of the string which is not necessarily the same as the last three characters of the string, and may or may not be a complete code. You could use the following code snippet to iterate over UTF-8 sequences (this will simply skip over most invalid codes): for uchar in string.gfind(ustring, "([%z\1-\127\194-\244][\128-\191]*)") do -- something end More sophisticated issues As you might have guessed by now, Lua provides no support for things like bidirectional printing or the proper formatting of Thai accents. Normally such things will be taken care of by a graphics or typography library. It would of course be possible to interface to such a library that did these things if you had access to one. There is a little string-like package [slnunicode] with upper/lower, len/sub and pattern matching for UTF-8. See ValidateUnicodeString for a smaller library. [ICU4Lua] is a Lua binding to ICU (International Components for Unicode [1]), an open-source library originally developed by IBM. See UnicodeIdentifers for platform independent Unicode Lua programs.