Lua相关问题整理(4) – 让Lua的eval函数支持赋值语句

上一篇文章提到了在Lua中实现类似于JavaScript中的eval函数,遗憾是该eval函数不支持赋值语句,原因是Lua的赋值运算符是不支持返回值。所以如果要让该eval函数也支持赋值语句,就需要一个额外的工作,让它鉴别一个语句是不是赋值语句,如果是,则return的是被赋值后变量的值。为此,我写了一个isAssignmentExpression函数,比较粗糙,不过够用了,基本思想是检测语句中第一个出现的”=“操作符,且该”=“不能在一对引号当中。

-- Lua code
function isAssignmentExpression( str )
	local i = 1;
	local curChar;
	local quotesType = "none" -- none, single or double
	local isEscaping = false

	curChar = string.sub( str, 1, 1 )
	while ( curChar ~= "" ) do
		if ( curChar == "'" and
			 isEscaping == false and
			 quotesType ~= "double" )
		then
			if ( quotesType == "single" )
			then quotesType = "none"
			elseif ( quotesType == "none" )
			then quotesType = "single"
			end
		end

		if ( curChar == "\"" and
			 isEscaping == false and
			 quotesType ~= "single" )
		then
			if ( quotesType == "double" )
			then quotesType = "none"
			elseif ( quotesType == "none" )
			then quotesType = "double"
			end
		end

		if ( curChar == "\\" and isEscaping == false )
		then isEscaping = true
		else isEscaping = false
		end

		if ( curChar == "=" and quotesType == "none" )
		then
			if ( string.sub( str, i+1, i+1 ) ~= "=" )
			then
				return true, string.sub( str, 1, i - 1 )
			else
				return false
			end
		end

		i = i + 1
		curChar = string.sub( str, i, i )
	end

	return false
end

function eval( str )
	local bAssign
	local var
	bAssign, var = isAssignmentExpression( str )
	if ( bAssign )
	then
		print( "Assignment, var=" .. var )
		loadstring( str )()
		return loadstring( "return " .. var )()
	else
		return loadstring( "return " .. str )()
	end
end

-- 以下是一组测试
print( eval( "3+4" ) )
-- 7
function Multiply( a, b )
	return a*b
end
print( eval( "Multiply( 3, 4 )" ) )
-- 12
print( eval( "i" ) )
-- nil
print( eval( "i = 1" ) )
-- Assignment, var=i
-- 1
print( eval( "i = i + 1" ) )
-- Assignment, var=i
-- 2
print( eval( "i" ) )
-- 2
print( eval( "i+1" ) )
-- 3
print( eval( "i, j = 4, 5" ) )
-- Assignment, var=i, j
-- 4	   5
print( eval( "i = {}" ) )
-- Assignment, var=i
-- table: 003CD818
print( eval( "i[ \"0\" ] = 0" ) )
-- Assignment, var=i[ "0" ]
-- 0
print( eval( "i[ \"\\\"0=\" ] = 1" ) )
-- Assignment, var=i[ "\"0=" ]
-- 1
print( eval( "i.name=\"hello\"" ) )
-- Assignment, var=i.name
-- hello
print( eval( "i[0], i.name = 4" ) )
-- Assignment, var=i[0], i.name
-- 4	  nil
print( eval( "i == 10" ) )
-- false
Posted in: Lua by Benny Chen 8 Comments , ,

Lua相关问题整理(3)

  1. 在注册给Lua的C函数中为Lua提供默认参数

    使用luaL_optstring, luaL_optnumber, luaL_optinteger等Lua API,如下示例,函数有一个默认字符串参数,默认值为”",这样在Lua中调用whatever的时候,whatever()或者whatever( “whatever”)均可。(Oh…whatever…随便…都行…)

    // C code
    int Whatever( lua_State *L )
    {
    	string str = luaL_optstring( L, 1, "" );
    	//...omitted code...
    }
    lua_register( L, "whatever", Whatever );
    
  2. 建立Lua字符串到C enum的映射

  3. 使用luaL_checkoption这个Lua API,它可以把从Lua传来的string转换为相应的C string array中的index,从而可以建立Lua字符串和C enum的映射。以下是个简单的示例:

    // C code
    enum PlayerType
    {
    	PLAYER_TYPE_UNDEFINED = -1,
    	PLAYER_TYPE_KING = 0, // 主公
    	PLAYER_TYPE_INSURGENT, // 反贼
    	PLAYER_TYPE_LOYAL, // 忠臣
    	PLAYER_TYPE_TREACHEROUS, //内奸-_^
    	NUM_PLAYER_TYPE // just a sentinel
    };
    
    const char * const PlayerTypeList[NUM_PLAYER_TYPE + 1] =
    {
    	"KING",
    	"INSURGENT",
    	"LOYAL",
    	"TREACHEROUS",
    	NULL
    };
    
    static int testPlayerType( lua_State *L )
    {
    	PlayerType type = static_cast< PlayerType >(
    						luaL_checkoption( L, 1,
    						"INSURGENT", PlayerTypeList ) );
    	std::cout << "Type index is " << type
    		      << " - " << PlayerTypeList[type]
    		      << std::endl;
    	return 0;
    }
    
    lua_register( L, "setPlayerType", setPlayerType )
    

    首先enum PlayerType定义了一组角色类型,来自人人都爱的三国杀:-)。

    接着PlayerTypeList定义了一个字符串数组,给Lua使用。注意需要保证enum和字符串数组的对应,比如PlayerTypeList[PLAYER_TYPE_KING]是“KING”,同时,PlayerTypeList必须以NULL结尾。

    在定义给Lua的函数testPlayerType中,就可以用luaL_checkoption将Lua传来的字符串参数转换为相应enum的值。luaL_checkoption还支持默认参数,比如在上面例子中,将第三个参数设为“INSURGENT”,如果Lua中没有提供任何参数,则PlayerType就为与“INSURGENT”相对应的PLAYER_TYPE_INSURGENT。

    以下是一组测试及结果:

    --Lua code
    testPlayerType( "KING" ) -- Type index is 0 - KING
    testPlayerType() -- Type index is 1 - INSURGENT
    testPlayerType( "whatever" ) -- bad argument #1 to 'testPlayerType' (invalid option 'whatever')
    
  4. 在Lua中实现eval函数

    众所周知,JavaScript中有一个著名的eval函数,它用于把一个字符串当作一段JS代码去执行,在Lua中没有提供类似的函数,但稍微包装下Lua的库函数loadstring即可实现,以下是代码。

    --Lua code
    function eval( str )
    	local func = loadstring( "return " ..str );
    	return func()
    end
    

    这样已经可以了,不过相比于JS的eval函数,功能稍微差一些,因为它不支持赋值语句,这是Lua语言天然的原因,因为Lua的赋值运算符没有返回值,在其他语言中常见传递赋值的“i=j=1”(先赋值j=1,然后将(j=1)的返回值j赋值给i),在Lua中是不允许的。所以当eval执行的是赋值运算(比如i=1)的时候,return i=1就会出错。

    下面是一些测试例子:

    --Lua code
    print( eval( "3+4" ) ) -- OK, 打印7
    
    function Multiply( a, b )
    	return a*b
    end
    
    print( eval( "Multiply( 3, 4 )" ) ) -- OK,打印12
    
    print( eval( "i = 1" ) ) -- 错误, attempt to call a nil value
    i = 1
    print( eval( "i" ) ) -- OK,打印1
    print( eval( "i = i + 1" ) ) -- 错误, attempt to call a nil value
    
  5. 实现luaL_checkbool

    不知道为什么Lua的API没有提供luaL_checkbook函数,不过很容易实现:

    // C code
    BOOL luaL_checkbool( lua_State *luaVM, int numArg )
    {
    	BOOL b = FALSE;
    	if ( lua_type( L, numArg ) == LUA_TBOOLEAN )
    	{
    		b = lua_toboolean( L, numArg );
    	}
    	else
    	{
    		luaL_typerror( L, numArg, lua_typename( L, LUA_TBOOLEAN ) )
    	}
    	return b;
    }
    
Posted in: Lua by Benny Chen No Comments , , , ,

Lua相关问题整理(1)

  1. (Under Linux)cannot find ‘dlsym’ ‘dlopen’ ‘dlerror’ ‘dlclose’

    需要同时链接”dl“库

  2. (Under Linux)编译lua报错luaconf.h:275:31: error: readline/readline.h: No such file or directory

    需要下载并安装GNU Readline Library

  3. PANIC: unprotected error in call to Lua API (unable to get ModuleFileName)

    1: 不推荐的解决方式:将Project Properties->Configuration Properties->General下的Character Set从unicode改成multi-set;
    2: 彻底的解决方式,参考此链接:http://lua-users.org/lists/lua-l/2006-06/msg00427.html

  4. 如何将Lua文本文件转化为Lua块文件(chunk file)

    调用LuaAPI – lua_dump

    关于lua_dump: about lua_dump: Dumps a function as a binary chunk. Receives a Lua function on the top of the stack and produces a binary chunk that, if loaded again, results in a function equivalent to the one dumped. As it produces parts of the chunk, lua_dump calls function writer (see lua_Writer) with the given data to write them.

  5. 如何在C中调用Lua脚本层的库函数

    void BeginLuaLibCall( lua_State *L, const string &libName, const string &functionName )
    {
         lua_pushstring( L, libName.c_str() );
         lua_gettable( L, LUA_GLOBALSINDEX );
         lua_pushstring( L, functionName.c_str() );
         lua_gettable( L, -2 );
    }
    
    void EndLuaLibCall( lua_State *L )
    {
         lua_pop( L, -1 );
    }
    

    示例:调用table.getn(该函数用来获取一个table的size)

    // 利用上面的函数
    BeginLuaLibCall( L, "table", "getn" );
    // 假设你的脚本中有一个table变量myTable,获取它到栈顶
    lua_getglobal( L, "myTable" );
    // 执行table.getn( t )
    lua_call( L, 1, 1 );
    // 打印结果
    std::cout << lua_tonumber( L, -1 ) ) << std::endl;
    // 将结果弹出栈
    lua_pop( L, -1 );
    // 将名叫“table”的table弹出栈
    EndLuaLibCall( L);
    

关于从DLL导出模板函数

模板在C++中本来就是个比较复杂的领域,而当它和DLL结合到一起时,事情变得更加有点复杂而有趣,最近就遇到了这样一个问题。

我有一个用于生成单件的类模板,它声明在一个DLL项目中,如下。

#if defined MY_EXPORTS
#define EXPORT_API __declspec(dllexport)
#else
#define EXPORT_API __declspec(dllimport)
#endif

template < typename T >
class Singleton
{
public:
	EXPORT_API static T& GetSingleton()
	{
		static T singleton;
		return singleton;
	}

// ...省去其它代码,比如隐藏构造函数,禁止复制构造和赋值函数..
};

我试图导出GetSingleton()函数,因为我希望在其他导入该DLL的模块中能够通过调用这个函数而得到单例。基于该Singleton类模板定义一个单件的类很简单,只需要继承实例化的类即可,比如我在DLL内部定义了两个单件类,LogManager和ResourceManager,他们的定义看起来像这样。

class LogManager : public Singleton< LogManager >
{
// ......
}
class ResourceManager : public Singleton< ResourceManager >
{
// 该类因为需要记录日志,会使用LogManager类
// ......
}

OK,DLL编译通过。然后,我在另一个项目模块中导入该DLL,我需要在这个模块中使用LogManager类和ResourceManager类,由于它们都是单件,正如前面所说的,我通过GetSingleton()函数得到单例,以访问它们的其它接口。

LogManager::GetSingleton()->...
ResourceManager::GetSingleton()->...

然而,状况出现了,build该模块时出现了链接错误:unresolved external symbol “public: static class ResourceManager & __cdecl Singleton::GetSingleton(void)”” ,提示死活链接不到ResourceManager的GetSingleton()函数,然而同样是使用Singleton模板,LogManager的GetSingelton()函数却是链接成功的。

如果足够了解template的机制,就很容易找到问题所在。问题的原因是,除非你显示的实例化(或者调用)了某个模板函数,否则这个模板函数在编译生成代码中(.obj)是根本不存在的。所以,尽管我们为模板函数打上了export的标签,但其实什么也没有导出。而LogManager能链接成功,是因为它在DLL中(ResourceManager中)有使用,从而编译器生成了LogManager::GetSingleton()并导出。

所以,为了能够同样也导出ResourceManager::GetSingleton(),我们必须在DLL中提前显示的实例化它(explicit instantiation)。

LogManager和ResourceManager都是在DLL内部定义的单件类,那能不能在DLL外部也基于Singleton模板快速定义单件类呢?可以,不过GetSingleton这个函数对于其它模块就是隐形的了(根本不存在),你只能在每一个单件类中重新定义一个GetSingleton函数,以避免链接错误。

这个问题有没有完美的解决方案呢,即我们能否让一个模板函数完全导出,使得在别的模块中也可以自由的基于任意类型实例化函数呢?

去google上试图寻求答案,无果。不过说这个问题还真不少,比如CodeProject上的这篇文章:http://www.codeproject.com/KB/cpp/MemberTemplateDLL.aspx 。它提出可以使用inline的方式来解决这个问题,但不保证结果,因为本来编译器对于inline的处理就是个未知的行为。他同时还提出,这可能是一个跟编译器相关的问题,因为对于模板的处理是个跟编译器密切相关的行为。该作者在VC6.0上遇到了这个问题,我的是在VS2005(VC8.0)上,在其他不同平台或版本的编译器上会怎样我也没有测试过。

总之,记住很重要的一点,当导出一个模板函数时,需要格外的警惕。在MSVC编译器上,只有在DLL中被显示的实例化的版本,相应的函数才会被导出。

Posted in: C++ by Benny Chen No Comments

翻入墙内 | 反向SSH Tunnel | Reverse SSH Tunnel

      状况 | Case

    因为GFW的关系,越来越多的网友熟练掌握了使用SSH Tunnel“翻墙”的方法——这种方法使我们通过墙外一台主机作为代理中转访问国际互联网。网上关于SSH翻墙的文章已经很多,无须赘述,提及此只为特别感谢郭嘉。
    少数情况下,我们不仅需要翻出墙,可能还需要从墙外翻回来。比如你交友不慎,某个邪恶国家友人强烈要求感受一下国内的网络环境;你如此勤奋以至于希望在家中仍然能够连接到公司网络开工,公司却出于体恤员工的考虑没有提供VPN,此时就需要手段先“翻”到公司的院子里。反向的SSH Tunnel就是这样的手段。

      原理 | Principle

    反向SSH Tunnel原理图

    反向SSH Tunnel原理


    在一般的SSH转发模型中,我们从大中华局域网中的Desktop B去SSH连接外部SSH Server X,将A的Px端口映射到X的SSH Server端口(22)。连接建立后我们就可以在应用中指定127.0.0.1:Px为代理。发往127.0.0.1.Px的请求将通过Tunnel发送到X:22,并根据SSH协议中转发的规定转发到外部网络。(此部分图中未表现)。
    在反向SSH Tunnel中,我们由大中华局域网内Desktop B用SSH连接外部主机Desktop A上的SSH Server,并建立一个反向Tunnel,将A:Port1映射到B:Port2。相比于一般的正向Tunnel,反向Tunnel允许SSH连接的被动方A将Port1上的请求通过Tunnel转发到B:Port2上。而B上应有一个应用监听Port2,对Port2上的请求做适宜的处理。对于一般的网络代理而言,此“应用”即为SSH Server。SSH Server监听22端口,并对来自SSH Tunnel的请求通过本地网络转发,起到代理的作用。

      实例 | Practice

    用到反向SSH Tunnel,是因为之前有这样一个需求:我们有一个开发中的网站,将要在外部Web Server(Host A)上布署测试环境,需要在外部主机上获取代码并持续更新。代码通过公司内部的SVN Server(Host S)进行版本控制,公司外部无法访问。我们不希望在外部主机上通过VPN一类软件登录公司网络,而是在必要的时候由内部网络发起连接。因此我们使用反向SSH Tunnel。
    创建反向SSH Tunnel的过程由内网的桌面(Host B)来完成

    1
    root@B#ssh -NfR {PORT_A}:localhost:{PORT_B} {HOST_A} -l {USER@HOST_A}

    1
    root@desktop#ssh -Nf$ 8080:localhost:9090 www.example.com -l webadmin

    输入密码确认后,一个从desktop:8080到www.example.com:9090的反向Tunnel就建好了。在Host A上用

    1
    netstat -ntl | grep 127

    将看到9090端口已经在监听。此后发往www.example.com:9090的请求将被通过Tunnel转送到desktop:8080。
    接下来我们对转发到Host B的8080端口上的请求做处理。在本例中,我们使用Apache Server的Proxy Module来转发请求。为此,首先要确认Apache有安装好mod_proxy和mod_http_proxy。然后,在Apache中添加虚拟主机,配置如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    NameVirtualHost *:8080
    Listen 8080
    # ...
    <VirtualHost *:8080>
        ServerName svn.company-domain.com

        ProxyPass / http://svn.company-domain.com/
        ProxyPassReverse / http://svn.company-domain.com/
        <Proxy *>
            Order deny,allow
            Allow from all
        </Proxy>
        <Directory />
            Order allow,deny
            Allow from all
        </Directory>
    </VirtualHost>

    此配置将在8080端口上建立虚拟主机,并将发往此主机的所有请求转发到http://svn.company-domain.com/。
    这样,一个完整的Reverse SSH Tunnel就建好了。在SSH Tunnel连通时,我们可以使用svn co http://172.0.0.1:9090/trunk/myproject/…/在Host A上下载源码。这个请求首先通过Tunnel进入公司网络,被转发到desktop:8080。然后,再被Apache根据mod_proxy的设置转发到svn.company-domina.com。SVN Server的响应也会按照原路逐级转发回到外部主机Host A。当然,我们也可以再做一些锦上添花的工作比如修改Host A上的本地DNS,将svn.company-domain.com解析到127.0.0.1。
    当必要的任务完成后,只要在Host B上断开SSH连接,外部主机Host A将没有办法访问内部网络。

      更多 | More

    以上只是实现了一个基本的反向SSH Tunnel实例,在此基础上我们还可以做很多,比如最重要的安全策略。我们可以在Host A(www.example.com)上限制对9090(PORT_A)的访问,在Host B上对SSH Server和Apache Proxy做相应的权限,日志等设置。
    另外,虽然从安全模型上说,这种由内部网络主动发起并且可控的连接是可以信任的,但是此办法实质是在公司防火墙上开了个后门。所以在使用前还是要看看公司安全规定有否相关约束。
    关于SSH用法还有无数的内容,部分可参考下面的资源。

      资源 | Resource

    Secure Shell
    Setting up a reverse SSH tunnel
    深入讲解SSH协议的转发概念
    反向建立 SSH Tunnel、免 VPN 連回公司
    上班族ssh tunnel求生手冊
    SSH Tunnel扫盲

小心动态链接库链接静态库时的内存错误

最近写的模块,在独立的应用程序中测试是没问题的,但把它装配成DLL后,再在另一个应用程序中调用时却出现了内存错误。程序的模块链接关系大概是这样的:

module就是我所写的模块,在这里被封装为DLL,因为要使用json相关的功能,该DLL链接了一个静态库 (jsoncpp.lib)。最后在应用程序中导入并使用module.dll,同时因为在应用程序中也需要用到json,所以应用程序也链接了jsoncpp.lib。

以下用一些伪代码来描述这些模块间的调用关系,以具现出这个错误。

jsoncpp.lib为c++提供了功能齐全的json操作,其核心的类是Json::Value。(阅读本篇文章你无需了解太多json)

module.dll中导出了一个接口:

//ModuleClass.h
#include "json/value.h"

#if defined MODULE_EXPORTS
#define MODULE_EXPORTS __declspec(dllexport)
#else
#define MODULE_EXPORTS __declspec(dllimport)
#endif

class ModuleClass
{
public:
	MODULE_EXPORTS void AllocSomeMemory( Json::Value &root )
	{
		// 这将申请一些内存,因为会new出一个Json::Value,并append到root上
		root.append( "testString" );
	}
};

应用程序:

#include "json/value.h"
#include "ModuleClass.h"
int main()
{
	Json::Value root;
	ModuleClass::AllocSomeMemory( root );
}

在Debug模式下,当main函数执行完毕,对Json::Value root进行析构时,程序便出现了异常。分析下,很显然,调用ModuleClass::MallocMemoryHere时申请的内存,是在module.dll中申请的,而对这些内存的析构则是在应用程序(.exe)中进行的(析构root会同时析构append在root上的所有子Json::Value)。不过,这是异常的真正原因么?

追踪到异常的出错点:dbgheap.c文件中那句ASSERT语句。

/*
* If this ASSERT fails, a bad pointer has been passed in. It may be
* totally bogus, or it may have been allocated from another heap.
* The pointer MUST come from the 'local' heap.
*/
_ASSERTE(_CrtIsValidHeapPointer(pUserData));

注释中的最后一句话”The pointer MUST come from the ‘local’ heap“引起了我的警惕,难道对于内存的申请和释放不是在同一个heap上,除了‘local’ heap还有一个什么heap么。

去MSDN上搜索了关于_CrtIsValidHeapPointer,似乎找到了答案,以下这段话是MSDN上对于_CrtIsValidHeapPointer的介绍:

The _CrtIsValidHeapPointer function is used to ensure that a specific memory address is within the local heap. The local heap refers to the heap created and managed by a particular instance of the C run-time library. If a dynamic-link library (DLL) contains a static link to the run-time library, it has its own instance of the run-time heap, and therefore its own heap, independent of the application’s local heap. When _DEBUG is not defined, calls to _CrtIsValidHeapPointer are removed during preprocessing.

注意字体加粗的部分,这不正应对我的情形么?!错误不在于DLL中申请的内存在EXE中释放,而在于如果这个DLL拥有一个静态链接,它就会拥有独立的运行时堆,独立于应用程序的堆。这样对于内存申请和释放并不是在同一个堆上进行的,当然出错了。

解决:虽然MSDN上最后说,如果把项目改成release的,这个ASSERT就将避免,但这是放纵内存泄露,最好的解决办法是将静态链接也改成动态链接,这样就使得DLL能够和应用程序共享同一个堆,错误也得以避免。

于是,我修改了jsoncpp的项目配置,生成jsoncpp的动态链接库,而不是使用静态库,重新导入到module.dll中,错误解决。

Posted in: C++ by Benny Chen No Comments , ,

Static Initialization Order Fiasco

Static Initialization Order Fiasco (SIOF),我也是最近才知道了这个说法,因为在开发程序的时候被它bug了:对于一个static变量,不管它是全局的或者是类的成员变量,访问它的时候不一定总是成功的,甚至会造成程序crash,因为不能保证它在被访问时已经被初始化了(跟初始化的顺序有关,所以称为初始化顺序的Fiasco)。以下将制造一个非常简单的SIOF情形:

Whatever.h

#include <vector>
#include <string>
class Whatever
{
public:
	Whatever()
	{
		cout << "Construct Whatever" << endl;
		Display();
	}
	~Whatever()
	{
		cout << "Destruct Whatever" << endl;
		Display();
	}
	void Display()
	{
		cout << "static int:" << i << endl;
		cout << "static string:" << m_str << endl;
		cout << "static vector:" << m_vec.front() << endl;
	}

private:
	static int i;
	static std::string m_str;
	static std::vector<char> m_vec;
};

Whatever.cpp

#include "Whatever.h"

int Whatever::i = 500;
string Whatever::m_str = "something";
vector<char> Whatever::m_vec = vector<char>( 10, 'a' );

一个简单的类,Whatever,包含几个static成员变量,然后在构造函数和析构函数中都分别打印这些静态变量的值,乍一看似乎没什么问题,但却有潜在的SIOF的风险。我们容易默认为在调用Whatever的构造函数的时候,Whatever空间中的static的成员变量已经被初始化了,其实不然,现在制造一个SIOF引起crash的情形:

#include "Whatever.h"
Whatever g_whatever;
int main()
{
	...
}

因为g_whatever是global变量,所以最先被初始化,在调用Whatever的构造函数的时候,Whatever空间的静态成员变量还未被初始化,所以访问这些静态变量肯定出错。在VS的编译器下测试的结果:

Construct Whatever
static int:5
static string:
(调用m_vec.front()导致程序crash)

奇怪的是对于int这种built-in的类型却能得到正确的值,不知编译器在背后都做了哪些手脚,猜想可能是在程序编译的时候他们就被值替换了。而string和vector应该都属于自定义类型(初始化需要调用构造函数),未初始化之前访问肯定是错误的,所以打印出的string是个空值,而访问一个空的vector的front元素则直接造成程序crash。

根据初始化和释放的对称关系,所以在析构函数中访问这些静态变量同样也是失败的,因为在析构g_whatever的时候,Whatever空间的静态变量已经被解决掉了。

SIOF是非常难于检测的问题,这个例子是一种最简单的情形,在我的项目中,我并没有定义什么global的成员,但是因为使用了很多前置声明(forward declaration),还有一些Singleton,造成了一个非常隐蔽的SIOF,花了很大的力气才找到,痛苦的过程。

要解决SIOF问题,需要用一个function来包装static变量,即利用函数内static变量的construct-on-first-use特性。

修改后的Whatever.h

class Whatever
{
public:
	Whatever()
	{
		cout << "Construct Whatever" << endl;
		Display();
	}
	~Whatever()
	{
		cout << "Destruct Whatever" << endl;
		Display();
	}
	void Display()
	{
		cout << "static vector:" << GetStaticVector().front() << endl;
	}

private:
	vector<char>& GetStaticVector()
	{
		static vector<char> vec = vector<char>( 10, 'a' );
		return vec;
	}
};

用GetStaticVector来包装之前所需要的静态的vector,就能保证在调用的时候,它一定已经被初始化了。再次运行之前的测试程序,OK了。

总之,我们对于static变量的使用要保持一颗警惕的心,如果不确定在使用时它是否已经被初始化,就要使用函数包装static变量来防止Static Initialization Order FIASCO!
Fiasco, what a cool word.

让管理lua_State的类指针安全

最近因为在公司的项目中接手了Lua脚本模块的开发,所以研究了很多关于Lua脚本的东西,秉着“多看多想多记”的原则,我时刻敦促自己要及时记录下遇到的一些问题和想法。

在Lua中,几乎所有的东西都是围绕着lua_State转,所以,一般我们都会写一个类来封装管理它,比如:

class LuaObject
{
public:
	LuaObject()
	{
		m_L = luaL_newstate();
		luaL_openlibs( m_L );
	}
	~LuaObject()
	{
		if ( m_L )
		{
			lua_close( m_L );
			m_L = NULL;
		}
	}

private:
	lua_State *m_L;
};

这很好,不过它不是指针安全的。试想,如果一个LuaObject对象被复制,结果将会怎样。

LuaObject luaObject1;
LuaObject luaObject2( luaObject1 );

上面这段代码将会导致运行时crash,因为luaObject1和luaObject事实上指向了同一块lua_State,这样当luaObject1和luaObject2被析构时,lua_State会被两次lua_close,这不crash才怪呢!

事实是,当一个类包含了一个指针时,我们就需要开始变得格外谨慎,除了在构造函数和析构函数中要处理指针的初始化和清理外,我们还需要考虑深拷贝(deep copy),浅拷贝(shallow copy))的问题。如果使用编译器默认生成的拷贝构造函数,它只会浅拷贝指针,而指针所指向的内存区域不会被拷贝。就像上面一样,两个LuaObject实则共享了一个lua_State。

那该如何处理让管理LuaObject类的指针安全呢,深拷贝?厄,首先我也没有深究深度拷贝lua_State具体该如何完成,不过我猜想这可是一个复杂而重型的操作,仅仅为了带来指针安全而选择此可不是一个明智的选择。

如果你是开发LuaObject类的程序员,也许你会对使用LuaObject的程序员(或许有时使用者就是你自己)说:“你不要对它进行拷贝操作不就OK了”,但这是一种严重不负责任的行为,因为这种皮球会越踢越远的。比如,程序员A使用了你的LuaObject类,他写了一个包含LuaObject的指针的类,同样A也不考虑拷贝指针安全问题,然后A又将它的类传递给了B,B封装了A的类指针,然后传递给了C,接着如此重复,C再给D,D再给E,最后E在对类进行拷贝操作时,程序crash掉了,因为在某个最底层,他们共享了lua_State。不过因为这时候已经嵌套了这么多层,E程序员或许根本不知道也不关心什么是LuaObject(他只跟D的类打交道)。这时,要想追踪到BUG之源——万恶的不考虑指针安全的LuaObject,已经非常困难了,God bless you all.

事实是,如果你不想让你的类被复制,你就应该明确而显示的禁止它。其实lua_State的这个问题非常类似于Effective C++书中的第14个条款中所提到的问题:在资源管理类中小心copying行为。对于这个问题,书中提供了两种解决方案。第一种就是禁止复制。第二种则是对底层资源的“引用计数法”(reference count)

第一种禁止复制很简单。(关于Uncopyable

class LuaObject : private Uncopyable
{
public:
    ...
}

第二种则是使用智能指针来封装lua_State,我们可以使用boost的shared_ptr来封装lua_State,即shared_ptr m_L。如何对m_L进行初始化是另一个需要注意的问题,如果使用shared_ptr的常见初始化形式:m_L = shared_ptr( luaL_newstate() ),这样是不对的,因为在这种形式下,当lua_State的计数变为0时,shared_ptr会去调用lua_State的的析构函数,这显然是错误的,对lua_State的释放动作是lua_close而不是删除。事实上,这样编译器也无法通过,如果这么写,会报出“use of undefined type ‘lua_State’”的错误,提示lua_State是一个非完成的类型(incomplete type)。

我们应该为shared_ptr的初始化传入一个删除器(deleter)。很显然,lua_State的deleter是lua_close()函数,这样最终的代码如下。

#include <boost/shared_ptr.hpp>
using boost::shared_ptr;

class LuaObject
{
public:
	LuaObject()
	{
		m_L = shared_ptr( luaL_newstate(), lua_close );
		luaL_openlibs( m_L.get() );
	}

private:
	boost::shared_pt< lua_State > m_L;
};

这样再回到前面拷贝的那个例子,luaObject1和luaObject2共同引用了一个lua_State,但因为使用了shared_ptr,所以只有在lua_State的引用次数变为0时,它的deleter(这里是lua_close)才会被调用,安全了!

在我的项目中,因为没有使用boost库,也没有提供任何智能指针,所以使用禁止复制来保证安全。

[译]3D为互联网准备好了么?

原文:Is 3D Finally Ready for the Web?
作者:Sixto Ortiz Jr.
来源:Computer archive, Volume 43, Issue 1 (January 2010) table of contents, Pages: 14-16, 2010

Introduction 介绍

最初的互联网是以一个简陋的鼠标点击环境开始的,但如今,互联网上已经到处是各种眼花缭乱的页面,充满着各种丰富的应用程序,有的用来娱乐,有的用来提高生产率,等等等等。用户可以在互联网上完成各式各样的任务,不管是购买商品,还是与全世界的用户实时交互。然而,一个关键的元素却迟迟没有在互联网上打上自己的烙印——3D。

在今天,3D的在线应用主要是游戏和虚拟世界,这些都需要强大的电脑和特殊的软件来支撑。然而,商业,工程企业和其他一些用户同样也需要3D,他们同样也需要3D所带来的真实感和更多细节。用户希望他们能够在浏览器中获得和在PC中一样的体验。并且由于3D技术在电影、游戏和其他各种娱乐行业中的广泛应用,消费者已经对它习以为常。因此,对于互联网上更多且更易于访问的3D内容的需求变得越来越强烈。况且更好的浏览器体验同时也意味着更多潜在的收入。

然而,互联网3D还处于一种很不成熟的状态,因为很难在典型的PC和浏览器上广泛使用这种复杂的技术。事实上,一般浏览器也无法承载复杂的3D内容,更无法提供高帧率或全屏的图形效果。并且,在实时的合作程序和其他应用程序中包含3D让本来已经很繁琐的开发过程会变得更加复杂。

尽管如此,现在是有一些组织在为网络3D技术而努力工作的。他们尝试将浏览器转为一种更为强大的计算平台,以在该平台上获得如PC上一样的体验,例如3D内容的展示。这些工作将会为网络衍生出更多的应用程序,包括产品建模,展示和配置;3D在线会议和工人协作;对于手术或机械过程的模拟;虚拟旅游;增强现实等等。

不管怎样,在互联网3D技术变得可依赖和成为主流之前,仍然有重重的困难需要克服。

3D on the web 网络上的3D

早期的网络是没有图形界面的,直到NCSA(美国国家超计算应用程序中心)在1993年发布了Mosaic,这是首个可以同时展示图片和文字的浏览器。

当前在互联网上,已经有一些为3D服务的技术在使用,他们基本使用同样的方式工作,但是使用不同的文件格式。

VRML和X3D
网络3D开始于1994年,在这一年,VRML组织发布了虚拟现实标记语言(Virtual Reality Markup Language)。然而,VRML从未流行过,因为它限制开发者只可以写3D相关的内容。为了创建完整的引人注目的应用程序,开发者必须能够同时开发3D,2D,视频和音频。在处理器和软件能够支持图形之前,VRML表现还是不错的,因为它能支持图形。但是VRML太慢,并且没有能力渲染复杂高仿真的模型和场景。

在1997年,Web3D联盟推出了X3D,它是一种基于XML的文件格式,同时也是VRML的扩展,以用来表现3D图形。X3D同样也没有流行过。游戏和3D开发人员广泛忽视了X3D,X3D只被极少数的商业工具所支持。

其他方法
3D工业论坛于2003年推出的Universal 3D技术,是一种压缩的3D图形文件格式。然而,它的推崇者也只是推动Universal 3D使其成为了一种主要使用在制造业或建筑业相关应用程序的文件格式。

开源的网络3D标记语言(3DMLW,3D Markup Language for Web)是一种基于XML的文件格式,它用于创建网络上的3D和2D内容。3DMLW由3D Technologies R&D于2009年推出,它可以通过插件工作在大多数流行的浏览器中。

Technical Developments 技术开发

今天的硬件能力能够比过去更好的处理3D。更快的CPU,更快的图形处理器和显卡,以及四处可见的3D图形加速器,这些都为网络3D的出现提供了可能。

JavaScript和HTML 5.0
开发者使用JavaScript语言开发各种网络应用程序。浏览器的 JavaScript引擎性能的提升,使得网络3D成为可能。比如说,IE9中的JavaScript引擎将可以使用宿主机器的图形处理器来快速的处理图形相关的任务。同样的,Mozilla也增强了其Firefox浏览器的JavaScript引擎,他们使用了一种追踪( tracing )技术,该技术通过优化代码的执行方式来提升性能。

JavaScript的访问HTML 5.0的能力可以让开发者更加方便的将视频,音频,3D和2D内容无缝合并到应用程序中。HTML5.0中的画布(canvas)元素同样也会促成互联网3D。该元素使得浏览器可以通过它们的JavaScript引擎,本能(无需插件技术)且动态的渲染位图图片,使得渲染3D变得更加容易。

WebGL
Mozilla 基金会是一个创建和支持开源应用程序的组织,Khronos是一个为并行计算,图形和动态媒体设计标准的联盟。它们俩正在开发WebGL。该技术可以在不需要插件的情况下为网络带来硬件加速的3D图形效果。任何支持Khronos的OpenGL或OpenGL ES规范的浏览器都可以运行WebGL。

跨语言跨平台的OpenGL定义了一组API,以供开发出提供2D和3D图形效果的应用程序。而OpenGL ES(Embedded Systems)规范为从简单元素(或者成为图元,比如线或者多边形)绘制3D场景提供了编程工具。OpenGL ES可以工作在智能手机这样的小型设备上。然而,这些能力不能离开插件的支持。许多用户倾向于不使用插件,因为它们不易安装,且难于排除故障和管理。

WebGL使得浏览无需插件便可渲染3D内容。该技术提供可以让软件通过编程访问PC机3D渲染硬件的API,从而扩展了OpenGL。本质上,WebGL提供了JavaScript应用程序和OpenGL软件库之间的连接,而后者负责访问宿主系统的图形处理器。这可以充分利用硬件的能力来渲染3D内容。

Khronos已经建立了一个WebGL工作组,该工作组将在今年上半年发布 WebGL的第一个release版本。但是程序人员已经开始把WebGL构建到Firefox的开发版和Webkit开源浏览器引擎中,该浏览器引擎被苹果的Safari和Google的Chrome浏览器所使用。

O3D
Google也是 WebGL工作组的成员,但同时Google也开发了一款基于浏览器的3D图形技术,O3D,如下图所示。

O3D Software Stack

图片来源:http://code.google.com/apis/o3d/docs/techoverview.html

O3D是一个基于IE,Firefox,Safari 和Chrome这些浏览器的插件。Google现在正在把该技术构建到Chrome中,并希望未来能够直接构建到其它的浏览器中。O3D可以在Windows,Mac,Linux上运行,它是一套开源的JavaScript API,用于开发互动的3D图形应用程序,比如游戏,广告,或者虚拟产品展示,都运行在一个浏览器里。该API为基于JavaScript的程序提供了接口,使得JavaScript应用程序可以与包含在O3D插件中的O3D核心软件进行通信,从而直接利用计算机的图形硬件。

Google 发言人说O3D是一个保留模式(retained-mode)的技术,因为它只设置场景一次,然后每帧只绘制场景改变的部分。与WebGL这样的立即模式(immediate-mode)技术不同,O3D不会每次都重新绘制整个场景。这提供了更好的性能,但却弱化了开发者的控制能力。

Adobe Flash
Adobe正在将更强的3D能力加入到它所属的Flash浏览器插件中。Adobe是在2008年Flash Player 10的发行版中推出了3D能力。该技术通过加入新的类和方法,从而包含了对于3D效果的支持,尤其可以通过Flash的 ActionScript编程语言在三维空间中设置一个物体的位置。通过这种方法,即便是没有丰富3D经验的开发者也可以通过在2D中设计物体来制作3D内容,并能通过新加入的类和方法修改它们。Flash Player 10.0,现在是beta版,将会为智能手机和其他移动设备带来3D效果。

Standing in the Way 在路上

在3D Web真正成熟之前,它还需要克服重重的障碍。

比如说,插件,在某些情况下,时常会导致浏览器崩溃或者其他的问题。让浏览器能够天生就有渲染3D的能力,并且克服当前3D技术不能和所有的浏览器、操作系统和应用程序兼容的问题,这些都是很大的挑战。另外,缺乏标准化也是一个问题。如果没有标准化,网络将会出现各种不同的互不兼容的格式和技术,这使得开发者为了在不同的浏览器上运行需要创建很多版本的程序。同时,开发网络上的3D内容需要很长的开发时间,并且很少的开发者对该方法很熟悉。

对于上网本和智能手机使用的迅猛增长,这些具有较慢的处理器,意味着更多的人在使用无法运行3D内容的设备。技术硬件能力和网络带宽已经大幅度的提升了,但它们仍然不能满足高度复杂的3D模型的需求。并且网络3D技术的推崇者们并没有为普通用户设计在线3D技术,这是在犯和VRML一样的错误。

Conclusion 结论

WebGL是一个非常有趣的网络3D开发技术,因为它无需插件。一旦WebGL推出,我们将在网络上看到3D内容的迅速增多。然而,3D在10年内是很难成功的,直到迅猛增长的流行上网本和智能手机拥有足够强大的处理器能力来播放数据密集的内容。不过总有一天,3D将在网络上做到像现在视频所做到的一样,网络3D的时代终会到来。