Index: trunk/src/formats/md2_loader.cc
===================================================================
--- trunk/src/formats/md2_loader.cc	(revision 197)
+++ trunk/src/formats/md2_loader.cc	(revision 198)
@@ -17,5 +17,4 @@
 
 // assuming low-endian
-#define MD2_MAGIC         "IDP2"
 #define MD2_MAX_FRAMES    512
 #define MD2_MAX_SKINS     32
@@ -75,6 +74,6 @@
 struct md2_vertex_t
 {
-	unsigned char v[3];
-	unsigned char n;
+	uint8 v[3];
+	uint8 n;
 };
 
@@ -127,5 +126,5 @@
 }
 
-static bool read_md2_frame( md2_frame_t* frame, int vcount, nv::stream& source )
+static bool read_md2_frame( md2_frame_t* frame, unsigned vcount, nv::stream& source )
 {
 	frame->vertices = new md2_vertex_t[ vcount ];
@@ -170,14 +169,14 @@
 	
 	source.seek( md2->header.offset_skins, origin::SET );
-	source.read( md2->skins, sizeof(md2_skin_t), md2->header.num_skins );
+	source.read( md2->skins, sizeof(md2_skin_t), static_cast<size_t>( md2->header.num_skins ) );
 
 	source.seek( md2->header.offset_st, origin::SET );
-	source.read( md2->texcoords, sizeof(md2_texcoord_t), md2->header.num_st );
+	source.read( md2->texcoords, sizeof(md2_texcoord_t), static_cast<size_t>( md2->header.num_st ) );
 
 	source.seek( md2->header.offset_tris, origin::SET );
-	source.read( md2->triangles, sizeof(md2_triangle_t), md2->header.num_tris );
+	source.read( md2->triangles, sizeof(md2_triangle_t), static_cast<size_t>( md2->header.num_tris ) );
 
 	source.seek( md2->header.offset_glcmds, origin::SET);
-	source.read( md2->glcmds, sizeof(int), md2->header.num_glcmds );
+	source.read( md2->glcmds, sizeof(int), static_cast<size_t>( md2->header.num_glcmds ) );
 
 	md2->frames    = new md2_frame_t   [ md2->header.num_frames ];
@@ -185,5 +184,5 @@
 	for ( int i = 0; i < md2->header.num_frames; ++i )
 	{
-		if (!read_md2_frame( &(md2->frames[i]), md2->header.num_vertices, source ) ) return false;
+		if (!read_md2_frame( &(md2->frames[i]), static_cast<unsigned>( md2->header.num_vertices ), source ) ) return false;
 	}
 
@@ -197,5 +196,5 @@
 }
 
-static inline vec3 md2_normal( char normal )
+static inline vec3 md2_normal( uint8 normal )
 {
 	return md2_vec3( md2_normal_table[normal] );
@@ -269,7 +268,7 @@
 }
 
-sint32 md2_loader::get_max_frames() const
-{
-	return ((md2_t*)m_md2)->header.num_frames;
+size_t md2_loader::get_max_frames() const
+{
+	return static_cast< size_t >( ((md2_t*)m_md2)->header.num_frames );
 }
 
@@ -277,9 +276,9 @@
 {
 	md2_t* md2 = (md2_t*)m_md2;
-	sint32 num_frames = md2->header.num_frames;
-	sint32 num_verts  = m_new_vindexes.size();
+	size_t num_frames = static_cast< size_t >( md2->header.num_frames );
+	size_t num_verts  =	m_new_vindexes.size();
 	p.clear();
-	sint32 current_frame = ( frame == -1 ? 0 : frame );
-	sint32 frame_count   = ( frame == -1 ? num_frames : 1 );
+	size_t current_frame = ( frame == -1 ? 0 : static_cast< size_t >( frame ) );
+	size_t frame_count   = ( frame == -1 ? num_frames : 1 );
 
 	p.reserve( num_verts * frame_count );
@@ -287,13 +286,13 @@
 	while ( frame_count > 0 )
 	{
-		const md2_frame_t& frame = md2->frames[current_frame];
-		NV_LOG( LOG_INFO, "FrameID = " << frame.name );
-
-		vec3 scale     = md2_vec3( frame.scale );
-		vec3 translate = md2_vec3( frame.translate );
-
-		for (sint32 i = 0; i < num_verts; ++i )
+		const md2_frame_t& cframe = md2->frames[current_frame];
+		NV_LOG( LOG_INFO, "FrameID = " << cframe.name );
+
+		vec3 scale     = md2_vec3( cframe.scale );
+		vec3 translate = md2_vec3( cframe.translate );
+
+		for (size_t i = 0; i < num_verts; ++i )
 		{
-			const md2_vertex_t& v = frame.vertices[ m_new_vindexes[ i ] ];
+			const md2_vertex_t& v = cframe.vertices[ m_new_vindexes[ i ] ];
 			p.push_back( vec3( v.v[0], v.v[2], v.v[1] ) * scale + translate );
 		}
@@ -306,9 +305,9 @@
 {
 	md2_t* md2 = (md2_t*)m_md2;
-	sint32 num_frames = md2->header.num_frames;
-	sint32 num_verts  =	m_new_vindexes.size();
+	size_t num_frames = static_cast< size_t >( md2->header.num_frames );
+	size_t num_verts  =	m_new_vindexes.size();
 	n.clear();
-	sint32 current_frame = ( frame == -1 ? 0 : frame );
-	sint32 frame_count   = ( frame == -1 ? num_frames : 1 );
+	size_t current_frame = ( frame == -1 ? 0 : static_cast< size_t>( frame ) );
+	size_t frame_count   = ( frame == -1 ? num_frames : 1 );
 
 	n.reserve( num_verts * frame_count );
@@ -316,9 +315,9 @@
 	while ( frame_count > 0 )
 	{
-		const md2_frame_t& frame = md2->frames[current_frame];
-
-		for (sint32 i = 0; i < num_verts; ++i )
+		const md2_frame_t& cframe = md2->frames[current_frame];
+
+		for (size_t i = 0; i < num_verts; ++i )
 		{
-			const md2_vertex_t& v = frame.vertices[ m_new_vindexes[ i ] ];
+			const md2_vertex_t& v = cframe.vertices[ m_new_vindexes[ i ] ];
 			n.push_back( s_md2_normal_cache[ v.n ] );
 		}
@@ -331,5 +330,5 @@
 {
 	md2_t* md2 = (md2_t*)m_md2;
-	sint32 num_verts  = m_new_vindexes.size();
+	size_t num_verts  = m_new_vindexes.size();
 
 	t.clear();
@@ -338,5 +337,5 @@
 	vec2 scale( 1.0f / (float) md2->header.skinwidth, 1.0f / (float) md2->header.skinheight );
 
-	for (sint32 i = 0; i < num_verts; ++i )
+	for (size_t i = 0; i < num_verts; ++i )
 	{
 		const md2_texcoord_t& st = md2->texcoords[ m_new_tindexes[ i ] ];
@@ -354,5 +353,5 @@
 {
 	md2_t* md2 = (md2_t*)m_md2;
-	uint32 num_indexes = md2->header.num_tris * 3;
+	uint32 num_indexes = static_cast< uint32 >( md2->header.num_tris * 3 );
 
 	uint32 stats_reuse      = 0;
@@ -373,10 +372,10 @@
 		for ( int j = 0; j < 3; ++j )
 		{
-			short index  = t.vertex[j];
-			short tindex = t.st[j];
+			uint16 index  = t.vertex[j];
+			uint16 tindex = t.st[j];
 
 			if ( index_translation[ index ] != -1 )
 			{
-				uint16 prev = index_translation[ index ];
+				uint16 prev = static_cast< uint16 >( index_translation[ index ] );
 				if ( m_new_tindexes[ prev ] == tindex )
 				{
Index: trunk/src/formats/md3_loader.cc
===================================================================
--- trunk/src/formats/md3_loader.cc	(revision 197)
+++ trunk/src/formats/md3_loader.cc	(revision 198)
@@ -17,5 +17,4 @@
 
 // assuming low-endian
-#define MD3_MAGIC         "IDP3"
 #define MD3_MAX_FRAMES    1024
 #define MD3_MAX_TAGS      16
@@ -149,5 +148,5 @@
 static bool read_surface( md3_surface_t * surface, nv::stream& source )
 {
-	sint32 pos = source.tell();
+	sint32 pos = static_cast< sint32 >( source.tell() );
 	source.read( &surface->header, sizeof(md3_surface_header_t), 1 );
 
@@ -164,14 +163,14 @@
 
 	source.seek( pos + surface->header.ofs_shaders, origin::SET );
-	source.read( surface->shaders, sizeof( md3_shader_t ), surface->header.num_shaders );
+	source.read( surface->shaders, sizeof( md3_shader_t ), static_cast<size_t>( surface->header.num_shaders ) );
 
 	source.seek( pos + surface->header.ofs_triangles, origin::SET );
-	source.read( surface->triangles, sizeof( md3_triangle_t ), surface->header.num_triangles );
+	source.read( surface->triangles, sizeof( md3_triangle_t ), static_cast<size_t>( surface->header.num_triangles ) );
 
 	source.seek( pos + surface->header.ofs_st, origin::SET );
-	source.read( surface->st, sizeof( md3_texcoord_t ), surface->header.num_verts );
+	source.read( surface->st, sizeof( md3_texcoord_t ), static_cast<size_t>( surface->header.num_verts ) );
 
 	source.seek( pos + surface->header.ofs_xyznormal, origin::SET );
-	source.read( surface->vertices, sizeof( md3_vertex_t ), surface->header.num_verts * surface->header.num_frames );
+	source.read( surface->vertices, sizeof( md3_vertex_t ), static_cast<size_t>( surface->header.num_verts * surface->header.num_frames ) );
 
 	if ( source.tell() != static_cast<std::size_t>( pos + surface->header.ofs_end ) ) return false;
@@ -201,11 +200,11 @@
 	md3->tags     = new md3_tag_t    [ md3->header.num_tags * md3->header.num_frames ];
 	md3->surfaces = new md3_surface_t[ md3->header.num_surfaces ];
-	std::memset( md3->surfaces, 0, md3->header.num_surfaces * sizeof(md3_surface_t) );
+	std::memset( md3->surfaces, 0, static_cast< size_t >( md3->header.num_surfaces ) * sizeof(md3_surface_t) );
 
 	source.seek( md3->header.ofs_frames, origin::SET );
-	source.read( md3->frames, sizeof( md3_frame_t ), md3->header.num_frames );
+	source.read( md3->frames, sizeof( md3_frame_t ), static_cast<size_t>( md3->header.num_frames ) );
 
 	source.seek( md3->header.ofs_tags, origin::SET );
-	source.read( md3->tags, sizeof( md3_tag_t ), md3->header.num_tags * md3->header.num_frames );
+	source.read( md3->tags, sizeof( md3_tag_t ), static_cast<size_t>( md3->header.num_tags * md3->header.num_frames ) );
 
 	source.seek( md3->header.ofs_surfaces, origin::SET );
@@ -351,7 +350,7 @@
 }
 
-sint32 md3_loader::get_max_frames() const
-{
-	return ((md3_t*)m_md3)->header.num_frames;
+size_t md3_loader::get_max_frames() const
+{
+	return static_cast< size_t >( ((md3_t*)m_md3)->header.num_frames );
 }
 
@@ -401,5 +400,5 @@
 	sint32 frame_count   = ( frame == -1 ? md3->header.num_frames : 1 );
 
-	p.reserve( md3->vertices_per_frame * frame_count );
+	p.reserve( static_cast< size_t >( md3->vertices_per_frame * frame_count ) );
 
 	while ( frame_count > 0 )
@@ -430,5 +429,5 @@
 	sint32 frame_count   = ( frame == -1 ? md3->header.num_frames : 1 );
 
-	n.reserve( md3->vertices_per_frame * frame_count );
+	n.reserve( static_cast< size_t >( md3->vertices_per_frame * frame_count ) );
 
 	while ( frame_count > 0 )
@@ -476,8 +475,8 @@
 	{
 		const md3_surface_t& surface = md3->surfaces[i];
-		const sint32         tcount  = surface.header.num_triangles;
+		const size_t         tcount  = static_cast< size_t >( surface.header.num_triangles );
 
 		idx.reserve( idx.size() + tcount * 3 );
-		for (sint32 j = 0; j < tcount; ++j )
+		for (size_t j = 0; j < tcount; ++j )
 		{
 			const md3_triangle_t& t = surface.triangles[j];
Index: trunk/src/formats/md5_loader.cc
===================================================================
--- trunk/src/formats/md5_loader.cc	(revision 197)
+++ trunk/src/formats/md5_loader.cc	(revision 198)
@@ -36,5 +36,5 @@
 }
 
-void unit_quat_w( glm::quat& quat )
+static void unit_quat_w( glm::quat& quat )
 {
 	float t = 1.0f - ( quat.x * quat.x ) - ( quat.y * quat.y ) - ( quat.z * quat.z );
@@ -354,5 +354,5 @@
 		{
 			discard( sstream, "{" );
-			for ( int i = 0; i < m_num_joints; ++i )
+			for ( size_t i = 0; i < m_num_joints; ++i )
 			{
 				md5_joint_info joint;
@@ -368,5 +368,5 @@
 			discard( sstream, "{" );
 			next_line( sstream ); 
-			for ( int i = 0; i < m_num_frames; ++i ) 
+			for ( size_t i = 0; i < m_num_frames; ++i ) 
 			{
 				md5_bound bound;
@@ -390,5 +390,5 @@
 			next_line( sstream ); 
 
-			for ( int i = 0; i < m_num_joints; ++i )
+			for ( size_t i = 0; i < m_num_joints; ++i )
 			{
 				md5_base_frame base_frame;
@@ -412,5 +412,5 @@
 			next_line( sstream ); 
 
-			for ( int i = 0; i < m_num_animated_components; ++i )
+			for ( size_t i = 0; i < m_num_animated_components; ++i )
 			{
 				float frameData;
@@ -436,9 +436,9 @@
 	m_anim_time = 0.0f;
 
-	assert( m_joint_infos.size() == (size_t)m_num_joints );
-	assert( m_bounds.size()      == (size_t)m_num_frames );
-	assert( m_base_frames.size() == (size_t)m_num_joints );
-	assert( m_frames.size()      == (size_t)m_num_frames );
-	assert( m_skeletons.size()   == (size_t)m_num_frames );
+	assert( m_joint_infos.size() == m_num_joints );
+	assert( m_bounds.size()      == m_num_frames );
+	assert( m_base_frames.size() == m_num_joints );
+	assert( m_frames.size()      == m_num_frames );
+	assert( m_skeletons.size()   == m_num_frames );
 
 	return true;
@@ -506,5 +506,5 @@
 void md5_animation::interpolate_skeletons( md5_frame_skeleton& final_skeleton, const md5_frame_skeleton& skeleton0, const md5_frame_skeleton& skeleton1, float interpolate )
 {
-	for ( int i = 0; i < m_num_joints; ++i )
+	for ( size_t i = 0; i < m_num_joints; ++i )
 	{
 		md5_skeleton_joint& final_joint = final_skeleton.joints[i];
Index: trunk/src/formats/obj_loader.cc
===================================================================
--- trunk/src/formats/obj_loader.cc	(revision 197)
+++ trunk/src/formats/obj_loader.cc	(revision 198)
@@ -119,5 +119,5 @@
 struct mesh_obj_reader : public obj_reader
 {
-	mesh_obj_reader( mesh* m ) : m_mesh( m ), m_position( nullptr ), m_normal( nullptr ), m_tex_coord( nullptr ), m_tangent( nullptr ) {}
+	mesh_obj_reader( mesh* m ) : m_position( nullptr ), m_normal( nullptr ), m_tex_coord( nullptr ), m_tangent( nullptr ), m_mesh( m ) {}
 	virtual std::size_t add_face( uint32* v, uint32* t, uint32* n, size_t count );
 	virtual void calculate_tangents();
@@ -206,6 +206,6 @@
 		vec3 xyz1 = v2 - v1;
 		vec3 xyz2 = v3 - v1;
-		vec2 st1  = w2 - w1;
-		vec2 st2  = w3 - w1;
+		//vec2 st1  = w2 - w1;
+		//vec2 st2  = w3 - w1;
 
 		float s1 = w2.x - w1.x;
Index: trunk/src/gfx/texture_atlas.cc
===================================================================
--- trunk/src/gfx/texture_atlas.cc	(revision 197)
+++ trunk/src/gfx/texture_atlas.cc	(revision 198)
@@ -15,5 +15,5 @@
 	: image( size, depth ), m_used( 0 ), m_border( border )
 {
-	m_nodes.push_back( glm::ivec3( m_border, m_border, m_size.x - 2 * m_border ) );
+	m_nodes.push_back( glm::ivec3( m_border, m_border, m_size.x - 2 * static_cast<int>( m_border ) ) );
 	fill( 0 );
 }
Index: trunk/src/gl/gl_context.cc
===================================================================
--- trunk/src/gl/gl_context.cc	(revision 197)
+++ trunk/src/gl/gl_context.cc	(revision 198)
@@ -363,4 +363,5 @@
 #else
 	NV_UNUSED( a_win_handle );
+	NV_UNUSED( m_handle );
 #endif
 
Index: trunk/src/io/c_stream.cc
===================================================================
--- trunk/src/io/c_stream.cc	(revision 197)
+++ trunk/src/io/c_stream.cc	(revision 198)
@@ -46,5 +46,5 @@
 }
 
-bool c_stream::seek( size_t offset, origin orig )
+bool c_stream::seek( long offset, origin orig )
 {
 	return m_file != nullptr && ( ::fseek( (FILE*)m_file, (long)offset, static_cast<int>(orig) ) == 0 );
@@ -53,5 +53,5 @@
 size_t c_stream::tell()
 {
-	return m_file != nullptr ? ::ftell( (FILE*)m_file ) : 0;
+	return m_file != nullptr ? static_cast< size_t >( ::ftell( (FILE*)m_file ) ) : 0;
 }
 
Index: trunk/src/io/std_stream.cc
===================================================================
--- trunk/src/io/std_stream.cc	(revision 197)
+++ trunk/src/io/std_stream.cc	(revision 198)
@@ -15,6 +15,6 @@
 	: m_stream( source )
 	, m_owner( owner )
+	, m_buffer( std::max(bsize, put_back) + put_back )
 	, m_put_back( std::max( put_back, std::size_t( 1 ) ) )
-	, m_buffer( std::max(bsize, put_back) + put_back )
 {
 	char *end = &m_buffer.front() + m_buffer.size();
@@ -49,5 +49,5 @@
 
 	// start is now the start of the buffer, proper.
-	size_t n = m_stream->read( start, 1, m_buffer.size() - (start - base) );
+	size_t n = m_stream->read( start, 1, m_buffer.size() - static_cast<size_t>(start - base) );
 	if (n == 0)
 	{
Index: trunk/src/lib/lua.cc
===================================================================
--- trunk/src/lib/lua.cc	(revision 197)
+++ trunk/src/lib/lua.cc	(revision 198)
@@ -66,6 +66,6 @@
 
 // only loaded in 5.1 mode to implement lua_compare
-int    (*lua_equal)        (lua_State *L, int idx1, int idx2) = nullptr;
-int    (*lua_lessthan)     (lua_State *L, int idx1, int idx2) = nullptr;
+static int    (*lua_equal)        (lua_State *L, int idx1, int idx2) = nullptr;
+static int    (*lua_lessthan)     (lua_State *L, int idx1, int idx2) = nullptr;
 
 
@@ -75,5 +75,5 @@
 
 #	define NV_LUA_COMPAT_FUN( rt, fn, fp, rt2, fn2, fp2,arg,ret ) \
-		rt call_##fn2##_compat fp { ret fn2##_compat arg; } 
+		static rt call_##fn2##_compat fp { ret fn2##_compat arg; } 
 #	include <nv/lib/detail/lua_functions_compat.inc>
 #	undef NV_LUA_COMPAT_FUN
@@ -85,11 +85,9 @@
 #	define LUA_GLOBALSINDEX_52      2
 #	define LUA_REGISTRYINDEX_51     (-10000)
-#	define lua_upvalueindex_51(i)   (LUA_GLOBALSINDEX_51-(i))
-#	define lua_upvalueindex_52(i)   (LUA_REGISTRYINDEX_52-(i))
-
-int lua_absindex_51 (lua_State *L, int idx) { return (idx > 0 ? idx : idx + lua_gettop(L) + 1); };
-void lua_getglobal_51 (lua_State *L, const char *var) { lua_getfield(L, LUA_GLOBALSINDEX_51, var ); };
-void lua_setglobal_51 (lua_State *L, const char *var) { lua_setfield(L, LUA_GLOBALSINDEX_51, var ); };
-void luaL_requiref_51 (lua_State *L, const char *modname, lua_CFunction openf, int glb)
+
+static int lua_absindex_51 (lua_State *L, int idx) { return (idx > 0 ? idx : idx + lua_gettop(L) + 1); };
+static void lua_getglobal_51 (lua_State *L, const char *var) { lua_getfield(L, LUA_GLOBALSINDEX_51, var ); };
+static void lua_setglobal_51 (lua_State *L, const char *var) { lua_setfield(L, LUA_GLOBALSINDEX_51, var ); };
+static void luaL_requiref_51 (lua_State *L, const char *modname, lua_CFunction openf, int glb)
 {
 	lua_pushcfunction(L, openf);
@@ -105,5 +103,5 @@
 }
 
-void luaL_setmetatable_51 (lua_State *L, const char *tname)
+static void luaL_setmetatable_51 (lua_State *L, const char *tname)
 {
 	luaL_getmetatable(L, tname);
@@ -111,5 +109,5 @@
 }
 
-void *luaL_testudata_51 (lua_State *L, int ud, const char *tname)
+static void *luaL_testudata_51 (lua_State *L, int ud, const char *tname)
 {
 	void *p = lua_touserdata(L, ud);
@@ -128,5 +126,5 @@
 }
 
-const lua_Number *lua_version_51 (lua_State*) 
+static const lua_Number *lua_version_51 (lua_State*) 
 {
 	static const lua_Number version = (lua_Number)LUA_VERSION_NUM;
@@ -134,5 +132,5 @@
 }
 
-void lua_copy_51 (lua_State *L, int fromidx, int toidx)
+static void lua_copy_51 (lua_State *L, int fromidx, int toidx)
 {
 	toidx = lua_absindex( L, toidx );
@@ -141,5 +139,5 @@
 }
 
-int lua_compare_51(lua_State *L, int idx1, int idx2, int op)
+static int lua_compare_51(lua_State *L, int idx1, int idx2, int op)
 {
 	switch (op)
@@ -153,5 +151,5 @@
 }
 
-void lua_rawgetp_51(lua_State *L, int idx, const void *p)
+static void lua_rawgetp_51(lua_State *L, int idx, const void *p)
 {
 	idx = lua_absindex( L, idx );
@@ -161,5 +159,5 @@
 }
 
-void lua_rawsetp_51(lua_State *L, int idx, const void *p)
+static void lua_rawsetp_51(lua_State *L, int idx, const void *p)
 {
 	idx = lua_absindex( L, idx );
@@ -170,5 +168,5 @@
 }
 
-int luaL_getsubtable_51(lua_State *L, int idx, const char *fname)
+static int luaL_getsubtable_51(lua_State *L, int idx, const char *fname)
 {
 	lua_getfield(L, idx, fname);
@@ -184,5 +182,5 @@
 }
 
-void luaL_setfuncs_51(lua_State *L, const luaL_Reg *l, int nup)
+static void luaL_setfuncs_51(lua_State *L, const luaL_Reg *l, int nup)
 {
 	luaL_checkstack(L, nup, "too many upvalues");
@@ -199,10 +197,10 @@
 }
 
-void lua_pushglobaltable_51(lua_State* L)
+static void lua_pushglobaltable_51(lua_State* L)
 {
 	lua_pushvalue( L, LUA_GLOBALSINDEX_51 );
 }
 
-void lua_pushglobaltable_52(lua_State* L)
+static void lua_pushglobaltable_52(lua_State* L)
 {
 	lua_rawgeti( L, LUA_REGISTRYINDEX_52, LUA_GLOBALSINDEX_52 );
Index: trunk/src/lua/lua_area.cc
===================================================================
--- trunk/src/lua/lua_area.cc	(revision 197)
+++ trunk/src/lua/lua_area.cc	(revision 198)
@@ -34,5 +34,5 @@
 }
 
-void nlua_area_construct( lua_State* L, int sidx )
+static void nlua_area_construct( lua_State* L, int sidx )
 {
 	if ( nlua_is_coord( L, sidx ) )
@@ -412,5 +412,5 @@
 
 
-int luaopen_area( lua_State * L )
+static int luaopen_area( lua_State * L )
 {
 	static const struct luaL_Reg nlua_area_sf [] = {
Index: trunk/src/lua/lua_aux.cc
===================================================================
--- trunk/src/lua/lua_aux.cc	(revision 197)
+++ trunk/src/lua/lua_aux.cc	(revision 198)
@@ -95,5 +95,5 @@
 	if ( dice < 1 )  luaL_argerror( L, 1, "die count lower than 1!" );
 	if ( sides < 1 ) luaL_argerror( L, 2, "side count lower than 1!" );
-	lua_pushnumber( L, nv::random::get().dice( dice, sides ) );
+	lua_pushnumber( L, nv::random::get().dice( static_cast< nv::uint32 >( dice ), static_cast< nv::uint32 >( sides ) ) );
 	return 1;
 }
@@ -111,5 +111,5 @@
 			int arg1 = luaL_checkinteger( L, 1 );
 			if ( arg1 < 1 ) arg1 = 1;
-			lua_pushunsigned( L, nv::random::get().urange( 1, arg1 ) );
+			lua_pushunsigned( L, nv::random::get().urange( 1, static_cast<nv::uint32>( arg1 ) ) );
 		}
 		else
@@ -126,5 +126,5 @@
 static int nluaaux_math_randomseed( lua_State* L )
 {
-	nv::random::get().set_seed( static_cast< nv::uint32 > ( L, 1 ) );
+	nv::random::get().set_seed( lua_tounsigned( L, 1 ) );
 	return 0;
 }
Index: trunk/src/lua/lua_function.cc
===================================================================
--- trunk/src/lua/lua_function.cc	(revision 197)
+++ trunk/src/lua/lua_function.cc	(revision 198)
@@ -11,7 +11,7 @@
 using namespace nv;
 
-lua::function_base::function_base( lua_State* L, const path& a_path, bool global /*= true*/ ) : L(L)
+lua::function_base::function_base( lua_State* a_L, const path& a_path, bool a_global /*= true*/ ) : L(a_L)
 {
-	if ( !a_path.resolve( L, global ) )
+	if ( !a_path.resolve( L, a_global ) )
 	{
 		lua_pop( L, 1 );
@@ -27,5 +27,5 @@
 }
 
-lua::function_base::function_base( const function_base& func ) : L(L)
+lua::function_base::function_base( const function_base& func ) : L(func.L)
 {
 	lua_rawgeti( L, LUA_REGISTRYINDEX, func.m_ref );
Index: trunk/src/lua/lua_map_area.cc
===================================================================
--- trunk/src/lua/lua_map_area.cc	(revision 197)
+++ trunk/src/lua/lua_map_area.cc	(revision 198)
@@ -15,34 +15,34 @@
 typedef nv::flags<512> cell_set;
 
-nv::uint32 nlua_to_cell_id( lua_State* L, int index, nv::map_area* map )
+static nv::uint32 nlua_to_cell_id( lua_State* L, int index, nv::map_area* map )
 {
 	if ( lua_type( L, index ) == LUA_TSTRING ) 
 		return map->string_to_id( lua_tostring( L, index ) );
 	else
-		return (nv::uint32)lua_tointeger( L, index );
-}
-
-cell_set nlua_to_cell_set( lua_State* L, int index, nv::map_area* map )
-{
-	cell_set result;
-	switch ( lua_type( L, index ) )
-	{
-	case LUA_TTABLE :	
-		{
-			lua_pushnil( L );
-			while ( lua_next( L, index ) != 0 )
-			{
-				if ( lua_type( L, -1 ) == LUA_TSTRING )
-					result.set( map->string_to_id( lua_tostring( L, -1 ) ), true );
-				else
-					result.set( lua_tointeger( L, -1 ), true );
-				lua_pop( L, 1 );
-			}
-		} break;
-	case LUA_TSTRING : result.set( map->string_to_id( lua_tostring( L, index ) ), true ); break;
-	case LUA_TNUMBER : result.set( lua_tointeger( L, index ), true ); break;
-	}
-	return result;
-}
+		return lua_tounsigned( L, index );
+}
+
+// static cell_set nlua_to_cell_set( lua_State* L, int index, nv::map_area* map )
+// {
+// 	cell_set result;
+// 	switch ( lua_type( L, index ) )
+// 	{
+// 	case LUA_TTABLE :	
+// 		{
+// 			lua_pushnil( L );
+// 			while ( lua_next( L, index ) != 0 )
+// 			{
+// 				if ( lua_type( L, -1 ) == LUA_TSTRING )
+// 					result.set( map->string_to_id( lua_tostring( L, -1 ) ), true );
+// 				else
+// 					result.set( lua_tounsigned( L, -1 ), true );
+// 				lua_pop( L, 1 );
+// 			}
+// 		} break;
+// 	case LUA_TSTRING : result.set( map->string_to_id( lua_tostring( L, index ) ), true ); break;
+// 	case LUA_TNUMBER : result.set( lua_tounsigned( L, index ), true ); break;
+// 	}
+// 	return result;
+// }
 
 bool nlua_is_map_area( lua_State* L, int index )
@@ -118,5 +118,5 @@
 {
 	nv::map_area* ma = nlua_to_map_area( L, 1 );
-	lua_pushinteger( L, ma->get_cell( nlua_to_coord( L, 2 ) ) );
+	lua_pushunsigned( L, ma->get_cell( nlua_to_coord( L, 2 ) ) );
 	return 1;
 }
@@ -125,5 +125,5 @@
 {
 	nv::map_area* ma = nlua_to_map_area( L, 1 );
-	ma->set_cell( nlua_to_coord( L, 2 ), lua_tointeger( L, 3 ) );
+	ma->set_cell( nlua_to_coord( L, 2 ), lua_tounsigned( L, 3 ) );
 	return 0;
 }
@@ -140,5 +140,5 @@
 	else
 	{
-		lua_pushinteger( L, ma->get_cell( nlua_to_coord( L, 2 ) ) );
+		lua_pushunsigned( L, ma->get_cell( nlua_to_coord( L, 2 ) ) );
 	}
 	return 1;
@@ -148,5 +148,5 @@
 {
 	nv::map_area* ma = nlua_to_map_area( L, 1 );
-	ma->set_cell( nlua_to_coord( L, 2 ), lua_tointeger( L, 3 ) );
+	ma->set_cell( nlua_to_coord( L, 2 ), lua_tounsigned( L, 3 ) );
 	return 0;
 }
@@ -179,5 +179,5 @@
 };
 
-int luaopen_map_area( lua_State * L )
+static int luaopen_map_area( lua_State * L )
 {
 	luaL_newmetatable( L, NLUA_MAP_AREA_METATABLE );
Index: trunk/src/lua/lua_path.cc
===================================================================
--- trunk/src/lua/lua_path.cc	(revision 197)
+++ trunk/src/lua/lua_path.cc	(revision 198)
@@ -23,5 +23,5 @@
 }
 
-lua::path::path( int i )
+lua::path::path( unsigned i )
 	: m_count(0)
 {
@@ -88,5 +88,5 @@
 			else
 			{
-				lua_pushinteger( L, m_elements[i].value );
+				lua_pushunsigned( L, m_elements[i].value );
 			}
 			lua_gettable( L, -2 );
Index: trunk/src/lua/lua_state.cc
===================================================================
--- trunk/src/lua/lua_state.cc	(revision 197)
+++ trunk/src/lua/lua_state.cc	(revision 198)
@@ -257,5 +257,5 @@
 {
 	lua_getfield( L->L, -1, element.c_str() );
-	int result = lua_type( L->L, -1 ) == LUA_TNUMBER ? lua_tounsigned( L->L, -1 ) : defval;
+	unsigned result = lua_type( L->L, -1 ) == LUA_TNUMBER ? lua_tounsigned( L->L, -1 ) : defval;
 	lua_pop( L->L, 1 );
 	return result;
Index: trunk/src/random.cc
===================================================================
--- trunk/src/random.cc	(revision 197)
+++ trunk/src/random.cc	(revision 198)
@@ -47,5 +47,5 @@
 uint32 random::urand( uint32 val )
 {
-	std::uniform_int_distribution<sint32> dist( 0, val - 1 );
+	std::uniform_int_distribution<uint32> dist( 0, val - 1 );
 	return dist( rng );
 }
@@ -65,5 +65,5 @@
 uint32 random::urange( uint32 min, uint32 max )
 {
-	std::uniform_int_distribution<sint32> dist( min, max );
+	std::uniform_int_distribution<uint32> dist( min, max );
 	return dist( rng );
 }