Changeset 2509 for code/branches/buildsystem2

code/branches/buildsystem2

Property svn:ignore deleted

Property svn:mergeinfo changed

merged: 1875,1882-1886,1975-1982,1991,1999,2054,2061,2135,2137-2139,2197-2199,2204,2214-2220,2223-2224,2229,2233-2244,2248-2249,2252-2253,2260,2275

code/branches/buildsystem2/CMakeLists.txt

-                      r1889
+                      r2509
 PROJECT(Orxonox)
+cmake_minimum_required(VERSION 2.4)
+IF (COMMAND cmake_policy)
+  cmake_policy(SET CMP0003 NEW)
+ENDIF (COMMAND cmake_policy)
+# Allow for simple IF constructs (makes code a lot more readable)
+#SET(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6 FATAL_ERROR)
 # This sets where to look for modules (e.g. "Find*.cmake" files)
 SET(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 # Check whether we are on a tardis box
+# Check for special include paths
 INCLUDE(CheckTardis)
+INCLUDE(CheckOrxonoxWinDeps)
+################ Test options ###################
+############## Testing options ##################
+OPTION(ENABLE_TESTS "Enable build tests.")
+IF(ENABLE_TESTS)
+  ENABLE_TESTING()
+ENDIF(ENABLE_TESTS)
+OPTION(TESTING_ENABLED "Do you want to enable Testing")
+IF (TESTING_ENABLED)
+  ENABLE_TESTING()
+ENDIF(TESTING_ENABLED)
+OPTION (NETWORK_TESTING_ENABLED "Do you want to build network testing tools: i.e. chatclient chatserver and alike")
+OPTION (NETWORKTRAFFIC_TESTING_ENABLED "Do you want to build dummyserver4 and dummyclient4")
+OPTION(NETWORK_TESTING_ENABLED "Build network testing tools: i.e. chatclient chatserver and alike.")
+OPTION(NETWORKTRAFFIC_TESTING_ENABLED "Build dummyserver4 and dummyclient4.")
 ########## Compiler/Linker options ##############
+# if on tardis change compiler and reset boost include directory
+IF(IS_TARDIS)
+  MESSAGE("System is a TARDIS: Setting Compiler to g++-4.1.1")
+  # Force-set the compiler on tardis machines, as default points to g++-3.3
+  SET(CMAKE_CXX_COMPILER "g++-4.1.1")
+  # Reset Boost serach path
+  SET(Boost_INCLUDE_DIR "/usr/pack/boost-1.34.1-sd/i686-debian-linux3.1/include")
+ELSE (IS_TARDIS)
+  IF (NOT WIN32)
+    SET(Boost_INCLUDE_DIR "/usr/include/boost")
+  ENDIF (NOT WIN32)
+ENDIF(IS_TARDIS)
+# Set binary output directories
+SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)
+SET(LIBRARY_OUTPUT_PATH    ${PROJECT_BINARY_DIR}/bin)
+MARK_AS_ADVANCED(EXECUTABLE_OUTPUT_PATH LIBRARY_OUTPUT_PATH)
+# Set binary output directories
+SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)
+SET(LIBRARY_OUTPUT_PATH    ${PROJECT_SOURCE_DIR}/bin/lib)
+# Global compiler/linker flags. force -O2!
+SET(CMAKE_C_FLAGS "$ENV{CFLAGS} -O0 -Wall -g -ggdb")
+SET(CMAKE_CXX_FLAGS "$ENV{CXXFLAGS} -O0 -Wall -g -ggdb")
+#SET(CMAKE_C_FLAGS "$ENV{CFLAGS} -O3 -s")
+#SET(CMAKE_CXX_FLAGS "$ENV{CXXFLAGS} -O3 -s")
+# Compiler/Linker flags.
+IF(NOT CMAKE_BUILD_TYPE)
+  SET(CMAKE_BUILD_TYPE "Debug")
+ENDIF(NOT CMAKE_BUILD_TYPE)
+SET(CMAKE_C_FLAGS   "$ENV{CFLAGS}   -Wall -Wextra -Wno-unused-parameter")
+SET(CMAKE_CXX_FLAGS "$ENV{CXXFLAGS} -Wall -Wextra -Wno-unused-parameter")
+SET(CMAKE_C_FLAGS_DEBUG            "-g -ggdb")
+SET(CMAKE_CXX_FLAGS_DEBUG          "-g -ggdb")
+SET(CMAKE_C_FLAGS_RELEASE          "-O3 -DNDEBUG")
+SET(CMAKE_CXX_FLAGS_RELEASE        "-O3 -DNDEBUG")
+SET(CMAKE_C_FLAGS_RELWITHDEBINFO   "-O2 -DNDEBUG -g -ggdb")
+SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -DNDEBUG -g -ggdb")
+SET(CMAKE_C_FLAGS_MINSIZEREL       "-Os -DNDEBUG")
+SET(CMAKE_CXX_FLAGS_MINSIZEREL     "-Os -DNDEBUG")
 SET(CMAKE_LD_FLAGS "$ENV{LDFLAGS}")
 …
 SET(CMAKE_MODULE_LINKER_FLAGS " --no-undefined")
-# Use 'cmake -D make_verb:1 path' to get verbose make output when compiling
-IF (MAKE_VERB)
- SET(CMAKE_VERBOSE_MAKEFILE TRUE)
-ENDIF (MAKE_VERB)
 ############### Library finding #################
+# Uncomment the following line if you want the include and library paths to be shown
+# Alternatively use the "-D VERBOSE_FIND:BOOL=true" option when executing cmake
+# Performs the search and sets the variables
+FIND_PACKAGE(OGRE REQUIRED)
+FIND_PACKAGE(CEGUI REQUIRED)
+# CEGUI_OGRE included in source
+#FIND_PACKAGE(CEGUI_OGRE REQUIRED)
+FIND_PACKAGE(ENet REQUIRED)
+FIND_PACKAGE(Boost 1.34 REQUIRED thread filesystem)
+FIND_PACKAGE(OpenAL REQUIRED)
+FIND_PACKAGE(ALUT REQUIRED)
+FIND_PACKAGE(OggVorbis REQUIRED)
+FIND_PACKAGE(ZLIB REQUIRED)
+FIND_PACKAGE(DirectX REQUIRED)
+FIND_PACKAGE(Lua50 REQUIRED)
+#FIND_PACKAGE(Lua51 QUIET)
+# SET (VERBOSE_FIND true)
+# Set the library directory when using precompiled tarballs for the dependencies under windows
+IF (WIN32)
+  IF (MSVC)
+    IF ($ENV{ORXONOX_DEV})
+      SET (DEPENDENCY_DIR ${CMAKE_SOURCE_DIR}/../lib_dist/dependencies/)
+    ELSE ($ENV{ORXONOX_DEV})
+      SET (DEPENDENCY_DIR ${CMAKE_SOURCE_DIR}/dependencies/)
+    ENDIF ($ENV{ORXONOX_DEV})
+    SET(Boost_LIB_SUFFIX_DEBUG vc80-mt-gd-1_35)
+  ENDIF (MSVC)
+ENDIF (WIN32)
+MESSAGE(STATUS ${DEPENDENCY_DIR})
+# Performs the search and sets the variables
+FIND_PACKAGE(OGRE)
+FIND_PACKAGE(CEGUI)
+# FIND_PACKAGE(CEGUI_OGRE)
+FIND_PACKAGE(ENet)
+FIND_PACKAGE(Boost REQUIRED thread filesystem)
+FIND_PACKAGE(OpenAL)
+FIND_PACKAGE(ALUT)
+FIND_PACKAGE(OggVorbis)
+FIND_PACKAGE(ZLIB)
+#FIND_PACKAGE(Lua)
+FIND_PACKAGE(TCL)
+FIND_PACKAGE(DirectX)
+# Set the search paths for the linking
+LINK_DIRECTORIES(
+  ${OGRE_LIB_DIR}
+  ${CEGUI_LIB_DIR}
+#  ${CEGUI_SCRIPT_LIB_DIR}
+#  ${CEGUI_OGRE_LIB_DIR}
+  ${ENet_LIBRARY}
+  ${Boost_LIBRARY_DIRS}
+  ${Zlib_LIBRARY_DIR}
+  ${TCL_LIBRARY}
+)
+# Set the search paths for include files
+INCLUDE_DIRECTORIES(
+  ${OGRE_INCLUDE_DIR}
+  ${CEGUI_INCLUDE_DIR}
+#  ${CEGUI_OGRE_INCLUDE_DIR}
+  ${ENet_INCLUDE_DIR}
+  ${Boost_INCLUDE_DIRS}
+  ${OPENAL_INCLUDE_DIR}
+  ${ALUT_INCLUDE_DIR}
+  ${VORBIS_INCLUDE_DIR}
+  ${OGG_INCLUDE_DIR}
+#  ${Lua_INCLUDE_DIR}
+  ${TCL_INCLUDE_PATH}
+  ${DirectX_INCLUDE_DIR}
+  ${ZLIB_INCLUDE_DIR}
+)
+#don't require the whole tcl rat tail
+FIND_PACKAGE(TCL QUIET)
+IF(NOT TCL_FOUND)
+    MESSAGE(FATAL_ERROR "Tcl not found.")
+ENDIF(NOT TCL_FOUND)
 # Add main source dir
 ADD_SUBDIRECTORY(src)
+ADD_SUBDIRECTORY(bin)

code/branches/buildsystem2/cmake/CheckTardis.cmake

-                      r1505
+                      r2509
 # only run this test on a lunix/unix machine
 IF (UNIX)
   FIND_PROGRAM(UNAME_CMD "uname"
   PATHS "/usr/bin /bin")
 …
 ENDIF (UNIX)
+MARK_AS_ADVANCED(IS_TARDIS)
+IF (IS_TARDIS)
+  MESSAGE(STATUS "Running on D-ITET isg.ee Tardis Computer. Using customized paths.")
+  SET(CMAKE_C_COMPILER "gcc-4.1")
+  SET(CMAKE_CXX_COMPILER "g++-4.1")
+  #SET(Boost_ADDITIONAL_VERSIONS "1.36")
+  SET(BOOST_INCLUDEDIR "/usr/pack/boost-1.34.1-sd/include")
+  SET(BOOST_LIBRARYDIR "/usr/pack/boost-1.34.1-sd/i686-debian-linux3.1/lib")
+  SET(ENV{LUA_DIR} "/usr/pack/lua-5.0.3-sd;/usr/pack/lua-5.0.3-sd/i686-debian-linux3.1")
+  SET(ENV{ALUTDIR} "/usr/pack/openal-0.0.8-cl;/usr/pack/openal-0.0.8-cl/i686-debian-linux3.1")
+  SET(ENV{OPENALDIR} "/usr/pack/openal-0.0.8-cl;/usr/pack/openal-0.0.8-cl/i686-debian-linux3.1")
+  SET(ENV{ENETDIR} "/usr/pack/enet-2007-sd;/usr/pack/enet-2007-sd/i686-debian-linux3.1")
+  SET(ENV{OGGVORBISDIR} "/usr/pack/oggvorbis-1.0-ds;/usr/pack/oggvorbis-1.0-ds/i686-debian-linux3.0")
+  #SET(TCL_INCLUDE_PATH "/usr/pack/tcltk-8.4.9.linux-mo/include")
+  SET(ENV{CEGUIDIR} "/usr/pack/cegui-0.5.0-sd;/usr/pack/cegui-0.5.0-sd/i686-debian-linux3.1")
+  SET(ENV{OGREDIR} "/usr/pack/ogre-1.4.5-sd;/usr/pack/ogre-1.4.5-sd/i686-debian-linux3.1")
+ENDIF (IS_TARDIS)
+MARK_AS_ADVANCED(UNAME_CMD IS_TARDIS)

code/branches/buildsystem2/cmake/FindALUT.cmake

-                      r1872
+                      r2509
+#
 # Several changes and additions by Fabian 'x3n' Landau
+# Some simplifications by Adrian Friedli
 #                 > www.orxonox.net <
-IF (ALUT_LIBRARY AND ALUT_INCLUDE_DIR)
-  SET (ALUT_FIND_QUIETLY TRUE)
-ENDIF (ALUT_LIBRARY AND ALUT_INCLUDE_DIR)
 FIND_PATH(ALUT_INCLUDE_DIR AL/alut.h
+  $ENV{ALUTDIR}/include
+  ~/Library/Frameworks/OpenAL.framework/Headers
+  /Library/Frameworks/OpenAL.framework/Headers
+  /System/Library/Frameworks/OpenAL.framework/Headers # Tiger
+  /usr/pack/openal-0.0.8-cl/include # Tardis specific hack
+  /usr/local/include/
+  /usr/local/include/OpenAL
+  /usr/local/include
+  /usr/include/
+  /usr/include/OpenAL
+  /usr/include
+  /sw/include/ # Fink
+  /sw/include/OpenAL
+  /sw/include
+  /opt/local/include/AL # DarwinPorts
+  /opt/local/include/OpenAL
+  /opt/local/include
+  /opt/csw/include/ # Blastwave
+  /opt/csw/include/OpenAL
+  /opt/csw/include
+  /opt/include/
+  /opt/include/OpenAL
+  /opt/include
+  ../libs/freealut-1.1.0/include
+  ${DEPENDENCY_DIR}/freealut-1.1.0/include
+  PATHS
+  $ENV{ALUTDIR}
+  ~/Library/Frameworks/OpenAL.framework
+  /Library/Frameworks/OpenAL.framework
+  /System/Library/Frameworks/OpenAL.framework # Tiger
+  /usr/local
+  /usr
+  /sw # Fink
+  /opt/local # DarwinPorts
+  /opt/csw # Blastwave
+  /opt
+  PATH_SUFFIXES include include/OpenAL include/AL Headers
+  )
 …
     NAMES alut
     PATHS
+    $ENV{ALUTDIR}/lib
+    $ENV{ALUTDIR}/libs
+    /usr/pack/openal-0.0.8-cl/i686-debian-linux3.1/lib
+    /usr/local/lib
+    /usr/lib
+    /sw/lib
+    /opt/local/lib
+    /opt/csw/lib
+    /opt/lib
+    ../libs/freealut-1.1.0/src/.libs
+    ../libs/freealut-1.1.0/lib
+    ${DEPENDENCY_DIR}/freealut-1.1.0/lib
+    $ENV{ALUTDIR}
+    /usr/local
+    /usr
+    /sw
+    /opt/local
+    /opt/csw
+    /opt
+    PATH_SUFFIXES lib libs
+    )
 ENDIF(${ALUT_INCLUDE_DIR} MATCHES ".framework")
+SET (ALUT_FOUND "NO")
+IF (ALUT_LIBRARY AND ALUT_INCLUDE_DIR)
+  SET (ALUT_FOUND "YES")
+  IF (NOT ALUT_FIND_QUIETLY)
+    MESSAGE (STATUS "FreeAlut was found.")
+    IF (VERBOSE_FIND)
+      MESSAGE (STATUS "  include path: ${ALUT_INCLUDE_DIR}")
+      MESSAGE (STATUS "  library path: ${ALUT_LIBRARY}")
+      MESSAGE (STATUS "  libraries:    alut")
+    ENDIF (VERBOSE_FIND)
+  ENDIF (NOT ALUT_FIND_QUIETLY)
+ELSE (ALUT_LIBRARY AND ALUT_INCLUDE_DIR)
+  IF (NOT ALUT_INCLUDE_DIR)
+    MESSAGE (SEND_ERROR "FreeAlut include path was not found.")
+  ENDIF (NOT ALUT_INCLUDE_DIR)
+  IF (NOT ALUT_LIBRARY)
+    MESSAGE (SEND_ERROR "FreeAlut library was not found.")
+  ENDIF (NOT ALUT_LIBRARY)
+ENDIF (ALUT_LIBRARY AND ALUT_INCLUDE_DIR)
+# handle the QUIETLY and REQUIRED arguments and set ALUT_FOUND to TRUE if
+# all listed variables are TRUE
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(ALUT DEFAULT_MSG ALUT_LIBRARY ALUT_INCLUDE_DIR)
+MARK_AS_ADVANCED(ALUT_LIBRARY ALUT_INCLUDE_DIR)

code/branches/buildsystem2/cmake/FindCEGUI.cmake

-                      r1872
+                      r2509
 # This module defines
 #  CEGUI_INCLUDE_DIR
+#  CEGUI_LIBRARIES, the libraries to link against to use CEGUI.
+#  CEGUI_LIB_DIR, the location of the libraries
+#  CEGUI_LIBRARY, the library to link against to use CEGUI.
 #  CEGUI_FOUND, If false, do not try to use CEGUI
+#
 …
+#
 # Several changes and additions by Fabian 'x3n' Landau
+# Lots of simplifications by Adrian Friedli
 #                 > www.orxonox.net <
+IF (CEGUI_LIBRARIES AND CEGUI_INCLUDE_DIR AND CEGUI_LIB_DIR)# AND CEGUI_SCRIPT_LIBRARIES)
+    SET(CEGUI_FIND_QUIETLY TRUE) # Already in cache, be silent
+ENDIF (CEGUI_LIBRARIES AND CEGUI_INCLUDE_DIR AND CEGUI_LIB_DIR)# AND CEGUI_SCRIPT_LIBRARIES)
+# TODO: Determine CEGUI version
+IF (WIN32) #Windows
+    FIND_PATH(CEGUI_INCLUDE_DIR CEGUI.h
+        ../libs/cegui-0.6.1/include
+        ${DEPENDENCY_DIR}/cegui-0.6.1/include
+    )
+FIND_PATH(CEGUI_INCLUDE_DIR CEGUI.h
+    PATHS
+    $ENV{CEGUIDIR}
+    /usr/local
+    /usr
+    PATH_SUFFIXES include include/CEGUI
+)
+    SET(CEGUI_LIBRARIES debug CEGUIBase_d optimized CEGUIBase)
+    FIND_LIBRARY(CEGUI_LIBDIR NAMES ${CEGUI_LIBRARIES} PATHS
+        ../libs/cegui-0.6.1/bin
+        ${DEPENDENCY_DIR}/cegui-0.6.1/lib
+    )
+    # Strip the filename from the path
+    IF (CEGUI_LIBDIR)
+        GET_FILENAME_COMPONENT(CEGUI_LIBDIR ${CEGUI_LIBDIR} PATH)
+        SET (CEGUI_LIB_DIR ${CEGUI_LIBDIR} CACHE FILEPATH "")
+    ENDIF (CEGUI_LIBDIR)
+#SET(CEGUI_LIBRARIES debug CEGUIBase_d optimized CEGUIBase)
+FIND_LIBRARY(CEGUI_LIBRARY
+    NAMES CEGUIBase
+    PATHS
+    $ENV{CEGUIDIR}
+    /usr/local
+    /usr
+    PATH_SUFFIXES lib
+)
 #    IF (NOT CEGUI_SCRIPT_LIBDIR)
 …
 #    ENDIF (NOT CEGUI_SCRIPT_LIBDIR)
+#    # Strip the filename from the path
+#    IF (CEGUI_SCRIPT_LIBDIR)
+#        GET_FILENAME_COMPONENT(CEGUI_SCRIPT_LIBDIR ${CEGUI_SCRIPT_LIBDIR} PATH)
+#        SET (CEGUI_SCRIPT_LIB_DIR ${CEGUI_SCRIPT_LIBDIR} CACHE FILEPATH "")
+#    ENDIF (CEGUI_SCRIPT_LIBDIR)
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(CEGUI DEFAULT_MSG
+    CEGUI_LIBRARY
+    CEGUI_INCLUDE_DIR
+    #CEGUI_SCRIPT_LIBRARIES
+)
+ELSE (WIN32) #Unix
+    FIND_PACKAGE(PkgConfig)
+    PKG_SEARCH_MODULE(CEGUI CEGUI /usr/pack/cegui-0.5.0-sd/i686-debian-linux3.1/lib/pkgconfig/CEGUI.pc) # tardis specific hack
+    SET(CEGUI_INCLUDE_DIR ${CEGUI_INCLUDE_DIRS})
+    SET(CEGUI_LIB_DIR ${CEGUI_LIBDIR})
+    SET(CEGUI_LIBRARIES ${CEGUI_LIBRARIES} CACHE STRING "")
+#    SET(CEGUI_SCRIPT_LIBRARIES "CEGUILuaScriptModule")
+#    SET(CEGUI_SCRIPT_LIB_DIR)
+ENDIF (WIN32)
+IF (CEGUI_INCLUDE_DIR AND CEGUI_LIBRARIES AND CEGUI_LIB_DIR)# AND CEGUI_SCRIPT_LIBRARIES)
+    SET(CEGUI_FOUND TRUE)
+    #Do some preparation
+    SEPARATE_ARGUMENTS(CEGUI_INCLUDE_DIR)
+    SEPARATE_ARGUMENTS(CEGUI_LIBRARIES)
+    SET(CEGUI_INCLUDE_DIR ${CEGUI_INCLUDE_DIR} CACHE PATH "")
+    SET(CEGUI_LIBRARIES ${CEGUI_LIBRARIES} CACHE STRING "")
+    SET(CEGUI_LIB_DIR ${CEGUI_LIB_DIR} CACHE PATH "")
+#    SET(CEGUI_SCRIPT_LIBRARIES ${CEGUI_SCRIPT_LIBRARIES} CACHE PATH "")
+ENDIF (CEGUI_INCLUDE_DIR AND CEGUI_LIBRARIES AND CEGUI_LIB_DIR)# AND CEGUI_SCRIPT_LIBRARIES)
+IF (CEGUI_FOUND)
+    IF (NOT CEGUI_FIND_QUIETLY)
+        MESSAGE(STATUS "CEGUI was found.")
+        IF (VERBOSE_FIND)
+            MESSAGE (STATUS "  include path: ${CEGUI_INCLUDE_DIR}")
+            MESSAGE (STATUS "  library path: ${CEGUI_LIB_DIR}")
+            MESSAGE (STATUS "  libraries:    ${CEGUI_LIBRARIES}")
+#            MESSAGE (STATUS "           :    ${CEGUI_SCRIPT_LIBRARIES}")
+        ENDIF (VERBOSE_FIND)
+    ENDIF (NOT CEGUI_FIND_QUIETLY)
+ELSE (CEGUI_FOUND)
+    IF (NOT CEGUI_INCLUDE_DIR)
+        MESSAGE(SEND_ERROR "CEGUI include path was not found.")
+    ENDIF (NOT CEGUI_INCLUDE_DIR)
+    IF (NOT CEGUI_LIB_DIR)
+        MESSAGE(SEND_ERROR "CEGUI library was not found.")
+    ENDIF (NOT CEGUI_LIB_DIR)
+    IF (NOT CEGUI_LIBRARIES)
+        MESSAGE(SEND_ERROR "CEGUI libraries not known.")
+    ENDIF (NOT CEGUI_LIBRARIES)
+#    IF (NOT CEGUI_SCRIPT_LIBRARIES)
+#        MESSAGE(SEND_ERROR "CEGUI Lua script module was not found.")
+#    ENDIF (NOT CEGUI_SCRIPT_LIBRARIES)
+ENDIF (CEGUI_FOUND)
+MARK_AS_ADVANCED(
+    CEGUI_LIBRARY
+    CEGUI_INCLUDE_DIR
+    #CEGUI_SCRIPT_LIBRARIES
+)

code/branches/buildsystem2/cmake/FindENet.cmake

-                      r1872
+                      r2509
+#
 #  ENET_FOUND - system has enet
+#  ENET_INCLUDE_DIR - the enet include directory
+#  ENET_LIBRARIES - the libraries needed to use enet
+#  ENET_DEFINITIONS - Compiler switches required for using enet
+#  ENet_INCLUDE_DIR - the enet include directory
+#  ENet_LIBRARIES - the libraries needed to use enet
+#
+# $ENETDIR is an environment variable used for finding enet.
+#
 #  Borrowed from The Mana World
 …
+#
 # Several changes and additions by Fabian 'x3n' Landau
+# Lots of simplifications by Adrian Friedli
 #                 > www.orxonox.net <
-IF (ENet_INCLUDE_DIR AND ENet_LIBRARY)
-   SET(ENet_FIND_QUIETLY TRUE)
-ENDIF (ENet_INCLUDE_DIR AND ENet_LIBRARY)
 FIND_PATH(ENet_INCLUDE_DIR enet/enet.h
     /usr/include
     /usr/local/include
     /usr/pack/enet-2007-sd/include
     ../libs/enet-1.1/include
     ${DEPENDENCY_DIR}/enet-1.2/include
+    PATHS
+    $ENV{ENETDIR}
+    /usr/local
+    /usr
+    PATH_SUFFIXES include
+    )
 FIND_LIBRARY(ENet_LIBRARY
     NAMES enet
+    PATHS /usr/lib /usr/local/lib /usr/pack/enet-2007-sd/i686-debian-linux3.1/lib/
+    ../libs/enet-1.1
+    ${DEPENDENCY_DIR}/enet-1.2/lib
+    PATHS
+    $ENV{ENETDIR}
+    /usr/local
+    /usr
+    PATH_SUFFIXES lib
+    )
+SET(ENET_FOUND FALSE)
+IF (ENet_INCLUDE_DIR AND ENet_LIBRARY)
     SET(ENET_FOUND TRUE)
     SET(ENET_INCLUDE_DIR ${ENet_INCLUDE_DIR})
+# handle the QUIETLY and REQUIRED arguments and set ENET_FOUND to TRUE if
+# all listed variables are TRUE
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(ENet DEFAULT_MSG ENet_LIBRARY ENet_INCLUDE_DIR)
+IF (ENET_FOUND)
     IF(WIN32)
         SET(WINDOWS_ENET_DEPENDENCIES "ws2_32;winmm")
+        SET(ENet_LIBRARY ${ENet_LIBRARY} ${WINDOWS_ENET_DEPENDENCIES})
+        SET(ENet_LIBRARIES ${ENet_LIBRARY} ${WINDOWS_ENET_DEPENDENCIES})
+    ELSE(WIN32)
+        SET(ENet_LIBRARIES ${ENet_LIBRARY})
     ENDIF(WIN32)
-    SET(ENET_LIBRARIES ${ENet_LIBRARY})
-ENDIF (ENet_INCLUDE_DIR AND ENet_LIBRARY)
-IF (ENET_FOUND)
-    IF (NOT ENet_FIND_QUIETLY)
-        MESSAGE(STATUS "ENet was found.")
-        IF (VERBOSE_FIND)
-            MESSAGE (STATUS "  include path: ${ENet_INCLUDE_DIR}")
-            MESSAGE (STATUS "  library path: ${ENet_LIBRARY}")
-            MESSAGE (STATUS "  libraries:    enet")
-        ENDIF (VERBOSE_FIND)
-    ENDIF (NOT ENet_FIND_QUIETLY)
-ELSE (ENET_FOUND)
-    IF (NOT ENet_INCLUDE_DIR)
-        MESSAGE(SEND_ERROR "ENet include path was not found.")
-    ENDIF (NOT ENet_INCLUDE_DIR)
-    IF (NOT ENet_LIBRARY)
-        MESSAGE(SEND_ERROR "ENet library was not found.")
-    ENDIF (NOT ENet_LIBRARY)
 ENDIF (ENET_FOUND)
 MARK_AS_ADVANCED(ENet_INCLUDE_DIR ENet_LIBRARY)
+MARK_AS_ADVANCED(ENet_LIBRARY ENet_INCLUDE_DIR)

code/branches/buildsystem2/cmake/FindOGRE.cmake

-                      r1872
+                      r2509
 # This module defines
 #  OGRE_INCLUDE_DIR
+#  OGRE_LIBRARIES, the libraries to link against to use OGRE.
+#  OGRE_LIB_DIR, the location of the libraries
+#  OGRE_LIBRARY, the library to link against to use OGRE.
 #  OGRE_FOUND, If false, do not try to use OGRE
+#
 …
+#
 # Several changes and additions by Fabian 'x3n' Landau
+# Lots of simplifications by Adrian Friedli
 #                 > www.orxonox.net <
+IF (OGRE_LIBRARIES AND OGRE_INCLUDE_DIR AND OGRE_LIB_DIR)
+    SET (OGRE_FIND_QUIETLY TRUE) # Already in cache, be silent
+ENDIF (OGRE_LIBRARIES AND OGRE_INCLUDE_DIR AND OGRE_LIB_DIR)
+FIND_PATH(OGRE_INCLUDE_DIR Ogre.h
+    PATHS
+    $ENV{OGREDIR}
+    /usr/local
+    /usr
+    PATH_SUFFIXES include include/OGRE
+)
+IF (WIN32) #Windows
+    FIND_PATH(OGRE_INCLUDE_DIR Ogre.h
+        ../libs/ogre/OgreMain/include
+        ${DEPENDENCY_DIR}/ogre-1.4.9/include
+    )
+#SET(OGRE_LIBRARIES debug OgreMain_d optimized OgreMain)
+FIND_LIBRARY(OGRE_LIBRARY
+    NAMES OgreMain
+    PATHS
+    $ENV{OGREDIR}
+    /usr/local
+    /usr
+    PATH_SUFFIXES lib
+)
     SET(OGRE_LIBRARIES debug OgreMain_d optimized OgreMain)
+    FIND_LIBRARY(OGRE_LIBDIR NAMES ${OGRE_LIBRARIES} PATHS
         ../libs/ogre/Samples/Common/bin/Release
         ${DEPENDENCY_DIR}/ogre-1.4.9/lib
+    )
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(OGRE DEFAULT_MSG
+    OGRE_LIBRARY
+    OGRE_INCLUDE_DIR
+)
+    # Strip the filename from the path
+    IF (OGRE_LIBDIR)
+        GET_FILENAME_COMPONENT(OGRE_LIBDIR ${OGRE_LIBDIR} PATH)
+        SET (OGRE_LIB_DIR ${OGRE_LIBDIR} CACHE FILEPATH "")
+    ENDIF (OGRE_LIBDIR)
+ELSE (WIN32) #Unix
+    FIND_PACKAGE(PkgConfig)
+    PKG_SEARCH_MODULE(OGRE OGRE /usr/pack/ogre-1.4.5-sd/i686-debian-linux3.1/lib/pkgconfig/OGRE.pc) # tardis specific hack
+    SET(OGRE_INCLUDE_DIR ${OGRE_INCLUDE_DIRS})
+    SET(OGRE_LIB_DIR ${OGRE_LIBDIR})
+    SET(OGRE_LIBRARIES ${OGRE_LIBRARIES})
+ENDIF (WIN32)
+#Do some preparation
+SEPARATE_ARGUMENTS(OGRE_INCLUDE_DIR)
+SEPARATE_ARGUMENTS(OGRE_LIBRARIES)
+SET (OGRE_INCLUDE_DIR ${OGRE_INCLUDE_DIR} CACHE PATH "")
+SET (OGRE_LIBRARIES ${OGRE_LIBRARIES} CACHE STRING "")
+SET (OGRE_LIB_DIR ${OGRE_LIB_DIR} CACHE PATH "")
+IF (OGRE_INCLUDE_DIR AND OGRE_LIBRARIES AND OGRE_LIB_DIR)
+    SET(OGRE_FOUND TRUE)
+ENDIF (OGRE_INCLUDE_DIR AND OGRE_LIBRARIES AND OGRE_LIB_DIR)
+IF (OGRE_FOUND)
+    IF (NOT OGRE_FIND_QUIETLY)
+        MESSAGE(STATUS "Ogre was found.")
+        IF (VERBOSE_FIND)
+            MESSAGE (STATUS "  include path: ${OGRE_INCLUDE_DIR}")
+            MESSAGE (STATUS "  library path: ${OGRE_LIB_DIR}")
+            MESSAGE (STATUS "  libraries:    ${OGRE_LIBRARIES}")
+        ENDIF (VERBOSE_FIND)
+    ENDIF (NOT OGRE_FIND_QUIETLY)
+ELSE (OGRE_FOUND)
+    IF (NOT OGRE_INCLUDE_DIR)
+        MESSAGE(SEND_ERROR "Ogre include path was not found.")
+    ENDIF (NOT OGRE_INCLUDE_DIR)
+    IF (NOT OGRE_LIB_DIR)
+        MESSAGE(SEND_ERROR "Ogre library was not found.")
+    ENDIF (NOT OGRE_LIB_DIR)
+    IF (NOT OGRE_LIBRARIES)
+        MESSAGE(SEND_ERROR "Ogre libraries not known.")
+    ENDIF (NOT OGRE_LIBRARIES)
+ENDIF (OGRE_FOUND)
+MARK_AS_ADVANCED(
+    OGRE_LIBRARY
+    OGRE_INCLUDE_DIR
+)

code/branches/buildsystem2/cmake/FindOggVorbis.cmake

-                      r1873
+                      r2509
+# - Try to find ogg/vorbis
+# Once done this will define
+#
+#  OGG_FOUND - system has ogg
+#  OGG_INCLUDE_DIR
+#  OGG_LIBRARY
+#  VORBIS_FOUND - system has vorbis
+#  VORBIS_INCLUDE_DIR
+#  VORBIS_LIBRARY
+#  VORBISENC_LIBRARY
+#  VORBISFILE_LIBRARY
+#
+# $OGGVORBISDIR is an environment variable used for finding ogg/vorbis.
+#
 # Several changes and additions by Fabian 'x3n' Landau
+# Most of all rewritten by Adrian Friedli
 #                 > www.orxonox.net <
+IF (OGG_INCLUDE_DIR AND OGG_LIBRARY)
+  SET(OGG_FIND_QUIETLY TRUE)
+ENDIF (OGG_INCLUDE_DIR AND OGG_LIBRARY)
+IF (VORBIS_INCLUDE_DIR AND VORBIS_LIBRARY AND VORBISENC_LIBRARY AND VORBISFILE_LIBRARY)
+  SET(VORBIS_FIND_QUIETLY TRUE)
+ENDIF (VORBIS_INCLUDE_DIR AND VORBIS_LIBRARY AND VORBISENC_LIBRARY AND VORBISFILE_LIBRARY)
+#SET(OGGVORBIS_LIBRARY_DIR "/usr/pack/oggvorbis-1.0-ds/i686-debian-linux3.0/lib")
+#SET(OGGVORBIS_LIBRARY "-L ${OGGVORBIS_LIBRARY_DIR} -lvorbisenc -lvorbisfile -logg -lvorbis ")
+#SET(OGGVORBIS_INCLUDE_DIR "/usr/pack/oggvorbis-1.0-ds/i686-debian-linux3.0/include")
+#
+# Includes
+#
+SET(OGG_SEARCH_PATHS
+  $ENV{OGGVORBISDIR}
+  /usr/local
+  /usr
+  /sw
+  /opt/local
+  /opt/csw
+  /opt
+)
 FIND_PATH(OGG_INCLUDE_DIR ogg/ogg.h
+  /usr/pack/oggvorbis-1.0-ds/i686-debian-linux3.0/include               # Tardis specific hack
+  /usr/local/include
+  /usr/include
+  /sw/include
+  /opt/local/include
+  /opt/csw/include
+  /opt/csw/include
+  /opt/include
+  ../libs/libogg-1.1.3/include
+  ${DEPENDENCY_DIR}/libogg-1.1.3/include
+  )
+  PATHS ${OGG_SEARCH_PATHS}
+  PATH_SUFFIXES include
+)
 FIND_PATH(VORBIS_INCLUDE_DIR vorbis/codec.h
+  /usr/pack/oggvorbis-1.0-ds/i686-debian-linux3.0/include               # Tardis specific hack
+  /usr/local/include
+  /usr/include
+  /sw/include
+  /opt/local/include
+  /opt/csw/include
+  /opt/csw/include
+  /opt/include
+  ../libs/libvorbis-1.2.0/include
+  ${DEPENDENCY_DIR}/libvorbis-1.2.0/include
+  )
+  PATHS ${OGG_SEARCH_PATHS}
+  PATH_SUFFIXES include
+)
+#
+# Libs
+#
+FIND_LIBRARY(OGG_LIBRARY NAMES ogg
+  PATHS ${OGG_SEARCH_PATHS}
+  PATH_SUFFIXES lib
+)
+FIND_LIBRARY(OGG_LIBRARY
+  NAMES ogg
+  PATHS
+  /usr/pack/oggvorbis-1.0-ds/i686-debian-linux3.1/lib
+  /usr/local/lib
+  /usr/lib
+  /sw/lib
+  /opt/local/lib
+  /opt/csw/lib
+  /opt/lib
+  ../libs/libogg-1.1.3/src/.libs
+  ${DEPENDENCY_DIR}/libogg-1.1.3/lib
+  )
+FIND_LIBRARY(VORBIS_LIBRARY NAMES vorbis
+  PATHS ${OGG_SEARCH_PATHS}
+  PATH_SUFFIXES lib
+)
+FIND_LIBRARY(VORBIS_LIBRARY
+  NAMES vorbis
+  PATHS
+  /usr/pack/oggvorbis-1.0-ds/i686-debian-linux3.1/lib
+  /usr/local/lib
+  /usr/lib
+  /sw/lib
+  /opt/local/lib
+  /opt/csw/lib
+  /opt/lib
+  ../libs/libvorbis-1.2.0/lib/.libs
+  ${DEPENDENCY_DIR}/libvorbis-1.2.0/lib
+  )
+#FIND_LIBRARY(VORBISENC_LIBRARY NAMES vorbisenc
+#  PATHS ${OGG_SEARCH_PATHS}
+#  PATH_SUFFIXES lib
+#)
+#FIND_LIBRARY(VORBISENC_LIBRARY
+#  NAMES vorbisenc
+#  PATHS
+#  /usr/pack/oggvorbis-1.0-ds/i686-debian-linux3.1/lib
+#  /usr/local/lib
+#  /usr/lib
+#  /sw/lib
+#  /opt/local/lib
+#  /opt/csw/lib
+#  /opt/lib
+#  ../libs/libvorbis-1.2.0/lib/.libs
+#  )
+FIND_LIBRARY(VORBISFILE_LIBRARY NAMES vorbisfile
+  PATHS ${OGG_SEARCH_PATHS}
+  PATH_SUFFIXES lib
+)
+FIND_LIBRARY(VORBISFILE_LIBRARY
+  NAMES vorbisfile
+  PATHS
+  /usr/pack/oggvorbis-1.0-ds/i686-debian-linux3.1/lib
+  /usr/local/lib
+  /usr/lib
+  /sw/lib
+  /opt/local/lib
+  /opt/csw/lib
+  /opt/lib
+  ../libs/libvorbis-1.2.0/lib/.libs
+  ${DEPENDENCY_DIR}/libvorbis-1.2.0/lib
+  )
+# handle the QUIETLY and REQUIRED arguments and set *_FOUND to TRUE if
+# all listed variables are TRUE
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(OGG DEFAULT_MSG OGG_LIBRARY OGG_INCLUDE_DIR)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(VORBIS DEFAULT_MSG
+  VORBIS_LIBRARY
+  VORBISFILE_LIBRARY
+  #VORBISENC_LIBRARY
+  VORBIS_INCLUDE_DIR
+)
+SET (OGG_FOUND "NO")
+IF (OGG_INCLUDE_DIR AND OGG_LIBRARY)
+  SET (OGG_FOUND "YES")
+  IF (NOT OGG_FIND_QUIETLY)
+    MESSAGE (STATUS "Ogg was found.")
+    IF (VERBOSE_FIND)
+      MESSAGE (STATUS "  include path: ${OGG_INCLUDE_DIR}")
+      MESSAGE (STATUS "  library path: ${OGG_LIBRARY}")
+      MESSAGE (STATUS "  libraries:    ogg")
+    ENDIF (VERBOSE_FIND)
+  ENDIF (NOT OGG_FIND_QUIETLY)
+ELSE (OGG_INCLUDE_DIR AND OGG_LIBRARY)
+  IF (NOT OGG_INCLUDE_DIR)
+    MESSAGE (SEND_ERROR "Ogg include path was not found.")
+  ENDIF (NOT OGG_INCLUDE_DIR)
+  IF (NOT OGG_LIBRARY)
+    MESSAGE (SEND_ERROR "Ogg library was not found.")
+  ENDIF (NOT OGG_LIBRARY)
+ENDIF (OGG_INCLUDE_DIR AND OGG_LIBRARY)
+SET (VORBIS_FOUND "NO")
+IF (VORBIS_INCLUDE_DIR AND VORBIS_LIBRARY AND VORBISFILE_LIBRARY)# AND VORBISENC_LIBRARY)
+  SET (VORBIS_FOUND "YES")
+  IF (NOT VORBIS_FIND_QUIETLY)
+    MESSAGE (STATUS "Vorbis was found.")
+    IF (VERBOSE_FIND)
+      MESSAGE (STATUS "  include path: ${VORBIS_INCLUDE_DIR}")
+      MESSAGE (STATUS "  library path: ${VORBIS_LIBRARY}")
+      #MESSAGE (STATUS "  library path: ${VORBISENC_LIBRARY}")
+      MESSAGE (STATUS "  library path: ${VORBISFILE_LIBRARY}")
+      MESSAGE (STATUS "  libraries:    vorbis vorbisenc vorbisfile")
+    ENDIF (VERBOSE_FIND)
+  ENDIF (NOT VORBIS_FIND_QUIETLY)
+ELSE (VORBIS_INCLUDE_DIR AND VORBIS_LIBRARY AND VORBISFILE_LIBRARY)# AND VORBISENC_LIBRARY)
+  IF (NOT VORBIS_INCLUDE_DIR)
+    MESSAGE (SEND_ERROR "Vorbis include path was not found.")
+  ENDIF (NOT VORBIS_INCLUDE_DIR)
+  IF (NOT VORBIS_LIBRARY)
+    MESSAGE (SEND_ERROR "Vorbis library \"vorbis\" was not found.")
+  ENDIF (NOT VORBIS_LIBRARY)
+  #IF (NOT VORBISENC_LIBRARY)
+  #  MESSAGE (SEND_ERROR "Vorbis library \"vorbisenc\" was not found.")
+  #ENDIF (NOT VORBISENC_LIBRARY)
+  IF (NOT VORBISFILE_LIBRARY)
+    MESSAGE (SEND_ERROR "Vorbis library \"vorbisfile\" was not found.")
+  ENDIF (NOT VORBISFILE_LIBRARY)
+ENDIF (VORBIS_INCLUDE_DIR AND VORBIS_LIBRARY AND VORBISFILE_LIBRARY)# AND VORBISENC_LIBRARY)
+MARK_AS_ADVANCED(
+  OGG_LIBRARY
+  OGG_INCLUDE_DIR
+  VORBIS_LIBRARY
+  VORBISFILE_LIBRARY
+  VORBIS_INCLUDE_DIR
+)

code/branches/buildsystem2/run

-                      r1506
+                      r2509
 #!/bin/bash
+cd bin
+./run-script $@
 cd ..
+#!/bin/sh
+# convenience script for starting orxonox
+cd build/bin && exec ./run-script $@

code/branches/buildsystem2/src/CMakeLists.txt

-                      r2129
+                      r2509
+INCLUDE_DIRECTORIES(.)
+INCLUDE_DIRECTORIES(..)
+INCLUDE_DIRECTORIES(orxonox)
+# Set the search paths for include files
+INCLUDE_DIRECTORIES(
+  ${OGRE_INCLUDE_DIR}
+  ${CEGUI_INCLUDE_DIR}
+#  ${CEGUI_OGRE_INCLUDE_DIR}
+  ${ENet_INCLUDE_DIR}
+  ${Boost_INCLUDE_DIRS}
+  ${OPENAL_INCLUDE_DIR}
+  ${ALUT_INCLUDE_DIR}
+  ${VORBIS_INCLUDE_DIR}
+  ${OGG_INCLUDE_DIR}
+  ${LUA_INCLUDE_DIR}
+  ${TCL_INCLUDE_PATH}
+  ${DirectX_INCLUDE_DIR}
+  ${ZLIB_INCLUDE_DIR}
+)
+INCLUDE_DIRECTORIES(
+  .
+  ois
+  orxonox
+  tolua
+  # Required for tolua bind files that are in the build folder
+  ${CMAKE_CURRENT_BINARY_DIR}
+)
+# Set special macro symbols across all libraries
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DTIXML_USE_TICPP")
 ADD_SUBDIRECTORY(cpptcl)
 ADD_SUBDIRECTORY(ois)
 ADD_SUBDIRECTORY(tinyxml)
-ADD_SUBDIRECTORY(lua)
 ADD_SUBDIRECTORY(tolua)
+# TODO: write include file for this stuff
 # Some people may not have CEGUILua installed, espc. with version 0.5
 # And we don't know what lua version it was linked against, so we compile
 …
     INCLUDE_DIRECTORIES(ceguilua-0.6.1)
 ELSE (WIN32)
+    IF (${CEGUI_VERSION} LESS 0.6.0)
+        ADD_SUBDIRECTORY(ceguilua-0.5.0b/ceguilua)
+        INCLUDE_DIRECTORIES(ceguilua-0.5.0b)
+    ELSE (${CEGUI_VERSION} LESS 0.6.0)
+        ADD_SUBDIRECTORY(ceguilua-0.6.1/ceguilua)
+        INCLUDE_DIRECTORIES(ceguilua-0.6.1)
+    ENDIF (${CEGUI_VERSION} LESS 0.6.0)
+    # FIXME
+    #IF (${CEGUI_VERSION} LESS 0.6.0)
+        ADD_SUBDIRECTORY(ceguilua-0.5.0/ceguilua)
+        INCLUDE_DIRECTORIES(ceguilua-0.5.0)
+    #ELSE (${CEGUI_VERSION} LESS 0.6.0)
+    #    ADD_SUBDIRECTORY(ceguilua-0.6.1/ceguilua)
+    #    INCLUDE_DIRECTORIES(ceguilua-0.6.1)
+    #ENDIF (${CEGUI_VERSION} LESS 0.6.0)
 ENDIF (WIN32)

code/branches/buildsystem2/src/ceguilua-0.6.1/ceguilua/CEGUILua.cpp

-                      r1810
+                      r2509
  *   OTHER DEALINGS IN THE SOFTWARE.
  ***************************************************************************/
+#ifdef HAVE_CONFIG_H
+#   include "config.h"
+#endif
 #include "CEGUI.h"
 …
 // include Lua libs and tolua++
+#include "lua/lua.hpp"
+#include "tolua/tolua++.h"
+extern "C" {
+#include "lua.h"
+#include "lualib.h"
+#include "lauxlib.h"
+}
+#include "tolua++.h"
 // prototype for bindings initialisation function
 …
 LuaScriptModule::LuaScriptModule()
+{
+    static const luaL_Reg lualibs[] = {
+        {"", luaopen_base},
+        {LUA_LOADLIBNAME, luaopen_package},
+        {LUA_TABLIBNAME, luaopen_table},
+        {LUA_IOLIBNAME, luaopen_io},
+        {LUA_OSLIBNAME, luaopen_os},
+        {LUA_STRLIBNAME, luaopen_string},
+        {LUA_MATHLIBNAME, luaopen_math},
+    #if defined(DEBUG) || defined (_DEBUG)
+        {LUA_DBLIBNAME, luaopen_debug},
+    #endif
+        {0, 0}
+    };
+    #if LUA_VERSION_NUM >= 501
+        static const luaL_Reg lualibs[] = {
+            {"", luaopen_base},
+            {LUA_LOADLIBNAME, luaopen_package},
+            {LUA_TABLIBNAME, luaopen_table},
+            {LUA_IOLIBNAME, luaopen_io},
+            {LUA_OSLIBNAME, luaopen_os},
+            {LUA_STRLIBNAME, luaopen_string},
+            {LUA_MATHLIBNAME, luaopen_math},
+        #if defined(DEBUG) || defined (_DEBUG)
+                {LUA_DBLIBNAME, luaopen_debug},
+        #endif
+            {0, 0}
+        };
+    #endif /* CEGUI_LUA_VER >= 51 */
     // create a lua state
 …
     // init all standard libraries
+    const luaL_Reg *lib = lualibs;
+    for (; lib->func; lib++)
+    {
+        lua_pushcfunction(d_state, lib->func);
+        lua_pushstring(d_state, lib->name);
+        lua_call(d_state, 1, 0);
+    }
+    #if LUA_VERSION_NUM >= 501
+            const luaL_Reg *lib = lualibs;
+            for (; lib->func; lib++)
+            {
+                lua_pushcfunction(d_state, lib->func);
+                lua_pushstring(d_state, lib->name);
+                lua_call(d_state, 1, 0);
+            }
+    #else /* CEGUI_LUA_VER >= 51 */
+        luaopen_base(d_state);
+        luaopen_io(d_state);
+        luaopen_string(d_state);
+        luaopen_table(d_state);
+        luaopen_math(d_state);
+        #if defined(DEBUG) || defined (_DEBUG)
+            luaopen_debug(d_state);
+        #endif
+    #endif /* CEGUI_LUA_VER >= 51 */
     setModuleIdentifierString();

code/branches/buildsystem2/src/ceguilua-0.6.1/ceguilua/CEGUILuaFunctor.cpp

-                      r1810
+                      r2509
 // include Lua libs and tolua++
+#include "lua/lua.hpp"
+#include "tolua/tolua++.h"
+extern "C" {
+#include "lua.h"
+#include "lualib.h"
+#include "lauxlib.h"
+}
+#include "tolua++.h"
 // Start of CEGUI namespace section

code/branches/buildsystem2/src/ceguilua-0.6.1/ceguilua/CMakeLists.txt

-                      r1854
+                      r2509
-INCLUDE_DIRECTORIES(.)
 SET( CEGUILUA_SRC_FILES
   CEGUILua.cpp
 …
 TARGET_LINK_LIBRARIES(ceguilua_orxonox
-  lua_orxonox
   tolualib_orxonox
+  ${CEGUI_LIBRARIES}
+  ${LUA_LIBRARIES}
+  ${CEGUI_LIBRARY}
+)

code/branches/buildsystem2/src/ceguilua-0.6.1/ceguilua/lua_CEGUI.cpp

r1810	r2509
9	9	#include "string.h"
10	10
11		#include "tolua~~/tolua~~++.h"
	11	#include "tolua++.h"
12	12
13	13	/* Exported function */

code/branches/buildsystem2/src/core/CMakeLists.txt

-                      r2131
+                      r2509
   TclThreadManager.cc
-  tolua/tolua_bind.cc
+)
 ADD_SOURCE_DIRECTORY(CORE_SRC_FILES input)
+GET_TARGET_PROPERTY(TOLUA_EXE tolua_orxonox LOCATION)
+ADD_CUSTOM_COMMAND(
+  OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/tolua/tolua_bind.cc ${CMAKE_CURRENT_SOURCE_DIR}/tolua/tolua_bind.h
+  COMMAND ${TOLUA_EXE} -n Core -o ../../src/core/tolua/tolua_bind.cc -H ../../src/core/tolua/tolua_bind.h ../../src/core/tolua/tolua.pkg
+  DEPENDS
+    tolua_orxonox
+    tolua/tolua.pkg
+    LuaBind.h
+    CommandExecutor.h
+  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/bin/lib
+)
+INCLUDE(UseTolua)
+TOLUA(Core CORE_SRC_FILES INPUTFILES LuaBind.h CommandExecutor.h)
 ADD_LIBRARY(core SHARED ${CORE_SRC_FILES})
 TARGET_LINK_LIBRARIES(core
   ${OGRE_LIBRARIES}
   ${Boost_thread_LIBRARIES}
   ${Boost_filesystem_LIBRARIES}
   lua_orxonox
+  ${OGRE_LIBRARY}
+  ${Boost_THREAD_LIBRARY}
+  ${Boost_FILESYSTEM_LIBRARY}
+  ${LUA_LIBRARIES}
   cpptcl_orxonox
   ois_orxonox

code/branches/buildsystem2/src/core/CommandExecutor.h

-                      r1771
+                      r2509
 #include "CommandEvaluation.h"
+namespace orxonox // tolua_export
+{ // tolua_export
+// tolua_begin
+namespace orxonox
+{
     class _CoreExport CommandExecutor
-    /*
-    class CommandExecutor { // tolua_export
-    */
+    {
+// tolua_end
         public:
             static bool execute(const std::string& command, bool useTcl = true); // tolua_export

code/branches/buildsystem2/src/core/LuaBind.cc

Property svn:mergeinfo set to (toggle deleted branches)

/code/branches/buildsystem/src/core/Script.cc	merged	eligible
/code/branches/questsystem2/src/core/LuaBind.cc	merged	eligible
/code/branches/buildsystem/src/core/LuaBind.cc	1874-2276
/code/branches/ceguilua/src/core/LuaBind.cc	1802-1808
/code/branches/core3/src/core/LuaBind.cc	1572-1739
/code/branches/gcc43/src/core/LuaBind.cc	1580
/code/branches/gui/src/core/LuaBind.cc	1635-1723
/code/branches/input/src/core/LuaBind.cc	1629-1636
/code/branches/objecthierarchy/src/core/LuaBind.cc	1911-2085,2100,2110-2169
/code/branches/pickups/src/core/LuaBind.cc	1926-2086
/code/branches/questsystem/src/core/LuaBind.cc	1894-2088
/code/branches/script_trigger/src/core/LuaBind.cc	1295-1953,1955
/code/branches/weapon/src/core/LuaBind.cc	1925-2094

-                      r2087
+                      r2509
 #include <map>
+#include "lua/lua.hpp"
+#include "tolua/tolua++.h"
+#include "tolua/tolua_bind.h"
+extern "C" {
+#include "lua.h"
+#include "lualib.h"
+}
+#include "tolua++.h"
+#include "core/ToluaBindCore.h"
 #include "util/String.h"
 #include "CoreIncludes.h"

code/branches/buildsystem2/src/core/LuaBind.h

Property svn:mergeinfo set to (toggle deleted branches)

/code/branches/buildsystem/src/core/Script.h	merged	eligible
/code/branches/questsystem2/src/core/LuaBind.h	merged	eligible
/code/branches/buildsystem/src/core/LuaBind.h	1874-2276
/code/branches/ceguilua/src/core/LuaBind.h	1802-1808
/code/branches/core3/src/core/LuaBind.h	1572-1739
/code/branches/gcc43/src/core/LuaBind.h	1580
/code/branches/gui/src/core/LuaBind.h	1635-1723
/code/branches/input/src/core/LuaBind.h	1629-1636
/code/branches/objecthierarchy/src/core/LuaBind.h	1911-2085,2100,2110-2169
/code/branches/pickups/src/core/LuaBind.h	1926-2086
/code/branches/questsystem/src/core/LuaBind.h	1894-2088
/code/branches/script_trigger/src/core/LuaBind.h	1295-1953,1955
/code/branches/weapon/src/core/LuaBind.h	1925-2094

-                      r2087
+                      r2509
 extern "C" {
 #include <lua/lua.h>
+#include <lua.h>
+}
 …
 #include <string>
+namespace orxonox // tolua_export
+{ // tolua_export
+// tolua_begin
+namespace orxonox
+{
   class _CoreExport LuaBind
+  {
+  /*
+  class LuaBind { // tolua_export
+  */
+// tolua_end
     struct LoadS {
       const char *s;

code/branches/buildsystem2/src/core/XMLIncludes.h

Property svn:mergeinfo changed (with no actual effect on merging)

code/branches/buildsystem2/src/network/CMakeLists.txt

-                      r2131
+                      r2509
 TARGET_LINK_LIBRARIES( network
   ${ZLIB_LIBRARY}
   ${ENet_LIBRARY}
   ${Boost_thread_LIBRARIES}
+  ${ENet_LIBRARIES}
+  ${Boost_THREAD_LIBRARY}
   core
+)
 …
   ADD_EXECUTABLE(networktest ${TEST_SRC_FILES})
   TARGET_LINK_LIBRARIES( networktest
     ${OGRE_LIBRARIES}
+    ${OGRE_LIBRARY}
     network
     ${ENet_LIBRARY}
+    ${ENet_LIBRARIES}
     ${ZLIB_LIBRARY}
-    ${WINDOWS_ENET_DEPENDENCIES}
+  )
   ##### end test for gamestate stuff #####

code/branches/buildsystem2/src/ois/CMakeLists.txt

r1555	r2509
1		~~INCLUDE_DIRECTORIES(.)~~
2
3	1	SET( OIS_SRC_FILES
4	2	OISEffect.cpp

code/branches/buildsystem2/src/orxonox/CMakeLists.txt

-                      r2171
+                      r2509
   PlayerManager.cc
   Settings.cc
-  tolua/tolua_bind.cc
+)
 …
 ADD_SOURCE_DIRECTORY(ORXONOX_SRC_FILES tools)
+GET_TARGET_PROPERTY(TOLUA_EXE tolua_orxonox LOCATION)
+ADD_CUSTOM_COMMAND(
+  OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/tolua/tolua_bind.cc ${CMAKE_CURRENT_SOURCE_DIR}/tolua/tolua_bind.h
+  COMMAND ${TOLUA_EXE} -n Orxonox -o ../../src/orxonox/tolua/tolua_bind.cc -H ../../src/orxonox/tolua/tolua_bind.h ../../src/orxonox/tolua/tolua.pkg
+  DEPENDS
+    tolua_orxonox
+    tolua/tolua.pkg
+    gui/GUIManager.h
+  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/bin/lib
+)
+INCLUDE(UseTolua)
+TOLUA(Orxonox ORXONOX_SRC_FILES INPUTFILES gui/GUIManager.h)
 …
 TARGET_LINK_LIBRARIES( orxonox
+  ${OGRE_LIBRARIES}
+  ${CEGUI_LIBRARIES}
+  lua_orxonox
+  ${OGRE_LIBRARY}
+  ${CEGUI_LIBRARY}
+  ${LUA_LIBRARIES}
+  #${CEGUI_SCRIPT_LIBRARIES}
   ceguilua_orxonox
   tinyxml_orxonox
 …
   network
+)

code/branches/buildsystem2/src/orxonox/Settings.cc

r2087	r2509
63	63	void Settings::setConfigValues()
64	64	{
65		SetConfigValue(dataPath_, "../../media/").description("Relative path to the game data.").callback(this, &Settings::dataPathChanged);
	65	SetConfigValue(dataPath_, "../../../media/").description("Relative path to the game data.").callback(this, &Settings::dataPathChanged);
66	66	}
67	67

code/branches/buildsystem2/src/orxonox/gamestates/GSGraphics.cc

-                      r2171
+                      r2509
 #include "util/Debug.h"
 #include "util/Exception.h"
+#include "util/String.h"
+#include "util/SubString.h"
 #include "core/ConsoleCommand.h"
 #include "core/ConfigValueIncludes.h"
 …
         SetConfigValue(ogreConfigFile_,  "ogre.cfg")
             .description("Location of the Ogre config file");
+        SetConfigValue(ogrePluginsFile_, "plugins.cfg")
+            .description("Location of the Ogre plugins file");
+        SetConfigValue(ogrePluginsFolder_, ".")
+            .description("Folder where the Ogre plugins are located.");
+        SetConfigValue(ogrePlugins_, "RenderSystem_GL, Plugin_ParticleFX")
+            .description("Comma separated list of all plugins to load.");
         SetConfigValue(ogreLogFile_,     "ogre.log")
             .description("Logfile for messages from Ogre. Use \"\" to suppress log file creation.");
 …
         // Ogre setup procedure
         setupOgre();
+        // load all the required plugins for Ogre
+        loadOgrePlugins();
+        // read resource declaration file
         this->declareResources();
+        this->loadRenderer();    // creates the render window
+        // Reads ogre config and creates the render window
+        this->loadRenderer();
         // TODO: Spread this so that this call only initialises things needed for the Console and GUI
         this->initialiseResources();
 …
             probe.close();
+        ogreRoot_ = new Ogre::Root(ogrePluginsFile_, ogreConfigFile_, ogreLogFile_);
+        // Leave plugins file empty. We're going to do that part manually later
+        ogreRoot_ = new Ogre::Root("", ogreConfigFile_, ogreLogFile_);
 #if 0 // Ogre 1.4.3 doesn't yet support setDebugOutputEnabled(.)
 …
         COUT(3) << "Ogre set up done." << std::endl;
+    }
+    void GSGraphics::loadOgrePlugins()
+    {
+        // just to make sure the next statement doesn't segfault
+        if (ogrePluginsFolder_ == "")
+            ogrePluginsFolder_ = ".";
+#if ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32
+        convertToWindowsPath(&ogrePluginsFolder_);
+#else
+        convertToUnixPath(&ogrePluginsFolder_);
+#endif
+        // Do some SubString magic to get the comma separated list of plugins
+        SubString plugins(ogrePlugins_, ",", " ", false, 92, false, 34, false, 40, 41, false, '\0');
+        for (unsigned int i = 0; i < plugins.size(); ++i)
+            ogreRoot_->loadPlugin(ogrePluginsFolder_ + plugins[i]);
+    }

code/branches/buildsystem2/src/orxonox/gamestates/GSGraphics.h

-                      r2103
+                      r2509
         void setupOgre();
+        void loadOgrePlugins();
         void declareResources();
         void loadRenderer();
 …
         std::string           resourceFile_;             //!< resources file name
         std::string           ogreConfigFile_;           //!< ogre config file name
+        std::string           ogrePluginsFile_;          //!< ogre plugins file name
+        std::string           ogrePluginsFolder_;        //!< Folder where the Ogre plugins are located
+        std::string           ogrePlugins_;              //!< Comma separated list of all plugins to load
         std::string           ogreLogFile_;              //!< log file name for Ogre log messages
         int                   ogreLogLevelTrivial_;      //!< Corresponding Orxonx debug level for LL_TRIVIAL

code/branches/buildsystem2/src/orxonox/gui/GUIManager.cc

-                      r2087
+                      r2509
 #include <OgreRoot.h>
 #include <CEGUI.h>
 #include "ceguilua/CEGUILua.h"
+#include <CEGUILua.h>
 #include "util/Exception.h"
 #include "core/input/InputManager.h"
 #include "core/input/SimpleInputState.h"
-#include "core/tolua/tolua_bind.h"
 #include "core/ConsoleCommand.h"
 #include "core/Core.h"
+#include "tolua/tolua_bind.h"
+#include "core/ToluaBindCore.h"
+#include "orxonox/ToluaBindOrxonox.h"
 #include "OgreCEGUIRenderer.h"
+#include "lua/lua.hpp"
+extern "C" {
+#include "lua.h"
+}
 namespace orxonox

code/branches/buildsystem2/src/orxonox/gui/GUIManager.h

-                      r1887
+                      r2509
 #include "core/input/InputInterfaces.h"
+namespace orxonox // tolua_export
+{ // tolua_export
+// tolua_begin
+namespace orxonox
+{
     /**
     @brief
         Provides a simple interface to CEGUI with tolua methods and console commands
     */
     class _OrxonoxExport GUIManager : public KeyHandler, public MouseHandler
+    /*
     class GUIManager { // tolua_export
+    */
+    class _OrxonoxExport GUIManager
+// tolua_end
+        : public KeyHandler, public MouseHandler
+// tolua_begin
+    {
+// tolua_end
     public:
         enum State

code/branches/buildsystem2/src/tinyxml/ticpp.cc

-                      r1625
+                      r2509
-#define TIXML_USE_TICPP
 /*
 http://code.google.com/p/ticpp/
 …
 */
-/*
-Modifications by the orxonox team:
-In function: void Document::Parse( const std::string& xml, bool throwIfParseError, TiXmlEncoding encoding )
-     change: Added row and column number to the error description.
-     author: Reto Grieder
-*/
 #ifdef TIXML_USE_TICPP
 …
         Attribute* temp = new Attribute( attribute );
         m_spawnedWrappers.push_back( temp );
+        attribute->m_spawnedWrappers.push_back( temp );
         return temp;
 …
         Attribute* temp = new Attribute( attribute );
         m_spawnedWrappers.push_back( temp );
+        attribute->m_spawnedWrappers.push_back( temp );
         return temp;
 …
         if ( rememberSpawnedWrapper )
+        {
                 m_spawnedWrappers.push_back( temp );
+                tiXmlNode->m_spawnedWrappers.push_back( temp );
+        }
         return temp;
 …
+        }
+        TiXmlNode* pointer = GetTiXmlPointer()->InsertEndChild( *addThis.GetTiXmlPointer() );
+        if ( 0 == pointer )
+        {
+                TICPPTHROW( "Node can't be inserted" );
+        }
+        return NodeFactory( pointer );
+}
+Node* Node::LinkEndChild( Node* childNode )
+{
+        if ( childNode->Type() == TiXmlNode::DOCUMENT )
+        {
+                TICPPTHROW( "Node is a Document and can't be linked" );
+        }
+        // Increment reference count when adding to the tree
+        childNode->m_impRC->IncRef();
+        if ( 0 == GetTiXmlPointer()->LinkEndChild( childNode->GetTiXmlPointer() ) )
+        {
+                TICPPTHROW( "Node can't be linked" );
+        }
+        return childNode;
+}
+Node* Node::InsertBeforeChild( Node* beforeThis, Node& addThis )
+{
+        if ( addThis.Type() == TiXmlNode::DOCUMENT )
+        {
+                TICPPTHROW( "Node is a Document and can't be inserted" );
+        }
         // Increment reference count when adding to the tree
         addThis.m_impRC->IncRef();
         TiXmlNode* pointer = GetTiXmlPointer()->InsertEndChild( *addThis.GetTiXmlPointer() );
+        TiXmlNode* pointer = GetTiXmlPointer()->InsertBeforeChild( beforeThis->GetTiXmlPointer(), *addThis.GetTiXmlPointer() );
         if ( 0 == pointer )
+        {
 …
+}
+Node* Node::LinkEndChild( Node* childNode )
+{
+        if ( childNode->Type() == TiXmlNode::DOCUMENT )
+        {
+                TICPPTHROW( "Node is a Document and can't be linked" );
+        }
+        // Increment reference count when adding to the tree
+        childNode->m_impRC->IncRef();
+        if ( 0 == GetTiXmlPointer()->LinkEndChild( childNode->GetTiXmlPointer() ) )
+        {
+                TICPPTHROW( "Node can't be linked" );
+        }
+        return childNode;
+}
+Node* Node::InsertBeforeChild( Node* beforeThis, Node& addThis )
+Node* Node::InsertAfterChild( Node* afterThis, Node& addThis )
+{
         if ( addThis.Type() == TiXmlNode::DOCUMENT )
 …
         addThis.m_impRC->IncRef();
-        TiXmlNode* pointer = GetTiXmlPointer()->InsertBeforeChild( beforeThis->GetTiXmlPointer(), *addThis.GetTiXmlPointer() );
-        if ( 0 == pointer )
+        {
-                TICPPTHROW( "Node can't be inserted" );
+        }
-        return NodeFactory( pointer );
+}
-Node* Node::InsertAfterChild( Node* afterThis, Node& addThis )
+{
-        if ( addThis.Type() == TiXmlNode::DOCUMENT )
+        {
-                TICPPTHROW( "Node is a Document and can't be inserted" );
+        }
-        // Increment reference count when adding to the tree
-        addThis.m_impRC->IncRef();
         TiXmlNode* pointer = GetTiXmlPointer()->InsertAfterChild( afterThis->GetTiXmlPointer(), *addThis.GetTiXmlPointer() );
         if ( 0 == pointer )
 …
         Element* temp = new Element( sibling );
         m_spawnedWrappers.push_back( temp );
+        sibling->m_spawnedWrappers.push_back( temp );
         return temp;
 …
         Element* temp = new Element( element );
         m_spawnedWrappers.push_back( temp );
+        element->m_spawnedWrappers.push_back( temp );
         return temp;
 …
+        }
         Document* temp = new Document( doc );
         m_spawnedWrappers.push_back( temp );
+        doc->m_spawnedWrappers.push_back( temp );
         return temp;
 …
+        }
         Document* temp = new Document( doc );
         m_spawnedWrappers.push_back( temp );
+        doc->m_spawnedWrappers.push_back( temp );
         return temp;
 …
+        }
         Element* temp = new Element( doc );
         m_spawnedWrappers.push_back( temp );
+        doc->m_spawnedWrappers.push_back( temp );
         return temp;
 …
+        }
         Comment* temp = new Comment( doc );
         m_spawnedWrappers.push_back( temp );
+        doc->m_spawnedWrappers.push_back( temp );
         return temp;
 …
+        }
         Text* temp = new Text( doc );
         m_spawnedWrappers.push_back( temp );
+        doc->m_spawnedWrappers.push_back( temp );
         return temp;
 …
+        }
         Declaration* temp = new Declaration( doc );
         m_spawnedWrappers.push_back( temp );
+        doc->m_spawnedWrappers.push_back( temp );
         return temp;
 …
+        }
         StylesheetReference* temp = new StylesheetReference( doc );
         m_spawnedWrappers.push_back( temp );
+        doc->m_spawnedWrappers.push_back( temp );
         return temp;
 …
         if( throwIfParseError && m_tiXmlPointer->Error() )
+        {
+                TICPPTHROW( "Error parsing xml: " << m_tiXmlPointer->ErrorDesc()
+            << " In row " << m_tiXmlPointer->ErrorRow() << ", column " << m_tiXmlPointer->ErrorCol() << ".");
+                TICPPTHROW( "Error parsing xml." );
+        }
+}
 …
         Attribute* temp = new Attribute( attribute );
         m_spawnedWrappers.push_back( temp );
+        attribute->m_spawnedWrappers.push_back( temp );
         return temp;
 …
         Attribute* temp = new Attribute( attribute );
         m_spawnedWrappers.push_back( temp );
+        attribute->m_spawnedWrappers.push_back( temp );
         return temp;
 …
+{
         return GetAttributeOrDefault( name, std::string() );
+}
+bool Element::HasAttribute( const std::string& name ) const
+{
+        ValidatePointer();
+        return ( 0 != m_tiXmlPointer->Attribute( name.c_str() ) );
+}
+void Element::RemoveAttribute( const std::string& name )
+{
+        ValidatePointer();
+        m_tiXmlPointer->RemoveAttribute( name.c_str() );
+}
 …
+}
+void TiCppRC::DeleteSpawnedWrappers()
+{
+        std::vector< Base* >::reverse_iterator wrapper;
+        for ( wrapper = m_spawnedWrappers.rbegin(); wrapper != m_spawnedWrappers.rend(); ++wrapper )
+        {
+                delete *wrapper;
+        }
+        m_spawnedWrappers.clear();
+}
 TiCppRC::~TiCppRC()
+{
+{
+        DeleteSpawnedWrappers();
         // Set pointer held by reference counter to NULL
         this->m_tiRC->Nullify();

code/branches/buildsystem2/src/tinyxml/ticpp.h

-                      r2087
+                      r2509
-#define TIXML_USE_TICPP
 /*
 http://code.google.com/p/ticpp/
 …
 @date           04/11/2006
-@version  0.04b by nico@orxonox.net: gcc-4.3 compilation hotfixes
 @version        0.04a by edam@waxworlds.org: based Exception based on std::exception; added stream
                                         << and >> support; added Document::Parse(); bug fix; improved THROW() macro.
 …
                 file = file.substr( file.find_last_of( "\\/" ) + 1 );                           \
                 full_message << message << " <" << file << "@" << __LINE__ << ">";      \
+                full_message << BuildDetailedErrorString();                                                     \
                 throw Exception( full_message.str() );                                                          \
+        }
 …
                 /**
+                Compare internal TiXml pointers to determine is both are wrappers around the same node
+                */
+                bool operator == ( const Base& rhs ) const
+                {
+                        return ( GetBasePointer() == rhs.GetBasePointer() );
+                }
+                /**
+                Compare internal TiXml pointers to determine is both are wrappers around the same node
+                */
+                bool operator != ( const Base& rhs ) const
+                {
+                        return ( GetBasePointer() != rhs.GetBasePointer() );
+                }
+                /**
+                Builds detailed error string using TiXmlDocument::Error() and others
+                */
+                std::string BuildDetailedErrorString() const
+                {
+                        std::ostringstream full_message;
+                        #ifndef TICPP_NO_RTTI
+                        TiXmlNode* node = dynamic_cast< TiXmlNode* >( GetBasePointer() );
+                        if ( node != 0 )
+                        {
+                                TiXmlDocument* doc = node->GetDocument();
+                                if ( doc != 0 )
+                                {
+                                        if ( doc->Error() )
+                                        {
+                                                full_message    << "\nDescription: " << doc->ErrorDesc()
+                                                                                << "\nFile: " << (strlen( doc->Value() ) > 0 ? doc->Value() : "<unnamed-file>")
+                                                                                << "\nLine: " << doc->ErrorRow()
+                                                                                << "\nColumn: " << doc->ErrorCol();
+                                        }
+                                }
+                        }
+                        #endif
+                        return full_message.str();
+                }
+                /**
                 Destructor
                 */
                 virtual ~Base()
+                {
-                        DeleteSpawnedWrappers();
+                }
 …
                 mutable TiCppRCImp* m_impRC;    /**< Holds status of internal TiXmlPointer - use this to determine if object has been deleted already */
-                mutable std::vector< Base* > m_spawnedWrappers; /**< Remember all wrappers that we've created with 'new' - ( e.g. NodeFactory, FirstChildElement, etc. )*/
                 /**
                 @internal
 …
                                 TICPPTHROW( "Internal TiXml Pointer is NULL" );
+                        }
+                }
+                /**
+                @internal
+                Delete all container objects we've spawned with 'new'.
+                */
+                void DeleteSpawnedWrappers()
+                {
+                        std::vector< Base* >::reverse_iterator wrapper;
+                        for ( wrapper = m_spawnedWrappers.rbegin(); wrapper != m_spawnedWrappers.rend(); ++wrapper )
+                        {
+                                delete *wrapper;
+                        }
+                        m_spawnedWrappers.clear();
+                }
+                }
                 /**
 …
                 bool NoChildren() const;
+                #ifndef TICPP_NO_RTTI
                 /**
                 Pointer conversion ( NOT OBJECT CONVERSION ) - replaces TiXmlNode::ToElement, TiXmlNode::ToDocument, TiXmlNode::ToComment, etc.
 …
                         return pointer;
+                }
+                #endif
                 /**
 …
                 /// Constructor
                 Iterator( const Iterator& it, const std::string& value  = "" )
                         : m_p( it.m_p ), m_value( value )
+                Iterator( const Iterator& it )
+                        : m_p( it.m_p ), m_value( it.m_value )
+                {
+                }
 …
+                {
                         m_p = it.m_p;
+                        m_value = it.m_value;
                         return *this;
+                }
 …
                 /** Sets internal pointer to the Next Sibling, or Iterator::END, if there are no more siblings */
+                Iterator& operator++(int)
+                {
+                        return this->operator ++();
+                Iterator operator++(int)
+                {
+                        Iterator tmp(*this);
+                        ++(*this);
+                        return tmp;
+                }
 …
                 /** Sets internal pointer to the Previous Sibling, or Iterator::END, if there are no prior siblings */
+                Iterator& operator--(int)
+                {
+                        return this->operator --();
+                Iterator operator--(int)
+                {
+                        Iterator tmp(*this);
+                        --(*this);
+                        return tmp;
+                }
                 /** Compares internal pointer */
+                bool operator!=( T* p ) const
+                {
+                        return m_p != p;
+                bool operator!=( const T* p ) const
+                {
+                        if ( m_p == p )
+                        {
+                                return false;
+                        }
+                        if ( 0 == m_p || 0 == p )
+                        {
+                                return true;
+                        }
+                        return *m_p != *p;
+                }
 …
                 bool operator!=( const Iterator& it ) const
+                {
                         return m_p != it.m_p;
+                        return operator!=( it.m_p );
+                }
 …
                 bool operator==( T* p ) const
+                {
+                        return m_p == p;
+                        if ( m_p == p )
+                        {
+                                return true;
+                        }
+                        if ( 0 == m_p || 0 == p )
+                        {
+                                return false;
+                        }
+                        return *m_p == *p;
+                }
 …
                 bool operator==( const Iterator& it ) const
+                {
                         return m_p == it.m_p;
+                        return operator==( it.m_p );
+                }
 …
                         if ( 0 == tiXmlPointer )
+                        {
+                                TICPPTHROW( "Can not create a " << typeid( T ).name() );
+                                #ifdef TICPP_NO_RTTI
+                                        TICPPTHROW( "Can not create TinyXML objext" );
+                                #else
+                                        TICPPTHROW( "Can not create a " << typeid( T ).name() );
+                                #endif
+                        }
                         SetTiXmlPointer( tiXmlPointer );
 …
                 virtual void operator=( const NodeImp<T>& copy )
+                {
-                        DeleteSpawnedWrappers();
                         // Dropping the reference to the old object
                         this->m_impRC->DecRef();
 …
                 virtual ~NodeImp()
+                {
-                        // The spawnedWrappers need to be deleted before m_tiXmlPointer
-                        DeleteSpawnedWrappers();
                         m_impRC->DecRef();
+                }
 …
                 /**
+                Returns an attribute of @a name from an element.
+                Uses FromString to convert the string to the type of choice.
+                @param name                             The name of the attribute you are querying.
+                @param throwIfNotFound  [DEF]   If true, will throw an exception if the attribute doesn't exist
+                @throws Exception When the attribute doesn't exist and throwIfNotFound is true
+                @see GetAttributeOrDefault
+                */
+                template < class T >
+                        T GetAttribute( const std::string& name, bool throwIfNotFound = true ) const
+                {
+                        // Get the attribute's value as a std::string
+                        std::string temp;
+                        T value;
+                        if ( !GetAttributeImp( name, &temp ) )
+                        {
+                                if ( throwIfNotFound )
+                                {
+                                        TICPPTHROW( "Attribute does not exist" );
+                                }
+                        }
+                        else
+                        {
+                                // Stream the value from the string to T
+                                FromString( temp, &value );
+                        }
+                        return value;
+                }
+                /**
                 Gets an attribute of @a name from an element.
                 Uses FromString to convert the string to the type of choice.
 …
                 std::string GetAttribute( const std::string& name ) const;
+                /**
+                Returns true, if attribute exists
+                @param name The name of the attribute you are checking.
+                @return Existence of attribute
+                */
+                bool HasAttribute( const std::string& name ) const;
+                /**
+                Removes attribute from element.
+                @param name The name of the attribute to remove.
+                */
+                void RemoveAttribute( const std::string& name );
         private:

code/branches/buildsystem2/src/tinyxml/ticpprc.h

-                      r1505
+                      r2509
-#define TIXML_USE_TICPP
 /*
 http://code.google.com/p/ticpp/
 …
 #define TICPPRC_INCLUDED
+#include <vector>
 // Forward declare ticpp::Node, so it can be made a friend of TiCppRC
 …
         */
         virtual ~TiCppRC();
+        std::vector< ticpp::Base* > m_spawnedWrappers; /**< Remember all wrappers that we've created with 'new' - ( e.g. NodeFactory, FirstChildElement, etc. )*/
+        /**
+        Delete all container objects we've spawned with 'new'.
+        */
+        void DeleteSpawnedWrappers();
 };

code/branches/buildsystem2/src/tinyxml/tinyxml.h

r1505	r2509
1		~~#define TIXML_USE_TICPP~~
2
3	1	/*
4	2	www.sourceforge.net/projects/tinyxml

code/branches/buildsystem2/src/tolua/CMakeLists.txt

-                      r1815
+                      r2509
 SET (TOLUALIB_SRC_FILES
+SET(TOLUALIB_SRC_FILES
   tolua_event.c
   tolua_is.c
 …
+)
+ADD_LIBRARY (tolualib_orxonox SHARED ${TOLUALIB_SRC_FILES})
+ADD_LIBRARY          (tolualib_orxonox SHARED ${TOLUALIB_SRC_FILES})
+TARGET_LINK_LIBRARIES(tolualib_orxonox ${LUA_LIBRARIES})
+TARGET_LINK_LIBRARIES (tolualib_orxonox
+  lua_orxonox
+SET(TOLUAGEN_SRC_FILES
+  tolua.c
+)
+ADD_EXECUTABLE       (toluaexe_orxonox ${TOLUAGEN_SRC_FILES})
+TARGET_LINK_LIBRARIES(toluaexe_orxonox tolualib_orxonox ${LUA_LIBRARIES})
+SET (TOLUAGEN_SRC_FILES
+  tolua.c
+  toluabind.c
+# TODO: determine lua version and set appropriate pack file
+SET(TOLUA_ALL_PACK all-5.1.lua)
+SET(TOLUA_PARSER_SOURCE "${CMAKE_CURRENT_SOURCE_DIR}/${TOLUA_ALL_PACK}" PARENT_SCOPE)
+SET(TOLUA_PARSER_DEPENDENCIES
+  ${CMAKE_CURRENT_SOURCE_DIR}/${TOLUA_ALL_PACK}
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/compat-5.1.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/compat.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/basic.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/feature.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/verbatim.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/code.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/typedef.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/container.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/package.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/module.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/namespace.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/define.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/enumerate.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/declaration.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/variable.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/array.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/function.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/operator.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/class.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/clean.lua
+  ${CMAKE_CURRENT_SOURCE_DIR}/lua/doit.lua
+  PARENT_SCOPE
+)
-ADD_EXECUTABLE (toluagen_orxonox ${TOLUAGEN_SRC_FILES})
-TARGET_LINK_LIBRARIES (toluagen_orxonox
-  lua_orxonox
-  tolualib_orxonox
+  m
+)
-SET (TOLUA_PACKAGE "../../src/tolua/tolua-5.1.pkg")
-GET_TARGET_PROPERTY(TOLUAGEN_EXE toluagen_orxonox LOCATION)
-ADD_CUSTOM_COMMAND(
-  OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/toluabind_orxonox.c
-  COMMAND ${TOLUAGEN_EXE} -n tolua -o ../../src/tolua/toluabind_orxonox.c -H ../../src/tolua/toluabind_orxonox.h ${TOLUA_PACKAGE}
-  DEPENDS
-    toluagen_orxonox
-    tolua-5.1.pkg
-    lua/compat-5.1.lua
-    lua/compat.lua
-    lua/basic.lua
-    lua/feature.lua
-    lua/verbatim.lua
-    lua/code.lua
-    lua/typedef.lua
-    lua/container.lua
-    lua/package.lua
-    lua/module.lua
-    lua/namespace.lua
-    lua/define.lua
-    lua/enumerate.lua
-    lua/declaration.lua
-    lua/variable.lua
-    lua/array.lua
-    lua/function.lua
-    lua/operator.lua
-    lua/class.lua
-    lua/clean.lua
-    lua/doit.lua
-  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/bin/lib
+)
-SET (TOLUAEXE_SRC_FILES
-  tolua.c
-  toluabind_orxonox.c
+)
-ADD_EXECUTABLE (tolua_orxonox ${TOLUAEXE_SRC_FILES})
-TARGET_LINK_LIBRARIES (tolua_orxonox
-  lua_orxonox
-  tolualib_orxonox
+  m
+)

code/branches/buildsystem2/src/tolua/lua/array.lua

-                      r2087
+                      r2509
 -- Print method
 function classArray:print (ident,close)
  print(ident.."Array{")
  print(ident.." mod  = '"..self.mod.."',")
  print(ident.." type = '"..self.type.."',")
  print(ident.." ptr  = '"..self.ptr.."',")
  print(ident.." name = '"..self.name.."',")
  print(ident.." def  = '"..self.def.."',")
  print(ident.." dim  = '"..self.dim.."',")
  print(ident.." ret  = '"..self.ret.."',")
  print(ident.."}"..close)
+    print(ident.."Array{")
+    print(ident.." mod  = '"..self.mod.."',")
+    print(ident.." type = '"..self.type.."',")
+    print(ident.." ptr  = '"..self.ptr.."',")
+    print(ident.." name = '"..self.name.."',")
+    print(ident.." def  = '"..self.def.."',")
+    print(ident.." dim  = '"..self.dim.."',")
+    print(ident.." ret  = '"..self.ret.."',")
+    print(ident.."}"..close)
 end
 -- check if it is a variable
 function classArray:isvariable ()
  return true
+    return true
 end
 …
 -- get variable value
 function classArray:getvalue (class,static)
  if class and static then
   return class..'::'..self.name..'[tolua_index]'
  elseif class then
   return 'self->'..self.name..'[tolua_index]'
  else
   return self.name..'[tolua_index]'
  end
+    if class and static then
+        return class..'::'..self.name..'[tolua_index]'
+    elseif class then
+        return 'self->'..self.name..'[tolua_index]'
+    else
+        return self.name..'[tolua_index]'
+    end
 end
 -- Write binding functions
 function classArray:supcode ()
+ local class = self:inclass()
+ -- get function ------------------------------------------------
+ if class then
+  output("/* get function:",self.name," of class ",class," */")
+ else
+  output("/* get function:",self.name," */")
+ end
+ self.cgetname = self:cfuncname("tolua_get")
+ output("#ifndef TOLUA_DISABLE_"..self.cgetname)
+ output("\nstatic int",self.cgetname,"(lua_State* tolua_S)")
+ output("{")
+ output(" int tolua_index;")
+ -- declare self, if the case
+ local _,_,static = strfind(self.mod,'^%s*(static)')
+ if class and static==nil then
+  output(' ',self.parent.type,'*','self;')
+  output(' lua_pushstring(tolua_S,".self");')
+  output(' lua_rawget(tolua_S,1);')
+  output(' self = ')
+  output('(',self.parent.type,'*) ')
+  output('lua_touserdata(tolua_S,-1);')
+ elseif static then
+  _,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
+ end
+ -- check index
+        output('#ifndef TOLUA_RELEASE\n')
+        output(' {')
+        output('  tolua_Error tolua_err;')
+ output('  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))')
+ output('   tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);')
+        output(' }')
+        output('#endif\n')
+        if flags['1'] then -- for compatibility with tolua5 ?
+                output(' tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;')
+        else
+                output(' tolua_index = (int)tolua_tonumber(tolua_S,2,0);')
+        end
+        output('#ifndef TOLUA_RELEASE\n')
+        if self.dim and self.dim ~= '' then
+          output(' if (tolua_index<0 || tolua_index>='..self.dim..')')
+        else
+          output(' if (tolua_index<0)')
+        end
+ output('  tolua_error(tolua_S,"array indexing out of range.",NULL);')
+        output('#endif\n')
+ -- return value
+ local t,ct = isbasic(self.type)
+ if t then
+  output(' tolua_push'..t..'(tolua_S,(',ct,')'..self:getvalue(class,static)..');')
+ else
+                t = self.type
+  if self.ptr == '&' or self.ptr == '' then
+   output(' tolua_pushusertype(tolua_S,(void*)&'..self:getvalue(class,static)..',"',t,'");')
+  else
+   output(' tolua_pushusertype(tolua_S,(void*)'..self:getvalue(class,static)..',"',t,'");')
+  end
+ end
+ output(' return 1;')
+ output('}')
+ output('#endif //#ifndef TOLUA_DISABLE\n')
+ output('\n')
+ -- set function ------------------------------------------------
+ if not strfind(self.type,'const') then
+  if class then
+   output("/* set function:",self.name," of class ",class," */")
+  else
+   output("/* set function:",self.name," */")
+  end
+  self.csetname = self:cfuncname("tolua_set")
+  output("#ifndef TOLUA_DISABLE_"..self.csetname)
+  output("\nstatic int",self.csetname,"(lua_State* tolua_S)")
+  output("{")
+  -- declare index
+  output(' int tolua_index;')
+  -- declare self, if the case
+  local _,_,static = strfind(self.mod,'^%s*(static)')
+  if class and static==nil then
+   output(' ',self.parent.type,'*','self;')
+   output(' lua_pushstring(tolua_S,".self");')
+   output(' lua_rawget(tolua_S,1);')
+   output(' self = ')
+   output('(',self.parent.type,'*) ')
+   output('lua_touserdata(tolua_S,-1);')
+  elseif static then
+   _,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
+  end
+  -- check index
+         output('#ifndef TOLUA_RELEASE\n')
+         output(' {')
+         output('  tolua_Error tolua_err;')
+  output('  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))')
+  output('   tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);')
+                output(' }')
+                output('#endif\n')
+        if flags['1'] then -- for compatibility with tolua5 ?
+                output(' tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;')
+        else
+                output(' tolua_index = (int)tolua_tonumber(tolua_S,2,0);')
+        end
+         output('#ifndef TOLUA_RELEASE\n')
+        if self.dim and self.dim ~= '' then
+          output(' if (tolua_index<0 || tolua_index>='..self.dim..')')
+        else
+          output(' if (tolua_index<0)')
+        end
+  output('  tolua_error(tolua_S,"array indexing out of range.",NULL);')
+                output('#endif\n')
+  -- assign value
+  local ptr = ''
+  if self.ptr~='' then ptr = '*' end
+  output(' ')
+  if class and static then
+   output(class..'::'..self.name..'[tolua_index]')
+  elseif class then
+   output('self->'..self.name..'[tolua_index]')
+  else
+   output(self.name..'[tolua_index]')
+  end
+  local t = isbasic(self.type)
+  output(' = ')
+  if not t and ptr=='' then output('*') end
+  output('((',self.mod,self.type)
+  if not t then
+   output('*')
+  end
+  output(') ')
+  local def = 0
+  if self.def ~= '' then def = self.def end
+  if t then
+   output('tolua_to'..t,'(tolua_S,3,',def,'));')
+  else
+   output('tolua_tousertype(tolua_S,3,',def,'));')
+  end
+  output(' return 0;')
+  output('}')
+  output('#endif //#ifndef TOLUA_DISABLE\n')
+  output('\n')
+ end
+    local class = self:inclass()
+    -- get function ------------------------------------------------
+    if class then
+        output("/* get function:",self.name," of class ",class," */")
+    else
+        output("/* get function:",self.name," */")
+    end
+    self.cgetname = self:cfuncname("tolua_get")
+    output("#ifndef TOLUA_DISABLE_"..self.cgetname)
+    output("\nstatic int",self.cgetname,"(lua_State* tolua_S)")
+    output("{")
+    output(" int tolua_index;")
+    -- declare self, if the case
+    local _,_,static = strfind(self.mod,'^%s*(static)')
+    if class and static==nil then
+        output(' ',self.parent.type,'*','self;')
+        output(' lua_pushstring(tolua_S,".self");')
+        output(' lua_rawget(tolua_S,1);')
+        output(' self = ')
+        output('(',self.parent.type,'*) ')
+        output('lua_touserdata(tolua_S,-1);')
+    elseif static then
+        _,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
+    end
+    -- check index
+    output('#ifndef TOLUA_RELEASE\n')
+    output(' {')
+    output('  tolua_Error tolua_err;')
+    output('  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))')
+    output('   tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);')
+    output(' }')
+    output('#endif\n')
+    if flags['1'] then -- for compatibility with tolua5 ?
+        output(' tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;')
+    else
+        output(' tolua_index = (int)tolua_tonumber(tolua_S,2,0);')
+    end
+    output('#ifndef TOLUA_RELEASE\n')
+    if self.dim and self.dim ~= '' then
+        output(' if (tolua_index<0 || tolua_index>='..self.dim..')')
+    else
+        output(' if (tolua_index<0)')
+    end
+    output('  tolua_error(tolua_S,"array indexing out of range.",NULL);')
+    output('#endif\n')
+    -- return value
+    local t,ct = isbasic(self.type)
+    if t then
+        output(' tolua_push'..t..'(tolua_S,(',ct,')'..self:getvalue(class,static)..');')
+    else
+        t = self.type
+        if self.ptr == '&' or self.ptr == '' then
+            output(' tolua_pushusertype(tolua_S,(void*)&'..self:getvalue(class,static)..',"',t,'");')
+        else
+            output(' tolua_pushusertype(tolua_S,(void*)'..self:getvalue(class,static)..',"',t,'");')
+        end
+    end
+    output(' return 1;')
+    output('}')
+    output('#endif //#ifndef TOLUA_DISABLE\n')
+    output('\n')
+    -- set function ------------------------------------------------
+    if not strfind(self.type,'const') then
+        if class then
+            output("/* set function:",self.name," of class ",class," */")
+        else
+            output("/* set function:",self.name," */")
+        end
+        self.csetname = self:cfuncname("tolua_set")
+        output("#ifndef TOLUA_DISABLE_"..self.csetname)
+        output("\nstatic int",self.csetname,"(lua_State* tolua_S)")
+        output("{")
+        -- declare index
+        output(' int tolua_index;')
+        -- declare self, if the case
+        local _,_,static = strfind(self.mod,'^%s*(static)')
+        if class and static==nil then
+            output(' ',self.parent.type,'*','self;')
+            output(' lua_pushstring(tolua_S,".self");')
+            output(' lua_rawget(tolua_S,1);')
+            output(' self = ')
+            output('(',self.parent.type,'*) ')
+            output('lua_touserdata(tolua_S,-1);')
+        elseif static then
+            _,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
+        end
+        -- check index
+        output('#ifndef TOLUA_RELEASE\n')
+        output(' {')
+        output('  tolua_Error tolua_err;')
+        output('  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))')
+        output('   tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);')
+        output(' }')
+        output('#endif\n')
+        if flags['1'] then -- for compatibility with tolua5 ?
+            output(' tolua_index = (int)tolua_tonumber(tolua_S,2,0)-1;')
+        else
+            output(' tolua_index = (int)tolua_tonumber(tolua_S,2,0);')
+        end
+        output('#ifndef TOLUA_RELEASE\n')
+        if self.dim and self.dim ~= '' then
+            output(' if (tolua_index<0 || tolua_index>='..self.dim..')')
+        else
+            output(' if (tolua_index<0)')
+        end
+        output('  tolua_error(tolua_S,"array indexing out of range.",NULL);')
+        output('#endif\n')
+        -- assign value
+        local ptr = ''
+        if self.ptr~='' then ptr = '*' end
+            output(' ')
+        if class and static then
+            output(class..'::'..self.name..'[tolua_index]')
+        elseif class then
+            output('self->'..self.name..'[tolua_index]')
+        else
+            output(self.name..'[tolua_index]')
+        end
+        local t = isbasic(self.type)
+        output(' = ')
+        if not t and ptr=='' then output('*') end
+        output('((',self.mod,self.type)
+        if not t then
+            output('*')
+        end
+        output(') ')
+        local def = 0
+        if self.def ~= '' then def = self.def end
+        if t then
+            output('tolua_to'..t,'(tolua_S,3,',def,'));')
+        else
+            output('tolua_tousertype(tolua_S,3,',def,'));')
+        end
+        output(' return 0;')
+        output('}')
+        output('#endif //#ifndef TOLUA_DISABLE\n')
+        output('\n')
+    end
 end
 function classArray:register (pre)
  pre = pre or ''
  if self.csetname then
   output(pre..'tolua_array(tolua_S,"'..self.lname..'",'..self.cgetname..','..self.csetname..');')
  else
   output(pre..'tolua_array(tolua_S,"'..self.lname..'",'..self.cgetname..',NULL);')
  end
+    pre = pre or ''
+    if self.csetname then
+        output(pre..'tolua_array(tolua_S,"'..self.lname..'",'..self.cgetname..','..self.csetname..');')
+    else
+        output(pre..'tolua_array(tolua_S,"'..self.lname..'",'..self.cgetname..',NULL);')
+    end
 end
 -- Internal constructor
 function _Array (t)
  setmetatable(t,classArray)
  append(t)
  return t
+    setmetatable(t,classArray)
+    append(t)
+    return t
 end
 …
 -- Expects a string representing the variable declaration.
 function Array (s)
  return _Array (Declaration(s,'var'))
 end
+    return _Array (Declaration(s,'var'))
+end

code/branches/buildsystem2/src/tolua/lua/basic.lua

-                      r2087
+                      r2509
 -- and all occurrences of "void*" will be replaced by "_userdata"
 _basic = {
  ['void'] = '',
  ['char'] = 'number',
  ['int'] = 'number',
  ['short'] = 'number',
  ['long'] = 'number',
  ['unsigned'] = 'number',
  ['float'] = 'number',
  ['double'] = 'number',
  ['_cstring'] = 'string',
  ['_userdata'] = 'userdata',
  ['char*'] = 'string',
  ['void*'] = 'userdata',
  ['bool'] = 'boolean',
  ['lua_Object'] = 'value',
  ['LUA_VALUE'] = 'value',    -- for compatibility with tolua 4.0
  ['lua_State*'] = 'state',
  ['_lstate'] = 'state',
  ['lua_Function'] = 'value',
+    ['void'] = '',
+    ['char'] = 'number',
+    ['int'] = 'number',
+    ['short'] = 'number',
+    ['long'] = 'number',
+    ['unsigned'] = 'number',
+    ['float'] = 'number',
+    ['double'] = 'number',
+    ['_cstring'] = 'string',
+    ['_userdata'] = 'userdata',
+    ['char*'] = 'string',
+    ['void*'] = 'userdata',
+    ['bool'] = 'boolean',
+    ['lua_Object'] = 'value',
+    ['LUA_VALUE'] = 'value',    -- for compatibility with tolua 4.0
+    ['lua_State*'] = 'state',
+    ['_lstate'] = 'state',
+    ['lua_Function'] = 'value',
+}
 _basic_ctype = {
  number = "lua_Number",
  string = "const char*",
  userdata = "void*",
  boolean = "bool",
  value = "int",
  state = "lua_State*",
+    number = "lua_Number",
+    string = "const char*",
+    userdata = "void*",
+    boolean = "bool",
+    value = "int",
+    state = "lua_State*",
+}
 …
 _renaming = {}
 function appendrenaming (s)
  local b,e,old,new = strfind(s,"%s*(.-)%s*@%s*(.-)%s*$")
         if not b then
          error("#Invalid renaming syntax; it should be of the form: pattern@pattern")
         end
         tinsert(_renaming,{old=old, new=new})
+    local b,e,old,new = strfind(s,"%s*(.-)%s*@%s*(.-)%s*$")
+    if not b then
+        error("#Invalid renaming syntax; it should be of the form: pattern@pattern")
+    end
+    tinsert(_renaming,{old=old, new=new})
 end
 function applyrenaming (s)
         for i=1,getn(_renaming) do
          local m,n = gsub(s,_renaming[i].old,_renaming[i].new)
                 if n ~= 0 then
                  return m
                 end
         end
         return nil
+    for i=1,getn(_renaming) do
+        local m,n = gsub(s,_renaming[i].old,_renaming[i].new)
+        if n ~= 0 then
+            return m
+        end
+    end
+    return nil
 end
 -- Error handler
 function tolua_error (s,f)
 if _curr_code then
         print("***curr code for error is "..tostring(_curr_code))
         print(debug.traceback())
 end
  local out = _OUTPUT
  _OUTPUT = _STDERR
  if strsub(s,1,1) == '#' then
   write("\n** tolua: "..strsub(s,2)..".\n\n")
   if _curr_code then
    local _,_,s = strfind(_curr_code,"^%s*(.-\n)") -- extract first line
    if s==nil then s = _curr_code end
    s = gsub(s,"_userdata","void*") -- return with 'void*'
    s = gsub(s,"_cstring","char*")  -- return with 'char*'
    s = gsub(s,"_lstate","lua_State*")  -- return with 'lua_State*'
    write("Code being processed:\n"..s.."\n")
   end
  else
  if not f then f = "(f is nil)" end
   print("\n** tolua internal error: "..f..s..".\n\n")
   return
  end
  _OUTPUT = out
+    if _curr_code then
+        print("***curr code for error is "..tostring(_curr_code))
+        print(debug.traceback())
+    end
+    local out = _OUTPUT
+    _OUTPUT = _STDERR
+    if strsub(s,1,1) == '#' then
+        write("\n** tolua: "..strsub(s,2)..".\n\n")
+        if _curr_code then
+            local _,_,s = strfind(_curr_code,"^%s*(.-\n)") -- extract first line
+            if s==nil then s = _curr_code end
+            s = gsub(s,"_userdata","void*") -- return with 'void*'
+            s = gsub(s,"_cstring","char*")  -- return with 'char*'
+            s = gsub(s,"_lstate","lua_State*")  -- return with 'lua_State*'
+            write("Code being processed:\n"..s.."\n")
+        end
+    else
+        if not f then f = "(f is nil)" end
+        print("\n** tolua internal error: "..f..s..".\n\n")
+        return
+    end
+    _OUTPUT = out
 end
 function warning (msg)
  local out = _OUTPUT
  _OUTPUT = _STDERR
  write("\n** tolua warning: "..msg..".\n\n")
  _OUTPUT = out
+    local out = _OUTPUT
+    _OUTPUT = _STDERR
+    write("\n** tolua warning: "..msg..".\n\n")
+    _OUTPUT = out
 end
 -- register an user defined type: returns full type
 function regtype (t)
         --if isbasic(t) then
         --      return t
         --end
         local ft = findtype(t)
         if not _usertype[ft] then
                 return appendusertype(t)
         end
         return ft
+    --if isbasic(t) then
+    --    return t
+    --end
+    local ft = findtype(t)
+    if not _usertype[ft] then
+        return appendusertype(t)
+    end
+    return ft
 end
 -- return type name: returns full type
 function typevar(type)
         if type == '' or type == 'void' then
                 return type
         else
                 local ft = findtype(type)
                 if ft then
                         return ft
                 end
                 _usertype[type] = type
                 return type
         end
+    if type == '' or type == 'void' then
+        return type
+    else
+        local ft = findtype(type)
+        if ft then
+            return ft
+        end
+        _usertype[type] = type
+        return type
+    end
 end
 -- check if basic type
 function isbasic (type)
  local t = gsub(type,'const ','')
  local m,t = applytypedef('', t)
  local b = _basic[t]
  if b then
   return b,_basic_ctype[b]
  end
  return nil
+    local t = gsub(type,'const ','')
+    local m,t = applytypedef('', t)
+    local b = _basic[t]
+    if b then
+        return b,_basic_ctype[b]
+    end
+    return nil
 end
 -- split string using a token
 function split (s,t)
  local l = {n=0}
  local f = function (s)
   l.n = l.n + 1
   l[l.n] = s
   return ""
  end
  local p = "%s*(.-)%s*"..t.."%s*"
  s = gsub(s,"^%s+","")
  s = gsub(s,"%s+$","")
  s = gsub(s,p,f)
  l.n = l.n + 1
  l[l.n] = gsub(s,"(%s%s*)$","")
  return l
+    local l = {n=0}
+    local f = function (s)
+        l.n = l.n + 1
+        l[l.n] = s
+        return ""
+    end
+    local p = "%s*(.-)%s*"..t.."%s*"
+    s = gsub(s,"^%s+","")
+    s = gsub(s,"%s+$","")
+    s = gsub(s,p,f)
+    l.n = l.n + 1
+    l[l.n] = gsub(s,"(%s%s*)$","")
+    return l
 end
 …
 function split_c_tokens(s, pat)
         s = string.gsub(s, "^%s*", "")
         s = string.gsub(s, "%s*$", "")
         local token_begin = 1
         local token_end = 1
         local ofs = 1
         local ret = {n=0}
         function add_token(ofs)
                 local t = string.sub(s, token_begin, ofs)
                 t = string.gsub(t, "^%s*", "")
                 t = string.gsub(t, "%s*$", "")
                 ret.n = ret.n + 1
                 ret[ret.n] = t
         end
         while ofs <= string.len(s) do
                 local sub = string.sub(s, ofs, -1)
                 local b,e = string.find(sub, "^"..pat)
                 if b then
                         add_token(ofs-1)
                         ofs = ofs+e
                         token_begin = ofs
                 else
                         local char = string.sub(s, ofs, ofs)
                         if char == "(" or char == "<" then
                                 local block
                                 if char == "(" then block = "^%b()" end
                                 if char == "<" then block = "^%b<>" end
                                 b,e = string.find(sub, block)
                                 if not b then
                                         -- unterminated block?
                                         ofs = ofs+1
                                 else
                                         ofs = ofs + e
                                 end
                         else
                                 ofs = ofs+1
                         end
                 end
         end
         add_token(ofs)
         --if ret.n == 0 then
         --      ret.n=1
         --      ret[1] = ""
         --end
         return ret
+    s = string.gsub(s, "^%s*", "")
+    s = string.gsub(s, "%s*$", "")
+    local token_begin = 1
+    local token_end = 1
+    local ofs = 1
+    local ret = {n=0}
+    function add_token(ofs)
+        local t = string.sub(s, token_begin, ofs)
+        t = string.gsub(t, "^%s*", "")
+        t = string.gsub(t, "%s*$", "")
+        ret.n = ret.n + 1
+        ret[ret.n] = t
+    end
+    while ofs <= string.len(s) do
+        local sub = string.sub(s, ofs, -1)
+        local b,e = string.find(sub, "^"..pat)
+        if b then
+            add_token(ofs-1)
+            ofs = ofs+e
+            token_begin = ofs
+        else
+            local char = string.sub(s, ofs, ofs)
+            if char == "(" or char == "<" then
+                local block
+                if char == "(" then block = "^%b()" end
+                if char == "<" then block = "^%b<>" end
+                b,e = string.find(sub, block)
+                if not b then
+                    -- unterminated block?
+                    ofs = ofs+1
+                else
+                    ofs = ofs + e
+                end
+            else
+                ofs = ofs+1
+            end
+        end
+    end
+    add_token(ofs)
+    --if ret.n == 0 then
+    --    ret.n=1
+    --    ret[1] = ""
+    --end
+    return ret
 end
 …
 -- concatenate strings of a table
 function concat (t,f,l,jstr)
         jstr = jstr or " "
  local s = ''
  local i=f
  while i<=l do
   s = s..t[i]
   i = i+1
   if i <= l then s = s..jstr end
  end
  return s
+    jstr = jstr or " "
+    local s = ''
+    local i=f
+    while i<=l do
+        s = s..t[i]
+        i = i+1
+        if i <= l then s = s..jstr end
+    end
+    return s
 end
 -- concatenate all parameters, following output rules
 function concatparam (line, ...)
  local i=1
  while i<=arg.n do
   if _cont and not strfind(_cont,'[%(,"]') and
      strfind(arg[i],"^[%a_~]") then
             line = line .. ' '
   end
   line = line .. arg[i]
   if arg[i] ~= '' then
    _cont = strsub(arg[i],-1,-1)
   end
   i = i+1
  end
  if strfind(arg[arg.n],"[%/%)%;%{%}]$") then
   _cont=nil line = line .. '\n'
  end
         return line
+    local i=1
+    while i<=arg.n do
+        if _cont and not strfind(_cont,'[%(,"]') and
+            strfind(arg[i],"^[%a_~]") then
+            line = line .. ' '
+        end
+        line = line .. arg[i]
+        if arg[i] ~= '' then
+            _cont = strsub(arg[i],-1,-1)
+        end
+        i = i+1
+    end
+    if strfind(arg[arg.n],"[%/%)%;%{%}]$") then
+        _cont=nil line = line .. '\n'
+    end
+    return line
 end
 -- output line
 function output (...)
  local i=1
  while i<=arg.n do
   if _cont and not strfind(_cont,'[%(,"]') and
      strfind(arg[i],"^[%a_~]") then
             write(' ')
   end
   write(arg[i])
   if arg[i] ~= '' then
    _cont = strsub(arg[i],-1,-1)
   end
   i = i+1
  end
  if strfind(arg[arg.n],"[%/%)%;%{%}]$") then
   _cont=nil write('\n')
  end
+    local i=1
+    while i<=arg.n do
+        if _cont and not strfind(_cont,'[%(,"]') and
+            strfind(arg[i],"^[%a_~]") then
+            write(' ')
+        end
+        write(arg[i])
+        if arg[i] ~= '' then
+            _cont = strsub(arg[i],-1,-1)
+        end
+        i = i+1
+    end
+    if strfind(arg[arg.n],"[%/%)%;%{%}]$") then
+        _cont=nil write('\n')
+    end
 end
 function get_property_methods(ptype, name)
         if get_property_methods_hook and get_property_methods_hook(ptype,name) then
                 return get_property_methods_hook(ptype, name)
         end
         if ptype == "default" then -- get_name, set_name
                 return "get_"..name, "set_"..name
         end
         if ptype == "qt" then -- name, setName
                 return name, "set"..string.upper(string.sub(name, 1, 1))..string.sub(name, 2, -1)
         end
         if ptype == "overload" then -- name, name
                 return name,name
         end
         return nil
+    if get_property_methods_hook and get_property_methods_hook(ptype,name) then
+        return get_property_methods_hook(ptype, name)
+    end
+    if ptype == "default" then -- get_name, set_name
+        return "get_"..name, "set_"..name
+    end
+    if ptype == "qt" then -- name, setName
+        return name, "set"..string.upper(string.sub(name, 1, 1))..string.sub(name, 2, -1)
+    end
+    if ptype == "overload" then -- name, name
+        return name,name
+    end
+    return nil
 end
 …
 -- takes the package object as the parameter
 function preprocess_hook(p)
         -- p.code has all the input code from the pkg
+    -- p.code has all the input code from the pkg
 end
 …
 function parser_hook(s)
         return nil
 end
+    return nil
+end

code/branches/buildsystem2/src/tolua/lua/class.lua

-                      r2087
+                      r2509
 --    {i}  = list of members
 classClass = {
  classtype = 'class',
  name = '',
  base = '',
  type = '',
  btype = '',
  ctype = '',
+    classtype = 'class',
+    name = '',
+    base = '',
+    type = '',
+    btype = '',
+    ctype = '',
+}
 classClass.__index = classClass
 …
 -- register class
 function classClass:register (pre)
         if not self:check_public_access() then
                 return
         end
  pre = pre or ''
  push(self)
         if _collect[self.type] then
                 output(pre,'#ifdef __cplusplus\n')
   output(pre..'tolua_cclass(tolua_S,"'..self.lname..'","'..self.type..'","'..self.btype..'",'.._collect[self.type]..');')
                 output(pre,'#else\n')
   output(pre..'tolua_cclass(tolua_S,"'..self.lname..'","'..self.type..'","'..self.btype..'",NULL);')
                 output(pre,'#endif\n')
         else
   output(pre..'tolua_cclass(tolua_S,"'..self.lname..'","'..self.type..'","'..self.btype..'",NULL);')
         end
         if self.extra_bases then
                 for k,base in ipairs(self.extra_bases) do
                         -- not now
    --output(pre..' tolua_addbase(tolua_S, "'..self.type..'", "'..base..'");')
                 end
         end
  output(pre..'tolua_beginmodule(tolua_S,"'..self.lname..'");')
  local i=1
  while self[i] do
   self[i]:register(pre..' ')
   i = i+1
  end
  output(pre..'tolua_endmodule(tolua_S);')
         pop()
+    if not self:check_public_access() then
+        return
+    end
+    pre = pre or ''
+    push(self)
+    if _collect[self.type] then
+        output(pre,'#ifdef __cplusplus\n')
+        output(pre..'tolua_cclass(tolua_S,"'..self.lname..'","'..self.type..'","'..self.btype..'",'.._collect[self.type]..');')
+        output(pre,'#else\n')
+        output(pre..'tolua_cclass(tolua_S,"'..self.lname..'","'..self.type..'","'..self.btype..'",NULL);')
+        output(pre,'#endif\n')
+    else
+        output(pre..'tolua_cclass(tolua_S,"'..self.lname..'","'..self.type..'","'..self.btype..'",NULL);')
+    end
+    if self.extra_bases then
+        for k,base in ipairs(self.extra_bases) do
+            -- not now
+            --output(pre..' tolua_addbase(tolua_S, "'..self.type..'", "'..base..'");')
+        end
+    end
+    output(pre..'tolua_beginmodule(tolua_S,"'..self.lname..'");')
+    local i=1
+    while self[i] do
+        self[i]:register(pre..' ')
+        i = i+1
+    end
+    output(pre..'tolua_endmodule(tolua_S);')
+    pop()
 end
 -- return collection requirement
 function classClass:requirecollection (t)
         if self.flags.protected_destructor then
                 return false
         end
  push(self)
         local r = false
  local i=1
  while self[i] do
   r = self[i]:requirecollection(t) or r
   i = i+1
  end
         pop()
         -- only class that exports destructor can be appropriately collected
         -- classes that export constructors need to have a collector (overrided by -D flag on command line)
         if self._delete or ((not flags['D']) and self._new) then
                 --t[self.type] = "tolua_collect_" .. gsub(self.type,"::","_")
                 t[self.type] = "tolua_collect_" .. clean_template(self.type)
                 r = true
         end
  return r
+    if self.flags.protected_destructor then
+        return false
+    end
+    push(self)
+    local r = false
+    local i=1
+    while self[i] do
+        r = self[i]:requirecollection(t) or r
+        i = i+1
+    end
+    pop()
+    -- only class that exports destructor can be appropriately collected
+    -- classes that export constructors need to have a collector (overrided by -D flag on command line)
+    if self._delete or ((not flags['D']) and self._new) then
+        --t[self.type] = "tolua_collect_" .. gsub(self.type,"::","_")
+        t[self.type] = "tolua_collect_" .. clean_template(self.type)
+        r = true
+    end
+    return r
 end
 -- output tags
 function classClass:decltype ()
  push(self)
         self.type = regtype(self.original_name or self.name)
         self.btype = typevar(self.base)
         self.ctype = 'const '..self.type
         if self.extra_bases then
                 for i=1,table.getn(self.extra_bases) do
                         self.extra_bases[i] = typevar(self.extra_bases[i])
                 end
         end
  local i=1
  while self[i] do
   self[i]:decltype()
   i = i+1
  end
         pop()
+    push(self)
+    self.type = regtype(self.original_name or self.name)
+    self.btype = typevar(self.base)
+    self.ctype = 'const '..self.type
+    if self.extra_bases then
+        for i=1,table.getn(self.extra_bases) do
+            self.extra_bases[i] = typevar(self.extra_bases[i])
+        end
+    end
+    local i=1
+    while self[i] do
+        self[i]:decltype()
+        i = i+1
+    end
+    pop()
 end
 …
 -- Print method
 function classClass:print (ident,close)
  print(ident.."Class{")
  print(ident.." name = '"..self.name.."',")
  print(ident.." base = '"..self.base.."';")
  print(ident.." lname = '"..self.lname.."',")
  print(ident.." type = '"..self.type.."',")
  print(ident.." btype = '"..self.btype.."',")
  print(ident.." ctype = '"..self.ctype.."',")
  local i=1
  while self[i] do
   self[i]:print(ident.." ",",")
   i = i+1
  end
  print(ident.."}"..close)
+    print(ident.."Class{")
+    print(ident.." name = '"..self.name.."',")
+    print(ident.." base = '"..self.base.."';")
+    print(ident.." lname = '"..self.lname.."',")
+    print(ident.." type = '"..self.type.."',")
+    print(ident.." btype = '"..self.btype.."',")
+    print(ident.." ctype = '"..self.ctype.."',")
+    local i=1
+    while self[i] do
+        self[i]:print(ident.." ",",")
+        i = i+1
+    end
+    print(ident.."}"..close)
 end
 function classClass:set_protected_destructor(p)
         self.flags.protected_destructor = self.flags.protected_destructor or p
+self.flags.protected_destructor = self.flags.protected_destructor or p
 end
 -- Internal constructor
 function _Class (t)
  setmetatable(t,classClass)
  t:buildnames()
  append(t)
  return t
+    setmetatable(t,classClass)
+    t:buildnames()
+    append(t)
+    return t
 end
 …
 function Class (n,p,b)
         if table.getn(p) > 1 then
                 b = string.sub(b, 1, -2)
                 for i=2,table.getn(p),1 do
                         b = b.."\n tolua_inherits "..p[i].." __"..p[i].."__;\n"
                 end
                 b = b.."\n}"
         end
         -- check for template
         b = string.gsub(b, "^{%s*TEMPLATE_BIND", "{\nTOLUA_TEMPLATE_BIND")
         local t,_,T,I = string.find(b, "^{%s*TOLUA_TEMPLATE_BIND%s*%(+%s*\"?([^\",]*)\"?%s*,%s*([^%)]*)%s*%)+")
         if t then
                 -- remove quotes
                 I = string.gsub(I, "\"", "")
                 T = string.gsub(T, "\"", "")
                 -- get type list
                 local types = split_c_tokens(I, ",")
                 -- remove TEMPLATE_BIND line
                 local bs = string.gsub(b, "^{%s*TOLUA_TEMPLATE_BIND[^\n]*\n", "{\n")
                 -- replace
                 for i =1 , types.n do
                         local Tl = split(T, " ")
                         local Il = split_c_tokens(types[i], " ")
                         local bI = bs
                         local pI = {}
                         for j = 1,Tl.n do
                                 Tl[j] = findtype(Tl[j]) or Tl[j]
                                 bI = string.gsub(bI, "([^_%w])"..Tl[j].."([^_%w])", "%1"..Il[j].."%2")
                                 if p then
                                         for i=1,table.getn(p) do
                                                 pI[i] = string.gsub(p[i], "([^_%w]?)"..Tl[j].."([^_%w]?)", "%1"..Il[j].."%2")
                                         end
                                 end
                         end
                         --local append = "<"..string.gsub(types[i], "%s+", ",")..">"
                         local append = "<"..concat(Il, 1, table.getn(Il), ",")..">"
                         append = string.gsub(append, "%s*,%s*", ",")
                         append = string.gsub(append, ">>", "> >")
                         for i=1,table.getn(pI) do
                                 --pI[i] = string.gsub(pI[i], ">>", "> >")
                                 pI[i] = resolve_template_types(pI[i])
                         end
                         bI = string.gsub(bI, ">>", "> >")
                         Class(n..append, pI, bI)
                 end
                 return
         end
         local mbase
         if p then
                 mbase = table.remove(p, 1)
                 if not p[1] then p = nil end
         end
         mbase = mbase and resolve_template_types(mbase)
         local c
         local oname = string.gsub(n, "@.*$", "")
         oname = getnamespace(classContainer.curr)..oname
         if _global_classes[oname] then
                 c = _global_classes[oname]
                 if mbase and ((not c.base) or c.base == "") then
                         c.base = mbase
                 end
         else
                 c = _Class(_Container{name=n, base=mbase, extra_bases=p})
                 local ft = getnamespace(c.parent)..c.original_name
                 append_global_type(ft, c)
         end
         push(c)
         c:parse(strsub(b,2,strlen(b)-1)) -- eliminate braces
         pop()
 end
+    if table.getn(p) > 1 then
+        b = string.sub(b, 1, -2)
+        for i=2,table.getn(p),1 do
+            b = b.."\n tolua_inherits "..p[i].." __"..p[i].."__;\n"
+        end
+        b = b.."\n}"
+    end
+    -- check for template
+    b = string.gsub(b, "^{%s*TEMPLATE_BIND", "{\nTOLUA_TEMPLATE_BIND")
+    local t,_,T,I = string.find(b, "^{%s*TOLUA_TEMPLATE_BIND%s*%(+%s*\"?([^\",]*)\"?%s*,%s*([^%)]*)%s*%)+")
+    if t then
+        -- remove quotes
+        I = string.gsub(I, "\"", "")
+        T = string.gsub(T, "\"", "")
+        -- get type list
+        local types = split_c_tokens(I, ",")
+        -- remove TEMPLATE_BIND line
+        local bs = string.gsub(b, "^{%s*TOLUA_TEMPLATE_BIND[^\n]*\n", "{\n")
+        -- replace
+        for i =1 , types.n do
+            local Tl = split(T, " ")
+            local Il = split_c_tokens(types[i], " ")
+            local bI = bs
+            local pI = {}
+            for j = 1,Tl.n do
+                Tl[j] = findtype(Tl[j]) or Tl[j]
+                bI = string.gsub(bI, "([^_%w])"..Tl[j].."([^_%w])", "%1"..Il[j].."%2")
+                if p then
+                    for i=1,table.getn(p) do
+                        pI[i] = string.gsub(p[i], "([^_%w]?)"..Tl[j].."([^_%w]?)", "%1"..Il[j].."%2")
+                    end
+                end
+            end
+            --local append = "<"..string.gsub(types[i], "%s+", ",")..">"
+            local append = "<"..concat(Il, 1, table.getn(Il), ",")..">"
+            append = string.gsub(append, "%s*,%s*", ",")
+            append = string.gsub(append, ">>", "> >")
+            for i=1,table.getn(pI) do
+                --pI[i] = string.gsub(pI[i], ">>", "> >")
+                pI[i] = resolve_template_types(pI[i])
+            end
+            bI = string.gsub(bI, ">>", "> >")
+            Class(n..append, pI, bI)
+        end
+        return
+    end
+    local mbase
+    if p then
+        mbase = table.remove(p, 1)
+        if not p[1] then p = nil end
+    end
+    mbase = mbase and resolve_template_types(mbase)
+    local c
+    local oname = string.gsub(n, "@.*$", "")
+    oname = getnamespace(classContainer.curr)..oname
+    if _global_classes[oname] then
+        c = _global_classes[oname]
+        if mbase and ((not c.base) or c.base == "") then
+            c.base = mbase
+        end
+    else
+        c = _Class(_Container{name=n, base=mbase, extra_bases=p})
+        local ft = getnamespace(c.parent)..c.original_name
+        append_global_type(ft, c)
+    end
+    push(c)
+    c:parse(strsub(b,2,strlen(b)-1)) -- eliminate braces
+    pop()
+end

code/branches/buildsystem2/src/tolua/lua/clean.lua

-                      r2087
+                      r2509
 MASK = { -- the substitution order is important
  {ESC1, "\\'"},
  {ESC2, '\\"'},
  {STR1, "'"},
  {STR2, '"'},
  {STR3, "%[%["},
  {STR4, "%]%]"},
  {REM , "%-%-"},
+    {ESC1, "\\'"},
+    {ESC2, '\\"'},
+    {STR1, "'"},
+    {STR2, '"'},
+    {STR3, "%[%["},
+    {STR4, "%]%]"},
+    {REM , "%-%-"},
+}
 function mask (s)
  for i = 1,getn(MASK)  do
   s = gsub(s,MASK[i][2],MASK[i][1])
  end
  return s
+    for i = 1,getn(MASK)  do
+        s = gsub(s,MASK[i][2],MASK[i][1])
+    end
+    return s
 end
 function unmask (s)
  for i = 1,getn(MASK)  do
   s = gsub(s,MASK[i][1],MASK[i][2])
  end
  return s
+    for i = 1,getn(MASK)  do
+        s = gsub(s,MASK[i][1],MASK[i][2])
+    end
+    return s
 end
 function clean (s)
  -- check for compilation error
  local code = "return function ()\n" .. s .. "\n end"
  if not dostring(code) then
   return nil
  end
+    -- check for compilation error
+    local code = "return function ()\n" .. s .. "\n end"
+    if not dostring(code) then
+        return nil
+    end
  if flags['C'] then
         return s
  end
+    if flags['C'] then
+        return s
+    end
  local S = "" -- saved string
+    local S = "" -- saved string
  s = mask(s)
+    s = mask(s)
  -- remove blanks and comments
  while 1 do
   local b,e,d = strfind(s,ANY)
   if b then
    S = S..strsub(s,1,b-1)
    s = strsub(s,b+1)
    if d==STR1 or d==STR2 then
     e = strfind(s,d)
     S = S ..d..strsub(s,1,e)
     s = strsub(s,e+1)
    elseif d==STR3 then
     e = strfind(s,STR4)
     S = S..d..strsub(s,1,e)
     s = strsub(s,e+1)
    elseif d==REM then
     s = gsub(s,"[^\n]*(\n?)","%1",1)
    end
   else
    S = S..s
    break
   end
  end
  -- eliminate unecessary spaces
  S = gsub(S,"[ \t]+"," ")
  S = gsub(S,"[ \t]*\n[ \t]*","\n")
         S = gsub(S,"\n+","\n")
  S = unmask(S)
  return S
+    -- remove blanks and comments
+    while 1 do
+        local b,e,d = strfind(s,ANY)
+        if b then
+            S = S..strsub(s,1,b-1)
+            s = strsub(s,b+1)
+            if d==STR1 or d==STR2 then
+                e = strfind(s,d)
+                S = S ..d..strsub(s,1,e)
+                s = strsub(s,e+1)
+            elseif d==STR3 then
+                e = strfind(s,STR4)
+                S = S..d..strsub(s,1,e)
+                s = strsub(s,e+1)
+            elseif d==REM then
+                s = gsub(s,"[^\n]*(\n?)","%1",1)
+            end
+        else
+            S = S..s
+            break
+        end
+    end
+    -- eliminate unecessary spaces
+    S = gsub(S,"[ \t]+"," ")
+    S = gsub(S,"[ \t]*\n[ \t]*","\n")
+    S = gsub(S,"\n+","\n")
+    S = unmask(S)
+    return S
 end

code/branches/buildsystem2/src/tolua/lua/code.lua

-                      r2087
+                      r2509
 --   text = text code
 classCode = {
  text = '',
+    text = '',
+}
 classCode.__index = classCode
 …
 -- register code
 function classCode:register (pre)
  pre = pre or ''
  -- clean Lua code
  local s = clean(self.text)
  if not s then
   --print(self.text)
   error("parser error in embedded code")
  end
+    pre = pre or ''
+    -- clean Lua code
+    local s = clean(self.text)
+    if not s then
+        --print(self.text)
+        error("parser error in embedded code")
+    end
  -- get first line
  local _, _, first_line=string.find(self.text, "^([^\n\r]*)")
  if string.find(first_line, "^%s*%-%-") then
          if string.find(first_line, "^%-%-##") then
                 first_line = string.gsub(first_line, "^%-%-##", "")
                 if flags['C'] then
                         s = string.gsub(s, "^%-%-##[^\n\r]*\n", "")
                 end
          end
  else
         first_line = ""
  end
+    -- get first line
+    local _, _, first_line=string.find(self.text, "^([^\n\r]*)")
+    if string.find(first_line, "^%s*%-%-") then
+        if string.find(first_line, "^%-%-##") then
+            first_line = string.gsub(first_line, "^%-%-##", "")
+            if flags['C'] then
+                s = string.gsub(s, "^%-%-##[^\n\r]*\n", "")
+            end
+        end
+    else
+        first_line = ""
+    end
+ -- convert to C
+ output('\n'..pre..'{ /* begin embedded lua code */\n')
+ output(pre..' int top = lua_gettop(tolua_S);')
+ output(pre..' static unsigned char B[] = {\n   ')
+ local t={n=0}
+ local b = gsub(s,'(.)',function (c)
+                         local e = ''
+                         t.n=t.n+1 if t.n==15 then t.n=0 e='\n'..pre..'  ' end
+                         return format('%3u,%s',strbyte(c),e)
+                        end
+               )
+ output(b..strbyte(" "))
+ output('\n'..pre..' };\n')
+ if first_line and first_line ~= "" then
+        output(pre..' tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua embedded: '..first_line..'");')
+ else
+        output(pre..' tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code '..code_n..'");')
+ end
+ output(pre..' lua_settop(tolua_S, top);')
+ output(pre..'} /* end of embedded lua code */\n\n')
+ code_n = code_n +1
+    -- convert to C
+    output('\n'..pre..'{ /* begin embedded lua code */\n')
+    output(pre..' int top = lua_gettop(tolua_S);')
+    output(pre..' static unsigned char B[] = {\n   ')
+    local t={n=0}
+    local b = gsub(s, '(.)',
+        function (c)
+            local e = ''
+            t.n=t.n+1
+            if t.n==15 then
+             t.n=0 e='\n'..pre..'  '
+            end
+            return format('%3u,%s',strbyte(c),e)
+        end
+    )
+    output(b..strbyte(" "))
+    output('\n'..pre..' };\n')
+    if first_line and first_line ~= "" then
+        output(pre..' tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua embedded: '..first_line..'");')
+    else
+        output(pre..' tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code '..code_n..'");')
+    end
+    output(pre..' lua_settop(tolua_S, top);')
+    output(pre..'} /* end of embedded lua code */\n\n')
+    code_n = code_n +1
 end
 …
 -- Print method
 function classCode:print (ident,close)
  print(ident.."Code{")
  print(ident.." text = [["..self.text.."]],")
  print(ident.."}"..close)
+    print(ident.."Code{")
+    print(ident.." text = [["..self.text.."]],")
+    print(ident.."}"..close)
 end
 …
 -- Internal constructor
 function _Code (t)
  setmetatable(t,classCode)
  append(t)
  return t
+    setmetatable(t,classCode)
+    append(t)
+    return t
 end
 …
 -- Expects a string representing the code text
 function Code (l)
  return _Code {
   text = l
+ }
+    return _Code {
+        text = l
+    }
 end

code/branches/buildsystem2/src/tolua/lua/compat-5.1.lua

-                      r2087
+                      r2509
 if string.find(_VERSION, "5%.0") then
         return
+    return
 end
 -- "loadfile"
 local function pp_dofile(path)
+    local loaded = false
+    local getfile = function()
+        local loaded = false
+        local getfile = function()
+        if loaded then
+            return
+        else
+            local file,err = io.open(path)
+            if not file then
+                error("error loading file "..path..": "..err)
+            end
+            local ret = file:read("*a")
+            file:close()
+                if loaded then
+                        return
+                else
+                        local file,err = io.open(path)
+                        if not file then
+                                error("error loading file "..path..": "..err)
+                        end
+                        local ret = file:read("*a")
+                        file:close()
+            ret = string.gsub(ret, "%.%.%.%s*%)", "...) local arg = {n=select('#', ...), ...};")
+                        ret = string.gsub(ret, "%.%.%.%s*%)", "...) local arg = {n=select('#', ...), ...};")
+            loaded = true
+            return ret
+        end
+    end
+                        loaded = true
+                        return ret
+                end
+        end
+        local f = load(getfile, path)
+        return f()
+    local f = load(getfile, path)
+    return f()
 end
 …
 local ogsub = string.gsub
 local function compgsub(a,b,c,d)
   if type(c) == "function" then
     local oc = c
     c = function (...) return oc(...) or '' end
   end
   return ogsub(a,b,c,d)
+    if type(c) == "function" then
+        local oc = c
+        c = function (...) return oc(...) or '' end
+    end
+    return ogsub(a,b,c,d)
 end
 string.repl = ogsub

code/branches/buildsystem2/src/tolua/lua/compat.lua

-                      r2087
+                      r2509
 function do_ (f, err)
   if not f then print(err); return end
   local a,b = pcall(f)
   if not a then print(b); return nil
   else return b or true
   end
+    if not f then print(err); return end
+    local a,b = pcall(f)
+    if not a then print(b); return nil
+    else return b or true
+    end
 end
 …
 function flush (f)
   if f then f:flush()
   else _OUTPUT:flush()
   end
+    if f then f:flush()
+    else _OUTPUT:flush()
+    end
 end
 function readfrom (name)
   if name == nil then
     local f, err, cod = io.close(_INPUT)
     _INPUT = io.stdin
     return f, err, cod
   else
     local f, err, cod = io.open(name, "r")
     _INPUT = f or _INPUT
     return f, err, cod
   end
+    if name == nil then
+        local f, err, cod = io.close(_INPUT)
+        _INPUT = io.stdin
+        return f, err, cod
+    else
+        local f, err, cod = io.open(name, "r")
+        _INPUT = f or _INPUT
+        return f, err, cod
+    end
 end
 function writeto (name)
   if name == nil then
     local f, err, cod = io.close(_OUTPUT)
     _OUTPUT = io.stdout
     return f, err, cod
   else
     local f, err, cod = io.open(name, "w")
     _OUTPUT = f or _OUTPUT
     return f, err, cod
   end
+    if name == nil then
+        local f, err, cod = io.close(_OUTPUT)
+        _OUTPUT = io.stdout
+        return f, err, cod
+    else
+        local f, err, cod = io.open(name, "w")
+        _OUTPUT = f or _OUTPUT
+        return f, err, cod
+    end
 end
 function appendto (name)
   local f, err, cod = io.open(name, "a")
   _OUTPUT = f or _OUTPUT
   return f, err, cod
+    local f, err, cod = io.open(name, "a")
+    _OUTPUT = f or _OUTPUT
+    return f, err, cod
 end
 function read (...)
   local f = _INPUT
   if rawtype(arg[1]) == 'userdata' then
     f = tab.remove(arg, 1)
   end
   return f:read(unpack(arg))
+    local f = _INPUT
+    if rawtype(arg[1]) == 'userdata' then
+        f = tab.remove(arg, 1)
+    end
+    return f:read(unpack(arg))
 end
 function write (...)
   local f = _OUTPUT
   if rawtype(arg[1]) == 'userdata' then
     f = tab.remove(arg, 1)
   end
   return f:write(unpack(arg))
+    local f = _OUTPUT
+    if rawtype(arg[1]) == 'userdata' then
+        f = tab.remove(arg, 1)
+    end
+    return f:write(unpack(arg))
 end

code/branches/buildsystem2/src/tolua/lua/container.lua

-                      r2087
+                      r2509
 classContainer =
+{
  curr = nil,
+    curr = nil,
+}
 classContainer.__index = classContainer
 …
 -- output tags
 function classContainer:decltype ()
  push(self)
  local i=1
  while self[i] do
   self[i]:decltype()
   i = i+1
  end
  pop()
+    push(self)
+    local i=1
+    while self[i] do
+        self[i]:decltype()
+        i = i+1
+    end
+    pop()
 end
 …
 function classContainer:supcode ()
         if not self:check_public_access() then
                 return
         end
  push(self)
  local i=1
  while self[i] do
   if self[i]:check_public_access() then
         self[i]:supcode()
   end
   i = i+1
  end
  pop()
+    if not self:check_public_access() then
+        return
+    end
+    push(self)
+    local i=1
+    while self[i] do
+        if self[i]:check_public_access() then
+            self[i]:supcode()
+        end
+        i = i+1
+    end
+    pop()
 end
 function classContainer:hasvar ()
  local i=1
  while self[i] do
   if self[i]:isvariable() then
                  return 1
                 end
   i = i+1
  end
         return 0
+    local i=1
+    while self[i] do
+        if self[i]:isvariable() then
+            return 1
+        end
+        i = i+1
+    end
+    return 0
 end
 -- Internal container constructor
 function _Container (self)
  setmetatable(self,classContainer)
  self.n = 0
  self.typedefs = {tolua_n=0}
  self.usertypes = {}
  self.enums = {tolua_n=0}
  self.lnames = {}
  return self
+    setmetatable(self,classContainer)
+    self.n = 0
+    self.typedefs = {tolua_n=0}
+    self.usertypes = {}
+    self.enums = {tolua_n=0}
+    self.lnames = {}
+    return self
 end
 -- push container
 function push (t)
         t.prox = classContainer.curr
  classContainer.curr = t
+    t.prox = classContainer.curr
+    classContainer.curr = t
 end
 -- pop container
 function pop ()
 --print("name",classContainer.curr.name)
 --foreach(classContainer.curr.usertypes,print)
 --print("______________")
  classContainer.curr = classContainer.curr.prox
+    --print("name",classContainer.curr.name)
+    --foreach(classContainer.curr.usertypes,print)
+    --print("______________")
+    classContainer.curr = classContainer.curr.prox
 end
 -- get current namespace
 function getcurrnamespace ()
         return getnamespace(classContainer.curr)
+    return getnamespace(classContainer.curr)
 end
 -- append to current container
 function append (t)
  return classContainer.curr:append(t)
+    return classContainer.curr:append(t)
 end
 -- append typedef to current container
 function appendtypedef (t)
  return classContainer.curr:appendtypedef(t)
+    return classContainer.curr:appendtypedef(t)
 end
 -- append usertype to current container
 function appendusertype (t)
  return classContainer.curr:appendusertype(t)
+    return classContainer.curr:appendusertype(t)
 end
 -- append enum to current container
 function appendenum (t)
  return classContainer.curr:appendenum(t)
+    return classContainer.curr:appendenum(t)
 end
 -- substitute typedef
 function applytypedef (mod,type)
  return classContainer.curr:applytypedef(mod,type)
+    return classContainer.curr:applytypedef(mod,type)
 end
 -- check if is type
 function findtype (type)
  local t = classContainer.curr:findtype(type)
         return t
+    local t = classContainer.curr:findtype(type)
+    return t
 end
 -- check if is typedef
 function istypedef (type)
  return classContainer.curr:istypedef(type)
+    return classContainer.curr:istypedef(type)
 end
 -- get fulltype (with namespace)
 function fulltype (t)
  local curr =  classContainer.curr
         while curr do
          if curr then
                  if curr.typedefs and curr.typedefs[t] then
                   return curr.typedefs[t]
                  elseif curr.usertypes and curr.usertypes[t] then
                   return curr.usertypes[t]
                         end
                 end
          curr = curr.prox
         end
         return t
+    local curr =  classContainer.curr
+    while curr do
+        if curr then
+            if curr.typedefs and curr.typedefs[t] then
+                return curr.typedefs[t]
+            elseif curr.usertypes and curr.usertypes[t] then
+                return curr.usertypes[t]
+            end
+        end
+        curr = curr.prox
+    end
+    return t
 end
 -- checks if it requires collection
 function classContainer:requirecollection (t)
  push(self)
  local i=1
         local r = false
  while self[i] do
   r = self[i]:requirecollection(t) or r
   i = i+1
  end
         pop()
         return r
+    push(self)
+    local i=1
+    local r = false
+    while self[i] do
+        r = self[i]:requirecollection(t) or r
+        i = i+1
+    end
+    pop()
+    return r
 end
 …
 -- get namesapce
 function getnamespace (curr)
         local namespace = ''
         while curr do
          if curr and
                    ( curr.classtype == 'class' or curr.classtype == 'namespace')
                 then
                  namespace = (curr.original_name or curr.name) .. '::' .. namespace
                  --namespace = curr.name .. '::' .. namespace
                 end
          curr = curr.prox
         end
         return namespace
+    local namespace = ''
+    while curr do
+        if curr and
+            ( curr.classtype == 'class' or curr.classtype == 'namespace')
+        then
+            namespace = (curr.original_name or curr.name) .. '::' .. namespace
+            --namespace = curr.name .. '::' .. namespace
+        end
+        curr = curr.prox
+    end
+    return namespace
 end
 -- get namespace (only namespace)
 function getonlynamespace ()
  local curr = classContainer.curr
         local namespace = ''
         while curr do
                 if curr.classtype == 'class' then
                  return namespace
                 elseif curr.classtype == 'namespace' then
                  namespace = curr.name .. '::' .. namespace
                 end
          curr = curr.prox
         end
         return namespace
+    local curr = classContainer.curr
+    local namespace = ''
+    while curr do
+        if curr.classtype == 'class' then
+            return namespace
+        elseif curr.classtype == 'namespace' then
+            namespace = curr.name .. '::' .. namespace
+        end
+        curr = curr.prox
+    end
+    return namespace
 end
 -- check if is enum
 function isenum (type)
  return classContainer.curr:isenum(type)
+    return classContainer.curr:isenum(type)
 end
 -- append feature to container
 function classContainer:append (t)
  self.n = self.n + 1
  self[self.n] = t
  t.parent = self
+    self.n = self.n + 1
+    self[self.n] = t
+    t.parent = self
 end
 -- append typedef
 function classContainer:appendtypedef (t)
+ local namespace = getnamespace(classContainer.curr)
+ self.typedefs.tolua_n = self.typedefs.tolua_n + 1
+ self.typedefs[self.typedefs.tolua_n] = t
+        self.typedefs[t.utype] = namespace .. t.utype
+        global_typedefs[namespace..t.utype] = t
+        t.ftype = findtype(t.type) or t.type
+        --print("appending typedef "..t.utype.." as "..namespace..t.utype.." with ftype "..t.ftype)
+        append_global_type(namespace..t.utype)
+        if t.ftype and isenum(t.ftype) then
+                global_enums[namespace..t.utype] = true
+        end
+    local namespace = getnamespace(classContainer.curr)
+    self.typedefs.tolua_n = self.typedefs.tolua_n + 1
+    self.typedefs[self.typedefs.tolua_n] = t
+    self.typedefs[t.utype] = namespace .. t.utype
+    global_typedefs[namespace..t.utype] = t
+    t.ftype = findtype(t.type) or t.type
+    --print("appending typedef "..t.utype.." as "..namespace..t.utype.." with ftype "..t.ftype)
+    append_global_type(namespace..t.utype)
+    if t.ftype and isenum(t.ftype) then
+        global_enums[namespace..t.utype] = true
+    end
 end
 -- append usertype: return full type
 function classContainer:appendusertype (t)
         local container
         if t == (self.original_name or self.name) then
                 container = self.prox
         else
                 container = self
         end
         local ft = getnamespace(container) .. t
         container.usertypes[t] = ft
         _usertype[ft] = ft
         return ft
+    local container
+    if t == (self.original_name or self.name) then
+        container = self.prox
+    else
+        container = self
+    end
+    local ft = getnamespace(container) .. t
+    container.usertypes[t] = ft
+    _usertype[ft] = ft
+    return ft
 end
 -- append enum
 function classContainer:appendenum (t)
  local namespace = getnamespace(classContainer.curr)
  self.enums.tolua_n = self.enums.tolua_n + 1
  self.enums[self.enums.tolua_n] = t
         global_enums[namespace..t.name] = t
+    local namespace = getnamespace(classContainer.curr)
+    self.enums.tolua_n = self.enums.tolua_n + 1
+    self.enums[self.enums.tolua_n] = t
+    global_enums[namespace..t.name] = t
 end
 -- determine lua function name overload
 function classContainer:overload (lname)
  if not self.lnames[lname] then
   self.lnames[lname] = 0
  else
   self.lnames[lname] = self.lnames[lname] + 1
  end
  return format("%02d",self.lnames[lname])
+    if not self.lnames[lname] then
+        self.lnames[lname] = 0
+    else
+        self.lnames[lname] = self.lnames[lname] + 1
+    end
+    return format("%02d",self.lnames[lname])
 end
 -- applies typedef: returns the 'the facto' modifier and type
 function classContainer:applytypedef (mod,type)
         if global_typedefs[type] then
                 --print("found typedef "..global_typedefs[type].type)
                 local mod1, type1 = global_typedefs[type].mod, global_typedefs[type].ftype
                 local mod2, type2 = applytypedef(mod.." "..mod1, type1)
                 --return mod2 .. ' ' .. mod1, type2
                 return mod2, type2
         end
         do return mod,type end
+    if global_typedefs[type] then
+        --print("found typedef "..global_typedefs[type].type)
+        local mod1, type1 = global_typedefs[type].mod, global_typedefs[type].ftype
+        local mod2, type2 = applytypedef(mod.." "..mod1, type1)
+        --return mod2 .. ' ' .. mod1, type2
+        return mod2, type2
+    end
+    do return mod,type end
 end
 -- check if it is a typedef
 function classContainer:istypedef (type)
  local env = self
  while env do
   if env.typedefs then
    local i=1
    while env.typedefs[i] do
     if env.typedefs[i].utype == type then
          return type
         end
         i = i+1
    end
   end
   env = env.parent
  end
  return nil
+    local env = self
+    while env do
+        if env.typedefs then
+            local i=1
+            while env.typedefs[i] do
+                if env.typedefs[i].utype == type then
+                    return type
+                end
+                i = i+1
+            end
+        end
+        env = env.parent
+    end
+    return nil
 end
 function find_enum_var(var)
         if tonumber(var) then return var end
         local c = classContainer.curr
         while c do
                 local ns = getnamespace(c)
                 for k,v in pairs(_global_enums) do
                         if match_type(var, v, ns) then
                                 return v
                         end
                 end
                 if c.base and c.base ~= '' then
                         c = _global_classes[c:findtype(c.base)]
                 else
                         c = nil
                 end
         end
         return var
+    if tonumber(var) then return var end
+    local c = classContainer.curr
+    while c do
+        local ns = getnamespace(c)
+        for k,v in pairs(_global_enums) do
+            if match_type(var, v, ns) then
+                return v
+            end
+        end
+        if c.base and c.base ~= '' then
+            c = _global_classes[c:findtype(c.base)]
+        else
+            c = nil
+        end
+    end
+    return var
 end
 …
 function classContainer:findtype (t)
         t = string.gsub(t, "=.*", "")
         if _basic[t] then
          return t
         end
         local _,_,em = string.find(t, "([&%*])%s*$")
         t = string.gsub(t, "%s*([&%*])%s*$", "")
         p = self
         while p and type(p)=='table' do
                 local st = getnamespace(p)
                 for i=_global_types.n,1,-1 do -- in reverse order
                         if match_type(t, _global_types[i], st) then
                                 return _global_types[i]..(em or "")
                         end
                 end
                 if p.base and p.base ~= '' and p.base ~= t then
                         --print("type is "..t..", p is "..p.base.." self.type is "..self.type.." self.name is "..self.name)
                         p = _global_classes[p:findtype(p.base)]
                 else
                         p = nil
                 end
         end
         return nil
+    t = string.gsub(t, "=.*", "")
+    if _basic[t] then
+     return t
+    end
+    local _,_,em = string.find(t, "([&%*])%s*$")
+    t = string.gsub(t, "%s*([&%*])%s*$", "")
+    p = self
+    while p and type(p)=='table' do
+        local st = getnamespace(p)
+        for i=_global_types.n,1,-1 do -- in reverse order
+            if match_type(t, _global_types[i], st) then
+                return _global_types[i]..(em or "")
+            end
+        end
+        if p.base and p.base ~= '' and p.base ~= t then
+            --print("type is "..t..", p is "..p.base.." self.type is "..self.type.." self.name is "..self.name)
+            p = _global_classes[p:findtype(p.base)]
+        else
+            p = nil
+        end
+    end
+    return nil
 end
 function append_global_type(t, class)
         _global_types.n = _global_types.n +1
         _global_types[_global_types.n] = t
         _global_types_hash[t] = 1
         if class then append_class_type(t, class) end
+    _global_types.n = _global_types.n +1
+    _global_types[_global_types.n] = t
+    _global_types_hash[t] = 1
+    if class then append_class_type(t, class) end
 end
 function append_class_type(t,class)
         if _global_classes[t] then
                 class.flags = _global_classes[t].flags
                 class.lnames = _global_classes[t].lnames
                 if _global_classes[t].base and (_global_classes[t].base ~= '') then
                         class.base = _global_classes[t].base or class.base
                 end
         end
         _global_classes[t] = class
         class.flags = class.flags or {}
+    if _global_classes[t] then
+        class.flags = _global_classes[t].flags
+        class.lnames = _global_classes[t].lnames
+        if _global_classes[t].base and (_global_classes[t].base ~= '') then
+            class.base = _global_classes[t].base or class.base
+        end
+    end
+    _global_classes[t] = class
+    class.flags = class.flags or {}
 end
 function match_type(childtype, regtype, st)
 --print("findtype "..childtype..", "..regtype..", "..st)
         local b,e = string.find(regtype, childtype, -string.len(childtype), true)
         if b then
                 if e == string.len(regtype) and
                                 (b == 1 or (string.sub(regtype, b-1, b-1) == ':' and
                                 string.sub(regtype, 1, b-1) == string.sub(st, 1, b-1))) then
                         return true
                 end
         end
         return false
+    local b,e = string.find(regtype, childtype, -string.len(childtype), true)
+    if b then
+        if e == string.len(regtype) and
+                (b == 1 or (string.sub(regtype, b-1, b-1) == ':' and
+                string.sub(regtype, 1, b-1) == string.sub(st, 1, b-1))) then
+            return true
+        end
+    end
+    return false
 end
 function findtype_on_childs(self, t)
         local tchild
         if self.classtype == 'class' or self.classtype == 'namespace' then
                 for k,v in ipairs(self) do
                         if v.classtype == 'class' or v.classtype == 'namespace' then
                                 if v.typedefs and v.typedefs[t] then
                                  return v.typedefs[t]
                                 elseif v.usertypes and v.usertypes[t] then
                                  return v.usertypes[t]
                                 end
                                 tchild = findtype_on_childs(v, t)
                                 if tchild then return tchild end
                         end
                 end
         end
         return nil
+    local tchild
+    if self.classtype == 'class' or self.classtype == 'namespace' then
+        for k,v in ipairs(self) do
+            if v.classtype == 'class' or v.classtype == 'namespace' then
+                if v.typedefs and v.typedefs[t] then
+                 return v.typedefs[t]
+                elseif v.usertypes and v.usertypes[t] then
+                 return v.usertypes[t]
+                end
+                tchild = findtype_on_childs(v, t)
+                if tchild then return tchild end
+            end
+        end
+    end
+    return nil
 end
 function classContainer:isenum (type)
  if global_enums[type] then
         return type
  else
         return false
  end
  local basetype = gsub(type,"^.*::","")
  local env = self
  while env do
   if env.enums then
    local i=1
    while env.enums[i] do
     if env.enums[i].name == basetype then
          return true
         end
         i = i+1
    end
   end
   env = env.parent
  end
  return false
+    if global_enums[type] then
+        return type
+    else
+        return false
+    end
+    local basetype = gsub(type,"^.*::","")
+    local env = self
+    while env do
+        if env.enums then
+            local i=1
+            while env.enums[i] do
+                if env.enums[i].name == basetype then
+                    return true
+                end
+                i = i+1
+            end
+        end
+        env = env.parent
+    end
+    return false
 end
 …
 -- parse chunk
 function classContainer:doparse (s)
 --print ("parse "..s)
  -- try the parser hook
  do
         local sub = parser_hook(s)
         if sub then
                 return sub
         end
  end
  -- try the null statement
  do
         local b,e,code = string.find(s, "^%s*;")
         if b then
                 return strsub(s,e+1)
         end
  end
  -- try empty verbatim line
  do
         local b,e,code = string.find(s, "^%s*$\n")
         if b then
                 return strsub(s,e+1)
         end
  end
  -- try Lua code
  do
   local b,e,code = strfind(s,"^%s*(%b\1\2)")
   if b then
    Code(strsub(code,2,-2))
    return strsub(s,e+1)
   end
  end
  -- try C code
  do
   local b,e,code = strfind(s,"^%s*(%b\3\4)")
   if b then
         code = '{'..strsub(code,2,-2)..'\n}\n'
         Verbatim(code,'r')        -- verbatim code for 'r'egister fragment
         return strsub(s,e+1)
   end
  end
  -- try C code for preamble section
  do
         local b,e,code = string.find(s, "^%s*(%b\5\6)")
         if b then
                 code = string.sub(code, 2, -2).."\n"
                 Verbatim(code, '')
                 return string.sub(s, e+1)
         end
  end
  -- try default_property directive
  do
         local b,e,ptype = strfind(s, "^%s*TOLUA_PROPERTY_TYPE%s*%(+%s*([^%)%s]*)%s*%)+%s*;?")
         if b then
                 if not ptype or ptype == "" then
                         ptype = "default"
                 end
                 self:set_property_type(ptype)
                 return strsub(s, e+1)
         end
  end
  -- try protected_destructor directive
  do
         local b,e = string.find(s, "^%s*TOLUA_PROTECTED_DESTRUCTOR%s*;?")
         if b then
                 if self.set_protected_destructor then
                         self:set_protected_destructor(true)
                 end
                 return strsub(s, e+1)
         end
  end
  -- try 'extern' keyword
  do
         local b,e = string.find(s, "^%s*extern%s+")
         if b then
                 -- do nothing
                 return strsub(s, e+1)
         end
  end
  -- try 'virtual' keyworkd
  do
         local b,e = string.find(s, "^%s*virtual%s+")
         if b then
                 methodisvirtual = true
                 return strsub(s, e+1)
         end
  end
  -- try labels (public, private, etc)
  do
         local b,e = string.find(s, "^%s*%w*%s*:[^:]")
         if b then
                 return strsub(s, e) -- preserve the [^:]
         end
  end
  -- try module
  do
   local b,e,name,body = strfind(s,"^%s*module%s%s*([_%w][_%w]*)%s*(%b{})%s*")
   if b then
    _curr_code = strsub(s,b,e)
    Module(name,body)
    return strsub(s,e+1)
   end
  end
  -- try namesapce
  do
   local b,e,name,body = strfind(s,"^%s*namespace%s%s*([_%w][_%w]*)%s*(%b{})%s*;?")
   if b then
    _curr_code = strsub(s,b,e)
    Namespace(name,body)
    return strsub(s,e+1)
   end
  end
  -- try define
  do
   local b,e,name = strfind(s,"^%s*#define%s%s*([^%s]*)[^\n]*\n%s*")
   if b then
    _curr_code = strsub(s,b,e)
    Define(name)
    return strsub(s,e+1)
   end
  end
  -- try enumerates
  do
   local b,e,name,body,varname = strfind(s,"^%s*enum%s+(%S*)%s*(%b{})%s*([^%s;]*)%s*;?%s*")
   if b then
    --error("#Sorry, declaration of enums and variables on the same statement is not supported.\nDeclare your variable separately (example: '"..name.." "..varname..";')")
    _curr_code = strsub(s,b,e)
    Enumerate(name,body,varname)
    return strsub(s,e+1)
   end
  end
 -- do
 --  local b,e,name,body = strfind(s,"^%s*enum%s+(%S*)%s*(%b{})%s*;?%s*")
 --  if b then
 --   _curr_code = strsub(s,b,e)
 --   Enumerate(name,body)
 --  return strsub(s,e+1)
 --  end
 -- end
  do
   local b,e,body,name = strfind(s,"^%s*typedef%s+enum[^{]*(%b{})%s*([%w_][^%s]*)%s*;%s*")
   if b then
    _curr_code = strsub(s,b,e)
    Enumerate(name,body)
    return strsub(s,e+1)
   end
  end
  -- try operator
  do
   local b,e,decl,kind,arg,const = strfind(s,"^%s*([_%w][_%w%s%*&:<>,]-%s+operator)%s*([^%s][^%s]*)%s*(%b())%s*(c?o?n?s?t?)%s*;%s*")
   if not b then
                  -- try inline
    b,e,decl,kind,arg,const = strfind(s,"^%s*([_%w][_%w%s%*&:<>,]-%s+operator)%s*([^%s][^%s]*)%s*(%b())%s*(c?o?n?s?t?)[%s\n]*%b{}%s*;?%s*")
   end
   if not b then
         -- try cast operator
         b,e,decl,kind,arg,const = strfind(s, "^%s*(operator)%s+([%w_:%d<>%*%&%s]+)%s*(%b())%s*(c?o?n?s?t?)");
         if b then
                 local _,ie = string.find(s, "^%s*%b{}", e+1)
                 if ie then
                         e = ie
                 end
         end
   end
   if b then
    _curr_code = strsub(s,b,e)
    Operator(decl,kind,arg,const)
    return strsub(s,e+1)
   end
  end
  -- try function
  do
   --local b,e,decl,arg,const = strfind(s,"^%s*([~_%w][_@%w%s%*&:<>]*[_%w])%s*(%b())%s*(c?o?n?s?t?)%s*=?%s*0?%s*;%s*")
   local b,e,decl,arg,const,virt = strfind(s,"^%s*([^%(\n]+)%s*(%b())%s*(c?o?n?s?t?)%s*(=?%s*0?)%s*;%s*")
   if not b then
         -- try function with template
         b,e,decl,arg,const = strfind(s,"^%s*([~_%w][_@%w%s%*&:<>]*[_%w]%b<>)%s*(%b())%s*(c?o?n?s?t?)%s*=?%s*0?%s*;%s*")
   end
   if not b then
    -- try a single letter function name
    b,e,decl,arg,const = strfind(s,"^%s*([_%w])%s*(%b())%s*(c?o?n?s?t?)%s*;%s*")
   end
   if b then
         if virt and string.find(virt, "[=0]") then
                 if self.flags then
                         self.flags.pure_virtual = true
                 end
         end
    _curr_code = strsub(s,b,e)
    Function(decl,arg,const)
    return strsub(s,e+1)
   end
  end
  -- try inline function
  do
   local b,e,decl,arg,const = strfind(s,"^%s*([^%(\n]+)%s*(%b())%s*(c?o?n?s?t?)[^;{]*%b{}%s*;?%s*")
   --local b,e,decl,arg,const = strfind(s,"^%s*([~_%w][_@%w%s%*&:<>]*[_%w>])%s*(%b())%s*(c?o?n?s?t?)[^;]*%b{}%s*;?%s*")
   if not b then
    -- try a single letter function name
    b,e,decl,arg,const = strfind(s,"^%s*([_%w])%s*(%b())%s*(c?o?n?s?t?).-%b{}%s*;?%s*")
   end
   if b then
    _curr_code = strsub(s,b,e)
    Function(decl,arg,const)
    return strsub(s,e+1)
   end
  end
  -- try class
  do
          local b,e,name,base,body
                 base = '' body = ''
                 b,e,name = strfind(s,"^%s*class%s*([_%w][_%w@]*)%s*;")  -- dummy class
                 if not b then
                         b,e,name = strfind(s,"^%s*struct%s*([_%w][_%w@]*)%s*;")    -- dummy struct
                         if not b then
                                 b,e,name,base,body = strfind(s,"^%s*class%s*([_%w][_%w@]*)%s*(.-)%s*(%b{})%s*;%s*")
                                 if not b then
                                         b,e,name,base,body = strfind(s,"^%s*struct%s*([_%w][_%w@]*)%s*(.-)%s*(%b{})%s*;%s*")
                                         if not b then
                                                 b,e,name,base,body = strfind(s,"^%s*union%s*([_%w][_%w@]*)%s*(.-)%s*(%b{})%s*;%s*")
                                                 if not b then
                                                         base = ''
                                                         b,e,body,name = strfind(s,"^%s*typedef%s%s*struct%s%s*[_%w]*%s*(%b{})%s*([_%w][_%w@]*)%s*;%s*")
                                                 end
                                         end
                                 end
                         end
                 end
                 if b then
                         if base ~= '' then
                                 base = string.gsub(base, "^%s*:%s*", "")
                                 base = string.gsub(base, "%s*public%s*", "")
                                 base = split(base, ",")
                                 --local b,e
                                 --b,e,base = strfind(base,".-([_%w][_%w<>,:]*)$")
                         else
                                 base = {}
                         end
                         _curr_code = strsub(s,b,e)
                         Class(name,base,body)
                         return strsub(s,e+1)
                 end
         end
  -- try typedef
  do
   local b,e,types = strfind(s,"^%s*typedef%s%s*(.-)%s*;%s*")
   if b then
    _curr_code = strsub(s,b,e)
    Typedef(types)
    return strsub(s,e+1)
   end
  end
  -- try variable
  do
   local b,e,decl = strfind(s,"^%s*([_%w][_@%s%w%d%*&:<>,]*[_%w%d])%s*;%s*")
   if b then
    _curr_code = strsub(s,b,e)
         local list = split_c_tokens(decl, ",")
         Variable(list[1])
         if list.n > 1 then
                 local _,_,type = strfind(list[1], "(.-)%s+([^%s]*)$");
                 local i =2;
                 while list[i] do
                         Variable(type.." "..list[i])
                         i=i+1
                 end
         end
    --Variable(decl)
    return strsub(s,e+1)
   end
  end
         -- try string
  do
   local b,e,decl = strfind(s,"^%s*([_%w]?[_%s%w%d]-char%s+[_@%w%d]*%s*%[%s*%S+%s*%])%s*;%s*")
   if b then
    _curr_code = strsub(s,b,e)
    Variable(decl)
    return strsub(s,e+1)
   end
  end
  -- try array
  do
   local b,e,decl = strfind(s,"^%s*([_%w][][_@%s%w%d%*&:]*[]_%w%d])%s*;%s*")
   if b then
    _curr_code = strsub(s,b,e)
    Array(decl)
    return strsub(s,e+1)
   end
  end
  -- no matching
  if gsub(s,"%s%s*","") ~= "" then
   _curr_code = s
   error("#parse error")
  else
   return ""
  end
+    --print ("parse "..s)
+    -- try the parser hook
+    do
+        local sub = parser_hook(s)
+        if sub then
+            return sub
+        end
+    end
+    -- try the null statement
+    do
+        local b,e,code = string.find(s, "^%s*;")
+        if b then
+            return strsub(s,e+1)
+        end
+    end
+    -- try empty verbatim line
+    do
+        local b,e,code = string.find(s, "^%s*$\n")
+        if b then
+            return strsub(s,e+1)
+        end
+    end
+    -- try Lua code
+    do
+        local b,e,code = strfind(s,"^%s*(%b\1\2)")
+        if b then
+            Code(strsub(code,2,-2))
+            return strsub(s,e+1)
+        end
+    end
+    -- try C code
+    do
+        local b,e,code = strfind(s,"^%s*(%b\3\4)")
+        if b then
+            code = '{'..strsub(code,2,-2)..'\n}\n'
+            Verbatim(code,'r')        -- verbatim code for 'r'egister fragment
+            return strsub(s,e+1)
+        end
+    end
+    -- try C code for preamble section
+    do
+        local b,e,code = string.find(s, "^%s*(%b\5\6)")
+        if b then
+            code = string.sub(code, 2, -2).."\n"
+            Verbatim(code, '')
+            return string.sub(s, e+1)
+        end
+    end
+    -- try default_property directive
+    do
+        local b,e,ptype = strfind(s, "^%s*TOLUA_PROPERTY_TYPE%s*%(+%s*([^%)%s]*)%s*%)+%s*;?")
+        if b then
+            if not ptype or ptype == "" then
+                ptype = "default"
+            end
+            self:set_property_type(ptype)
+            return strsub(s, e+1)
+        end
+    end
+    -- try protected_destructor directive
+    do
+        local b,e = string.find(s, "^%s*TOLUA_PROTECTED_DESTRUCTOR%s*;?")
+        if b then
+            if self.set_protected_destructor then
+                self:set_protected_destructor(true)
+            end
+            return strsub(s, e+1)
+        end
+    end
+    -- try 'extern' keyword
+    do
+        local b,e = string.find(s, "^%s*extern%s+")
+        if b then
+            -- do nothing
+            return strsub(s, e+1)
+        end
+    end
+    -- try 'virtual' keyworkd
+    do
+        local b,e = string.find(s, "^%s*virtual%s+")
+        if b then
+            methodisvirtual = true
+            return strsub(s, e+1)
+        end
+    end
+    -- try labels (public, private, etc)
+    do
+        local b,e = string.find(s, "^%s*%w*%s*:[^:]")
+        if b then
+            return strsub(s, e) -- preserve the [^:]
+        end
+    end
+    -- try module
+    do
+        local b,e,name,body = strfind(s,"^%s*module%s%s*([_%w][_%w]*)%s*(%b{})%s*")
+        if b then
+            _curr_code = strsub(s,b,e)
+            Module(name,body)
+            return strsub(s,e+1)
+        end
+    end
+    -- try namesapce
+    do
+        local b,e,name,body = strfind(s,"^%s*namespace%s%s*([_%w][_%w]*)%s*(%b{})%s*;?")
+        if b then
+            _curr_code = strsub(s,b,e)
+            Namespace(name,body)
+            return strsub(s,e+1)
+        end
+    end
+    -- try define
+    do
+        local b,e,name = strfind(s,"^%s*#define%s%s*([^%s]*)[^\n]*\n%s*")
+        if b then
+            _curr_code = strsub(s,b,e)
+            Define(name)
+            return strsub(s,e+1)
+        end
+    end
+    -- try enumerates
+    do
+        local b,e,name,body,varname = strfind(s,"^%s*enum%s+(%S*)%s*(%b{})%s*([^%s;]*)%s*;?%s*")
+        if b then
+            --error("#Sorry, declaration of enums and variables on the same statement is not supported.\nDeclare your variable separately (example: '"..name.." "..varname..";')")
+            _curr_code = strsub(s,b,e)
+            Enumerate(name,body,varname)
+            return strsub(s,e+1)
+        end
+    end
+    -- do
+    --    local b,e,name,body = strfind(s,"^%s*enum%s+(%S*)%s*(%b{})%s*;?%s*")
+    --    if b then
+    --        _curr_code = strsub(s,b,e)
+    --        Enumerate(name,body)
+    --        return strsub(s,e+1)
+    --    end
+    -- end
+    do
+        local b,e,body,name = strfind(s,"^%s*typedef%s+enum[^{]*(%b{})%s*([%w_][^%s]*)%s*;%s*")
+        if b then
+        _curr_code = strsub(s,b,e)
+        Enumerate(name,body)
+        return strsub(s,e+1)
+        end
+    end
+    -- try operator
+    do
+        local b,e,decl,kind,arg,const = strfind(s,"^%s*([_%w][_%w%s%*&:<>,]-%s+operator)%s*([^%s][^%s]*)%s*(%b())%s*(c?o?n?s?t?)%s*;%s*")
+        if not b then
+            -- try inline
+            b,e,decl,kind,arg,const = strfind(s,"^%s*([_%w][_%w%s%*&:<>,]-%s+operator)%s*([^%s][^%s]*)%s*(%b())%s*(c?o?n?s?t?)[%s\n]*%b{}%s*;?%s*")
+        end
+        if not b then
+            -- try cast operator
+            b,e,decl,kind,arg,const = strfind(s, "^%s*(operator)%s+([%w_:%d<>%*%&%s]+)%s*(%b())%s*(c?o?n?s?t?)");
+            if b then
+                local _,ie = string.find(s, "^%s*%b{}", e+1)
+                if ie then
+                    e = ie
+                end
+            end
+        end
+        if b then
+            _curr_code = strsub(s,b,e)
+            Operator(decl,kind,arg,const)
+            return strsub(s,e+1)
+        end
+    end
+    -- try function
+    do
+        --local b,e,decl,arg,const = strfind(s,"^%s*([~_%w][_@%w%s%*&:<>]*[_%w])%s*(%b())%s*(c?o?n?s?t?)%s*=?%s*0?%s*;%s*")
+        local b,e,decl,arg,const,virt = strfind(s,"^%s*([^%(\n]+)%s*(%b())%s*(c?o?n?s?t?)%s*(=?%s*0?)%s*;%s*")
+        if not b then
+            -- try function with template
+            b,e,decl,arg,const = strfind(s,"^%s*([~_%w][_@%w%s%*&:<>]*[_%w]%b<>)%s*(%b())%s*(c?o?n?s?t?)%s*=?%s*0?%s*;%s*")
+        end
+        if not b then
+            -- try a single letter function name
+            b,e,decl,arg,const = strfind(s,"^%s*([_%w])%s*(%b())%s*(c?o?n?s?t?)%s*;%s*")
+        end
+        if b then
+            if virt and string.find(virt, "[=0]") then
+                if self.flags then
+                    self.flags.pure_virtual = true
+                end
+            end
+            _curr_code = strsub(s,b,e)
+            Function(decl,arg,const)
+            return strsub(s,e+1)
+        end
+    end
+    -- try inline function
+    do
+        local b,e,decl,arg,const = strfind(s,"^%s*([^%(\n]+)%s*(%b())%s*(c?o?n?s?t?)[^;{]*%b{}%s*;?%s*")
+        --local b,e,decl,arg,const = strfind(s,"^%s*([~_%w][_@%w%s%*&:<>]*[_%w>])%s*(%b())%s*(c?o?n?s?t?)[^;]*%b{}%s*;?%s*")
+        if not b then
+            -- try a single letter function name
+            b,e,decl,arg,const = strfind(s,"^%s*([_%w])%s*(%b())%s*(c?o?n?s?t?).-%b{}%s*;?%s*")
+        end
+        if b then
+            _curr_code = strsub(s,b,e)
+            Function(decl,arg,const)
+            return strsub(s,e+1)
+        end
+    end
+    -- try class
+    do
+        local b,e,name,base,body
+        base = '' body = ''
+        b,e,name = strfind(s,"^%s*class%s*([_%w][_%w@]*)%s*;")  -- dummy class
+        if not b then
+            b,e,name = strfind(s,"^%s*struct%s*([_%w][_%w@]*)%s*;")    -- dummy struct
+            if not b then
+                b,e,name,base,body = strfind(s,"^%s*class%s*([_%w][_%w@]*)%s*(.-)%s*(%b{})%s*;%s*")
+                if not b then
+                    b,e,name,base,body = strfind(s,"^%s*struct%s*([_%w][_%w@]*)%s*(.-)%s*(%b{})%s*;%s*")
+                    if not b then
+                        b,e,name,base,body = strfind(s,"^%s*union%s*([_%w][_%w@]*)%s*(.-)%s*(%b{})%s*;%s*")
+                        if not b then
+                            base = ''
+                            b,e,body,name = strfind(s,"^%s*typedef%s%s*struct%s%s*[_%w]*%s*(%b{})%s*([_%w][_%w@]*)%s*;%s*")
+                        end
+                    end
+                end
+            end
+        end
+        if b then
+            if base ~= '' then
+                base = string.gsub(base, "^%s*:%s*", "")
+                base = string.gsub(base, "%s*public%s*", "")
+                base = split(base, ",")
+                --local b,e
+                --b,e,base = strfind(base,".-([_%w][_%w<>,:]*)$")
+            else
+                base = {}
+            end
+            _curr_code = strsub(s,b,e)
+            Class(name,base,body)
+            return strsub(s,e+1)
+        end
+    end
+    -- try typedef
+    do
+        local b,e,types = strfind(s,"^%s*typedef%s%s*(.-)%s*;%s*")
+        if b then
+            _curr_code = strsub(s,b,e)
+            Typedef(types)
+            return strsub(s,e+1)
+        end
+    end
+    -- try variable
+    do
+        local b,e,decl = strfind(s,"^%s*([_%w][_@%s%w%d%*&:<>,]*[_%w%d])%s*;%s*")
+        if b then
+            _curr_code = strsub(s,b,e)
+            local list = split_c_tokens(decl, ",")
+            Variable(list[1])
+            if list.n > 1 then
+                local _,_,type = strfind(list[1], "(.-)%s+([^%s]*)$");
+                local i =2;
+                while list[i] do
+                    Variable(type.." "..list[i])
+                    i=i+1
+                end
+            end
+            --Variable(decl)
+            return strsub(s,e+1)
+        end
+    end
+    -- try string
+    do
+        local b,e,decl = strfind(s,"^%s*([_%w]?[_%s%w%d]-char%s+[_@%w%d]*%s*%[%s*%S+%s*%])%s*;%s*")
+        if b then
+            _curr_code = strsub(s,b,e)
+            Variable(decl)
+            return strsub(s,e+1)
+        end
+    end
+    -- try array
+    do
+        local b,e,decl = strfind(s,"^%s*([_%w][][_@%s%w%d%*&:]*[]_%w%d])%s*;%s*")
+        if b then
+            _curr_code = strsub(s,b,e)
+            Array(decl)
+            return strsub(s,e+1)
+        end
+    end
+    -- no matching
+    if gsub(s,"%s%s*","") ~= "" then
+        _curr_code = s
+        error("#parse error")
+    else
+        return ""
+    end
 end
 …
 function classContainer:parse (s)
         self.curr_member_access = nil
  while s ~= '' do
   s = self:doparse(s)
   methodisvirtual = false
  end
+    self.curr_member_access = nil
+    while s ~= '' do
+        s = self:doparse(s)
+        methodisvirtual = false
+    end
 end
 …
 function get_property_type()
         return classContainer.curr:get_property_type()
+    return classContainer.curr:get_property_type()
 end
 function classContainer:set_property_type(ptype)
         ptype = string.gsub(ptype, "^%s*", "")
         ptype = string.gsub(ptype, "%s*$", "")
         self.property_type = ptype
+    ptype = string.gsub(ptype, "^%s*", "")
+    ptype = string.gsub(ptype, "%s*$", "")
+    self.property_type = ptype
 end
 function classContainer:get_property_type()
         return self.property_type or (self.parent and self.parent:get_property_type()) or "default"
 end
+    return self.property_type or (self.parent and self.parent:get_property_type()) or "default"
+end

code/branches/buildsystem2/src/tolua/lua/custom.lua

-                      r2087
+                      r2509
 function extract_code(fn,s)
         local code = ""
         if fn then
                 code = '\n$#include "'..fn..'"\n'
         end
         s= "\n" .. s .. "\n" -- add blank lines as sentinels
         local _,e,c,t = strfind(s, "\n([^\n]-)SCRIPT_([%w_]*)[^\n]*\n")
         while e do
                 t = strlower(t)
                 if t == "bind_begin" then
                         _,e,c = strfind(s,"(.-)\n[^\n]*SCRIPT_BIND_END[^\n]*\n",e)
                         if not e then
                          tolua_error("Unbalanced 'SCRIPT_BIND_BEGIN' directive in header file")
                         end
                 end
                 if t == "bind_class" or t == "bind_block" then
                         local b
                         _,e,c,b = string.find(s, "([^{]-)(%b{})", e)
                         c = c..'{\n'..extract_code(nil, b)..'\n};\n'
                 end
                 code = code .. c .. "\n"
          _,e,c,t = strfind(s, "\n([^\n]-)SCRIPT_([%w_]*)[^\n]*\n",e)
         end
         return code
+    local code = ""
+    if fn then
+        code = '\n$#include "'..fn..'"\n'
+    end
+    s= "\n" .. s .. "\n" -- add blank lines as sentinels
+    local _,e,c,t = strfind(s, "\n([^\n]-)SCRIPT_([%w_]*)[^\n]*\n")
+    while e do
+        t = strlower(t)
+        if t == "bind_begin" then
+            _,e,c = strfind(s,"(.-)\n[^\n]*SCRIPT_BIND_END[^\n]*\n",e)
+            if not e then
+             tolua_error("Unbalanced 'SCRIPT_BIND_BEGIN' directive in header file")
+            end
+        end
+        if t == "bind_class" or t == "bind_block" then
+            local b
+            _,e,c,b = string.find(s, "([^{]-)(%b{})", e)
+            c = c..'{\n'..extract_code(nil, b)..'\n};\n'
+        end
+        code = code .. c .. "\n"
+     _,e,c,t = strfind(s, "\n([^\n]-)SCRIPT_([%w_]*)[^\n]*\n",e)
+    end
+    return code
 end
 …
 function include_file_hook(p, filename)
         do return end
+    do return end
 --print("FILENAME is "..filename)
         p.code = string.gsub(p.code, "\n%s*SigC::Signal", "\n\ttolua_readonly SigC::Signal")
         p.code = string.gsub(p.code, "#ifdef __cplusplus\nextern \"C\" {\n#endif", "")
         p.code = string.gsub(p.code, "#ifdef __cplusplus\n};?\n#endif", "")
         p.code = string.gsub(p.code, "DECLSPEC", "")
         p.code = string.gsub(p.code, "SDLCALL", "")
         p.code = string.gsub(p.code, "DLLINTERFACE", "")
         p.code = string.gsub(p.code, "#define[^\n]*_[hH]_?%s*\n", "\n")
+    p.code = string.gsub(p.code, "\n%s*SigC::Signal", "\n\ttolua_readonly SigC::Signal")
+    p.code = string.gsub(p.code, "#ifdef __cplusplus\nextern \"C\" {\n#endif", "")
+    p.code = string.gsub(p.code, "#ifdef __cplusplus\n};?\n#endif", "")
+    p.code = string.gsub(p.code, "DECLSPEC", "")
+    p.code = string.gsub(p.code, "SDLCALL", "")
+    p.code = string.gsub(p.code, "DLLINTERFACE", "")
+    p.code = string.gsub(p.code, "#define[^\n]*_[hH]_?%s*\n", "\n")
 --print("code is "..p.code)
 end

code/branches/buildsystem2/src/tolua/lua/custom_hide.lua

-                      r2087
+                      r2509
 -- extract code with tolua_hide, and also
 function extract_code(fn,s)
         local code = '\n$#include "'..fn..'"\n'
         s= "\n" .. s .. "\n" -- add blank lines as sentinels
         local _,e,c,t = strfind(s, "\n([^\n]-)[Tt][Oo][Ll][Uu][Aa]_([^%s]*)[^\n]*\n")
         while e do
                 t = strlower(t)
                 if t == "begin" then
                         _,e,c = strfind(s,"(.-)\n[^\n]*[Tt][Oo][Ll][Uu][Aa]_[Ee][Nn][Dd][^\n]*\n",e)
                         if not e then
                          tolua_error("Unbalanced 'tolua_begin' directive in header file")
                         end
                 end
                 c = c.."\n"
                 c = string.gsub(c, "\n[^\n]*[Tt][Oo][Ll][Uu][Aa]_[hH][iI][Dd][eE][^\n]*\n", "\n");
                 c = string.gsub(c, "#define[^%(\n]*%(.-\n", "\n")
                 code = code .. c
          _,e,c,t = strfind(s, "\n([^\n]-)[Tt][Oo][Ll][Uu][Aa]_([^%s]*)[^\n]*\n",e)
         end
         return code
+    local code = '\n$#include "'..fn..'"\n'
+    s= "\n" .. s .. "\n" -- add blank lines as sentinels
+    local _,e,c,t = strfind(s, "\n([^\n]-)[Tt][Oo][Ll][Uu][Aa]_([^%s]*)[^\n]*\n")
+    while e do
+        t = strlower(t)
+        if t == "begin" then
+            _,e,c = strfind(s,"(.-)\n[^\n]*[Tt][Oo][Ll][Uu][Aa]_[Ee][Nn][Dd][^\n]*\n",e)
+            if not e then
+             tolua_error("Unbalanced 'tolua_begin' directive in header file")
+            end
+        end
+        c = c.."\n"
+        c = string.gsub(c, "\n[^\n]*[Tt][Oo][Ll][Uu][Aa]_[hH][iI][Dd][eE][^\n]*\n", "\n");
+        c = string.gsub(c, "#define[^%(\n]*%(.-\n", "\n")
+        code = code .. c
+     _,e,c,t = strfind(s, "\n([^\n]-)[Tt][Oo][Ll][Uu][Aa]_([^%s]*)[^\n]*\n",e)
+    end
+    return code
 end

code/branches/buildsystem2/src/tolua/lua/declaration.lua

-                      r2087
+                      r2509
 --  ret  = "*" or "&", if value is to be returned (only for arguments)
 classDeclaration = {
  mod = '',
  type = '',
  ptr = '',
  name = '',
  dim = '',
  ret = '',
  def = ''
+    mod = '',
+    type = '',
+    ptr = '',
+    name = '',
+    dim = '',
+    ret = '',
+    def = ''
+}
 classDeclaration.__index = classDeclaration
 …
 -- Create an unique variable name
 function create_varname ()
  if not _varnumber then _varnumber = 0 end
  _varnumber = _varnumber + 1
  return "tolua_var_".._varnumber
+    if not _varnumber then _varnumber = 0 end
+    _varnumber = _varnumber + 1
+    return "tolua_var_".._varnumber
 end
 …
 function classDeclaration:checkname ()
  if strsub(self.name,1,1) == '[' and not findtype(self.type) then
   self.name = self.type..self.name
   local m = split(self.mod,'%s%s*')
   self.type = m[m.n]
   self.mod = concat(m,1,m.n-1)
  end
  local t = split(self.name,'=')
  if t.n==2 then
   self.name = t[1]
   self.def = find_enum_var(t[t.n])
  end
  local b,e,d = strfind(self.name,"%[(.-)%]")
  if b then
   self.name = strsub(self.name,1,b-1)
   self.dim = find_enum_var(d)
  end
  if self.type ~= '' and self.type ~= 'void' and self.name == '' then
   self.name = create_varname()
  elseif self.kind=='var' then
   if self.type=='' and self.name~='' then
    self.type = self.type..self.name
    self.name = create_varname()
   elseif findtype(self.name) then
    if self.type=='' then self.type = self.name
    else self.type = self.type..' '..self.name end
    self.name = create_varname()
   end
  end
  -- adjust type of string
  if self.type == 'char' and self.dim ~= '' then
          self.type = 'char*'
  end
         if self.kind and self.kind == 'var' then
                 self.name = string.gsub(self.name, ":.*$", "") -- ???
         end
+    if strsub(self.name,1,1) == '[' and not findtype(self.type) then
+        self.name = self.type..self.name
+        local m = split(self.mod,'%s%s*')
+        self.type = m[m.n]
+        self.mod = concat(m,1,m.n-1)
+    end
+    local t = split(self.name,'=')
+    if t.n==2 then
+        self.name = t[1]
+        self.def = find_enum_var(t[t.n])
+    end
+    local b,e,d = strfind(self.name,"%[(.-)%]")
+    if b then
+        self.name = strsub(self.name,1,b-1)
+        self.dim = find_enum_var(d)
+    end
+    if self.type ~= '' and self.type ~= 'void' and self.name == '' then
+        self.name = create_varname()
+    elseif self.kind=='var' then
+        if self.type=='' and self.name~='' then
+            self.type = self.type..self.name
+            self.name = create_varname()
+        elseif findtype(self.name) then
+            if self.type=='' then self.type = self.name
+            else self.type = self.type..' '..self.name end
+            self.name = create_varname()
+        end
+    end
+    -- adjust type of string
+    if self.type == 'char' and self.dim ~= '' then
+        self.type = 'char*'
+    end
+    if self.kind and self.kind == 'var' then
+        self.name = string.gsub(self.name, ":.*$", "") -- ???
+    end
 end
 …
 function classDeclaration:checktype ()
  -- check if there is a pointer to basic type
  local basic = isbasic(self.type)
  if self.kind == 'func' and basic=='number' and string.find(self.ptr, "%*") then
         self.type = '_userdata'
         self.ptr = ""
  end
  if basic and self.ptr~='' then
   self.ret = self.ptr
   self.ptr = nil
   if isbasic(self.type) == 'number' then
         self.return_userdata = true
   end
  end
  -- check if there is array to be returned
  if self.dim~='' and self.ret~='' then
    error('#invalid parameter: cannot return an array of values')
  end
  -- restore 'void*' and 'string*'
  if self.type == '_userdata' then self.type = 'void*'
  elseif self.type == '_cstring' then self.type = 'char*'
  elseif self.type == '_lstate' then self.type = 'lua_State*'
  end
  -- resolve types inside the templates
  if self.type then
          self.type = resolve_template_types(self.type)
  end
 --
 -- -- if returning value, automatically set default value
 -- if self.ret ~= '' and self.def == '' then
 --  self.def = '0'
 -- end
 --
+    -- check if there is a pointer to basic type
+    local basic = isbasic(self.type)
+    if self.kind == 'func' and basic=='number' and string.find(self.ptr, "%*") then
+        self.type = '_userdata'
+        self.ptr = ""
+    end
+    if basic and self.ptr~='' then
+        self.ret = self.ptr
+        self.ptr = nil
+        if isbasic(self.type) == 'number' then
+            self.return_userdata = true
+        end
+    end
+    -- check if there is array to be returned
+    if self.dim~='' and self.ret~='' then
+        error('#invalid parameter: cannot return an array of values')
+    end
+    -- restore 'void*' and 'string*'
+    if self.type == '_userdata' then self.type = 'void*'
+    elseif self.type == '_cstring' then self.type = 'char*'
+    elseif self.type == '_lstate' then self.type = 'lua_State*'
+    end
+    -- resolve types inside the templates
+    if self.type then
+        self.type = resolve_template_types(self.type)
+    end
+    --
+    -- -- if returning value, automatically set default value
+    -- if self.ret ~= '' and self.def == '' then
+    --  self.def = '0'
+    -- end
+    --
 end
 …
 function resolve_template_types(type)
         if isbasic(type) then
                 return type
         end
         local b,_,m = string.find(type, "(%b<>)")
         if b then
                 m = split_c_tokens(string.sub(m, 2, -2), ",")
                 for i=1, table.getn(m) do
                         m[i] = string.gsub(m[i],"%s*([%*&])", "%1")
                         m[i] = findtype(m[i]) or m[i]
                         m[i] = resolve_template_types(m[i])
                 end
                 local b,i
                 type,b,i = break_template(type)
                 local template_part = "<"..string.gsub(concat(m, 1, m.n), " ", ",")..">"
                 type = rebuild_template(type, b, template_part)
                 type = string.gsub(type, ">>", "> >")
         end
         return type
+    if isbasic(type) then
+        return type
+    end
+    local b,_,m = string.find(type, "(%b<>)")
+    if b then
+        m = split_c_tokens(string.sub(m, 2, -2), ",")
+        for i=1, table.getn(m) do
+            m[i] = string.gsub(m[i],"%s*([%*&])", "%1")
+            m[i] = findtype(m[i]) or m[i]
+            m[i] = resolve_template_types(m[i])
+        end
+        local b,i
+        type,b,i = break_template(type)
+        local template_part = "<"..string.gsub(concat(m, 1, m.n), " ", ",")..">"
+        type = rebuild_template(type, b, template_part)
+        type = string.gsub(type, ">>", "> >")
+    end
+    return type
 end
 function break_template(s)
         local b,e,timpl = string.find(s, "(%b<>)")
         if timpl then
                 s = string.gsub(s, "%b<>", "")
                 return s, b, timpl
         else
                 return s, 0, nil
         end
+    local b,e,timpl = string.find(s, "(%b<>)")
+    if timpl then
+        s = string.gsub(s, "%b<>", "")
+        return s, b, timpl
+    else
+        return s, 0, nil
+    end
 end
 function rebuild_template(s, b, timpl)
         if b == 0 then
                 return s
         end
         return string.sub(s, 1, b-1)..timpl..string.sub(s, b, -1)
+    if b == 0 then
+        return s
+    end
+    return string.sub(s, 1, b-1)..timpl..string.sub(s, b, -1)
 end
 -- Print method
 function classDeclaration:print (ident,close)
  print(ident.."Declaration{")
  print(ident.." mod  = '"..self.mod.."',")
  print(ident.." type = '"..self.type.."',")
  print(ident.." ptr  = '"..self.ptr.."',")
  print(ident.." name = '"..self.name.."',")
  print(ident.." dim  = '"..self.dim.."',")
  print(ident.." def  = '"..self.def.."',")
  print(ident.." ret  = '"..self.ret.."',")
  print(ident.."}"..close)
+    print(ident.."Declaration{")
+    print(ident.." mod  = '"..self.mod.."',")
+    print(ident.." type = '"..self.type.."',")
+    print(ident.." ptr  = '"..self.ptr.."',")
+    print(ident.." name = '"..self.name.."',")
+    print(ident.." dim  = '"..self.dim.."',")
+    print(ident.." def  = '"..self.def.."',")
+    print(ident.." ret  = '"..self.ret.."',")
+    print(ident.."}"..close)
 end
 …
 function classDeclaration:requirecollection (t)
  if self.mod ~= 'const' and
             self.dim and self.dim ~= '' and
                                  not isbasic(self.type) and
                                  self.ptr == '' then
                 local type = gsub(self.type,"%s*const%s+","")
                 t[type] = "tolua_collect_" .. clean_template(type)
                 return true
         end
         return false
+        self.dim and self.dim ~= '' and
+                 not isbasic(self.type) and
+                 self.ptr == '' then
+        local type = gsub(self.type,"%s*const%s+","")
+        t[type] = "tolua_collect_" .. clean_template(type)
+        return true
+    end
+    return false
 end
 …
 function classDeclaration:decltype ()
         self.type = typevar(self.type)
         if strfind(self.mod,'const') then
                 self.type = 'const '..self.type
                 self.mod = gsub(self.mod,'const%s*','')
         end
+    self.type = typevar(self.type)
+    if strfind(self.mod,'const') then
+        self.type = 'const '..self.type
+        self.mod = gsub(self.mod,'const%s*','')
+    end
 end
 …
 -- output type checking
 function classDeclaration:outchecktype (narg)
  local def
  local t = isbasic(self.type)
  if self.def~='' then
   def = 1
  else
   def = 0
  end
  if self.dim ~= '' then
         --if t=='string' then
         --      return 'tolua_isstringarray(tolua_S,'..narg..','..def..',&tolua_err)'
         --else
         return 'tolua_istable(tolua_S,'..narg..',0,&tolua_err)'
         --end
  elseif t then
         return 'tolua_is'..t..'(tolua_S,'..narg..','..def..',&tolua_err)'
  else
   return 'tolua_isusertype(tolua_S,'..narg..',"'..self.type..'",'..def..',&tolua_err)'
  end
+    local def
+    local t = isbasic(self.type)
+    if self.def~='' then
+        def = 1
+    else
+        def = 0
+    end
+    if self.dim ~= '' then
+        --if t=='string' then
+        --    return 'tolua_isstringarray(tolua_S,'..narg..','..def..',&tolua_err)'
+        --else
+        return 'tolua_istable(tolua_S,'..narg..',0,&tolua_err)'
+        --end
+    elseif t then
+        return 'tolua_is'..t..'(tolua_S,'..narg..','..def..',&tolua_err)'
+    else
+        return 'tolua_isusertype(tolua_S,'..narg..',"'..self.type..'",'..def..',&tolua_err)'
+    end
 end
 function classDeclaration:builddeclaration (narg, cplusplus)
  local array = self.dim ~= '' and tonumber(self.dim)==nil
         local line = ""
  local ptr = ''
         local mod
         local type = self.type
  if self.dim ~= '' then
          type = gsub(self.type,'const%s+','')  -- eliminates const modifier for arrays
  end
  if self.ptr~='' and not isbasic(type) then ptr = '*' end
  line = concatparam(line," ",self.mod,type,ptr)
  if array then
   line = concatparam(line,'*')
  end
  line = concatparam(line,self.name)
  if self.dim ~= '' then
   if tonumber(self.dim)~=nil then
    line = concatparam(line,'[',self.dim,'];')
   else
         if cplusplus then
                 line = concatparam(line,' = new',type,ptr,'['..self.dim..'];')
         else
                 line = concatparam(line,' = (',type,ptr,'*)',
                 'malloc((',self.dim,')*sizeof(',type,ptr,'));')
         end
   end
  else
   local t = isbasic(type)
   line = concatparam(line,' = ')
   if t == 'state' then
         line = concatparam(line, 'tolua_S;')
   else
         --print("t is "..tostring(t)..", ptr is "..tostring(self.ptr))
         if t == 'number' and string.find(self.ptr, "%*") then
                 t = 'userdata'
         end
         if not t and ptr=='' then line = concatparam(line,'*') end
         line = concatparam(line,'((',self.mod,type)
         if not t then
                 line = concatparam(line,'*')
         end
         line = concatparam(line,') ')
                         if isenum(type) then
                         line = concatparam(line,'(int) ')
                         end
         local def = 0
         if self.def ~= '' then
                 def = self.def
                 if (ptr == '' or self.ptr == '&') and not t then
                         def = "(void*)&(const "..type..")"..def
                 end
         end
         if t then
         line = concatparam(line,'tolua_to'..t,'(tolua_S,',narg,',',def,'));')
         else
         line = concatparam(line,'tolua_tousertype(tolua_S,',narg,',',def,'));')
         end
   end
  end
         return line
+    local array = self.dim ~= '' and tonumber(self.dim)==nil
+    local line = ""
+    local ptr = ''
+    local mod
+    local type = self.type
+    if self.dim ~= '' then
+        type = gsub(self.type,'const%s+','')  -- eliminates const modifier for arrays
+    end
+    if self.ptr~='' and not isbasic(type) then ptr = '*' end
+    line = concatparam(line," ",self.mod,type,ptr)
+    if array then
+        line = concatparam(line,'*')
+    end
+    line = concatparam(line,self.name)
+    if self.dim ~= '' then
+        if tonumber(self.dim)~=nil then
+            line = concatparam(line,'[',self.dim,'];')
+        else
+            if cplusplus then
+                line = concatparam(line,' = new',type,ptr,'['..self.dim..'];')
+            else
+                line = concatparam(line,' = (',type,ptr,'*)',
+                'malloc((',self.dim,')*sizeof(',type,ptr,'));')
+            end
+        end
+    else
+    local t = isbasic(type)
+    line = concatparam(line,' = ')
+    if t == 'state' then
+        line = concatparam(line, 'tolua_S;')
+    else
+        --print("t is "..tostring(t)..", ptr is "..tostring(self.ptr))
+        if t == 'number' and string.find(self.ptr, "%*") then
+            t = 'userdata'
+        end
+        if not t and ptr=='' then line = concatparam(line,'*') end
+            line = concatparam(line,'((',self.mod,type)
+            if not t then
+                line = concatparam(line,'*')
+            end
+            line = concatparam(line,') ')
+            if isenum(type) then
+                line = concatparam(line,'(int) ')
+            end
+            local def = 0
+            if self.def ~= '' then
+                def = self.def
+                if (ptr == '' or self.ptr == '&') and not t then
+                    def = "(void*)&(const "..type..")"..def
+                end
+            end
+            if t then
+                line = concatparam(line,'tolua_to'..t,'(tolua_S,',narg,',',def,'));')
+            else
+                line = concatparam(line,'tolua_tousertype(tolua_S,',narg,',',def,'));')
+            end
+        end
+    end
+    return line
 end
 -- Declare variable
 function classDeclaration:declare (narg)
  if self.dim ~= '' and tonumber(self.dim)==nil then
          output('#ifdef __cplusplus\n')
                 output(self:builddeclaration(narg,true))
                 output('#else\n')
                 output(self:builddeclaration(narg,false))
          output('#endif\n')
         else
                 output(self:builddeclaration(narg,false))
         end
+    if self.dim ~= '' and tonumber(self.dim)==nil then
+        output('#ifdef __cplusplus\n')
+        output(self:builddeclaration(narg,true))
+        output('#else\n')
+        output(self:builddeclaration(narg,false))
+        output('#endif\n')
+    else
+        output(self:builddeclaration(narg,false))
+    end
 end
 -- Get parameter value
 function classDeclaration:getarray (narg)
  if self.dim ~= '' then
          local type = gsub(self.type,'const ','')
   output('  {')
          output('#ifndef TOLUA_RELEASE\n')
   local def; if self.def~='' then def=1 else def=0 end
                 local t = isbasic(type)
                 if (t) then
    output('   if (!tolua_is'..t..'array(tolua_S,',narg,',',self.dim,',',def,',&tolua_err))')
                 else
    output('   if (!tolua_isusertypearray(tolua_S,',narg,',"',type,'",',self.dim,',',def,',&tolua_err))')
                 end
   output('    goto tolua_lerror;')
   output('   else\n')
          output('#endif\n')
   output('   {')
   output('    int i;')
   output('    for(i=0; i<'..self.dim..';i++)')
   local t = isbasic(type)
   local ptr = ''
   if self.ptr~='' then ptr = '*' end
   output('   ',self.name..'[i] = ')
   if not t and ptr=='' then output('*') end
   output('((',type)
   if not t then
    output('*')
   end
   output(') ')
   local def = 0
   if self.def ~= '' then def = self.def end
   if t then
    output('tolua_tofield'..t..'(tolua_S,',narg,',i+1,',def,'));')
   else
    output('tolua_tofieldusertype(tolua_S,',narg,',i+1,',def,'));')
   end
   output('   }')
   output('  }')
  end
+    if self.dim ~= '' then
+        local type = gsub(self.type,'const ','')
+        output('  {')
+        output('#ifndef TOLUA_RELEASE\n')
+        local def; if self.def~='' then def=1 else def=0 end
+        local t = isbasic(type)
+        if (t) then
+            output('   if (!tolua_is'..t..'array(tolua_S,',narg,',',self.dim,',',def,',&tolua_err))')
+        else
+            output('   if (!tolua_isusertypearray(tolua_S,',narg,',"',type,'",',self.dim,',',def,',&tolua_err))')
+        end
+        output('    goto tolua_lerror;')
+        output('   else\n')
+        output('#endif\n')
+        output('   {')
+        output('    int i;')
+        output('    for(i=0; i<'..self.dim..';i++)')
+        local t = isbasic(type)
+        local ptr = ''
+        if self.ptr~='' then ptr = '*' end
+        output('   ',self.name..'[i] = ')
+        if not t and ptr=='' then output('*') end
+        output('((',type)
+        if not t then
+            output('*')
+        end
+        output(') ')
+        local def = 0
+        if self.def ~= '' then def = self.def end
+        if t then
+            output('tolua_tofield'..t..'(tolua_S,',narg,',i+1,',def,'));')
+        else
+            output('tolua_tofieldusertype(tolua_S,',narg,',i+1,',def,'));')
+        end
+        output('   }')
+        output('  }')
+    end
 end
 -- Get parameter value
 function classDeclaration:setarray (narg)
  if not strfind(self.type,'const%s+') and self.dim ~= '' then
          local type = gsub(self.type,'const ','')
   output('  {')
   output('   int i;')
   output('   for(i=0; i<'..self.dim..';i++)')
   local t,ct = isbasic(type)
   if t then
    output('    tolua_pushfield'..t..'(tolua_S,',narg,',i+1,(',ct,')',self.name,'[i]);')
   else
    if self.ptr == '' then
      output('   {')
      output('#ifdef __cplusplus\n')
      output('    void* tolua_obj = new',type,'(',self.name,'[i]);')
      output('    tolua_pushfieldusertype_and_takeownership(tolua_S,',narg,',i+1,tolua_obj,"',type,'");')
      output('#else\n')
      output('    void* tolua_obj = tolua_copy(tolua_S,(void*)&',self.name,'[i],sizeof(',type,'));')
      output('    tolua_pushfieldusertype(tolua_S,',narg,',i+1,tolua_obj,"',type,'");')
      output('#endif\n')
      output('   }')
    else
     output('   tolua_pushfieldusertype(tolua_S,',narg,',i+1,(void*)',self.name,'[i],"',type,'");')
    end
   end
   output('  }')
  end
+    if not strfind(self.type,'const%s+') and self.dim ~= '' then
+        local type = gsub(self.type,'const ','')
+        output('  {')
+        output('   int i;')
+        output('   for(i=0; i<'..self.dim..';i++)')
+        local t,ct = isbasic(type)
+        if t then
+            output('    tolua_pushfield'..t..'(tolua_S,',narg,',i+1,(',ct,')',self.name,'[i]);')
+        else
+            if self.ptr == '' then
+                output('   {')
+                output('#ifdef __cplusplus\n')
+                output('    void* tolua_obj = new',type,'(',self.name,'[i]);')
+                output('    tolua_pushfieldusertype_and_takeownership(tolua_S,',narg,',i+1,tolua_obj,"',type,'");')
+                output('#else\n')
+                output('    void* tolua_obj = tolua_copy(tolua_S,(void*)&',self.name,'[i],sizeof(',type,'));')
+                output('    tolua_pushfieldusertype(tolua_S,',narg,',i+1,tolua_obj,"',type,'");')
+                output('#endif\n')
+                output('   }')
+            else
+                output('   tolua_pushfieldusertype(tolua_S,',narg,',i+1,(void*)',self.name,'[i],"',type,'");')
+            end
+        end
+        output('  }')
+    end
 end
 -- Free dynamically allocated array
 function classDeclaration:freearray ()
  if self.dim ~= '' and tonumber(self.dim)==nil then
          output('#ifdef __cplusplus\n')
                 output('  delete []',self.name,';')
          output('#else\n')
   output('  free(',self.name,');')
          output('#endif\n')
  end
+    if self.dim ~= '' and tonumber(self.dim)==nil then
+        output('#ifdef __cplusplus\n')
+        output('  delete []',self.name,';')
+        output('#else\n')
+        output('  free(',self.name,');')
+        output('#endif\n')
+    end
 end
 -- Pass parameter
 function classDeclaration:passpar ()
  if self.ptr=='&' and not isbasic(self.type) then
   output('*'..self.name)
  elseif self.ret=='*' then
   output('&'..self.name)
  else
   output(self.name)
  end
+    if self.ptr=='&' and not isbasic(self.type) then
+        output('*'..self.name)
+    elseif self.ret=='*' then
+        output('&'..self.name)
+    else
+        output(self.name)
+    end
 end
 -- Return parameter value
 function classDeclaration:retvalue ()
  if self.ret ~= '' then
   local t,ct = isbasic(self.type)
   if t and t~='' then
    output('   tolua_push'..t..'(tolua_S,(',ct,')'..self.name..');')
   else
    output('   tolua_pushusertype(tolua_S,(void*)'..self.name..',"',self.type,'");')
   end
   return 1
  end
  return 0
+    if self.ret ~= '' then
+        local t,ct = isbasic(self.type)
+        if t and t~='' then
+            output('   tolua_push'..t..'(tolua_S,(',ct,')'..self.name..');')
+        else
+            output('   tolua_pushusertype(tolua_S,(void*)'..self.name..',"',self.type,'");')
+        end
+        return 1
+    end
+    return 0
 end
 …
 function _Declaration (t)
  setmetatable(t,classDeclaration)
  t:buildnames()
  t:checkname()
  t:checktype()
  local ft = findtype(t.type) or t.type
  if not isenum(ft) then
         t.mod, t.type = applytypedef(t.mod, ft)
  end
  if t.kind=="var" and (string.find(t.mod, "tolua_property%s") or string.find(t.mod, "tolua_property$")) then
         t.mod = string.gsub(t.mod, "tolua_property", "tolua_property__"..get_property_type())
  end
  return t
+    setmetatable(t,classDeclaration)
+    t:buildnames()
+    t:checkname()
+    t:checktype()
+    local ft = findtype(t.type) or t.type
+    if not isenum(ft) then
+        t.mod, t.type = applytypedef(t.mod, ft)
+    end
+    if t.kind=="var" and (string.find(t.mod, "tolua_property%s") or string.find(t.mod, "tolua_property$")) then
+        t.mod = string.gsub(t.mod, "tolua_property", "tolua_property__"..get_property_type())
+    end
+    return t
 end
 …
 function Declaration (s,kind,is_parameter)
  -- eliminate spaces if default value is provided
  s = gsub(s,"%s*=%s*","=")
  s = gsub(s, "%s*<", "<")
  local defb,tmpdef
  defb,_,tmpdef = string.find(s, "(=.*)$")
  if defb then
         s = string.gsub(s, "=.*$", "")
  else
         tmpdef = ''
  end
  if kind == "var" then
   -- check the form: void
   if s == '' or s == 'void' then
    return _Declaration{type = 'void', kind = kind, is_parameter = is_parameter}
   end
  end
  -- check the form: mod type*& name
  local t = split_c_tokens(s,'%*%s*&')
  if t.n == 2 then
   if kind == 'func' then
    error("#invalid function return type: "..s)
   end
   --local m = split(t[1],'%s%s*')
   local m = split_c_tokens(t[1],'%s+')
   return _Declaration{
    name = t[2]..tmpdef,
    ptr = '*',
    ret = '&',
    --type = rebuild_template(m[m.n], tb, timpl),
    type = m[m.n],
    mod = concat(m,1,m.n-1),
    is_parameter = is_parameter,
    kind = kind
+  }
  end
  -- check the form: mod type** name
  t = split_c_tokens(s,'%*%s*%*')
  if t.n == 2 then
   if kind == 'func' then
    error("#invalid function return type: "..s)
   end
   --local m = split(t[1],'%s%s*')
   local m = split_c_tokens(t[1],'%s+')
   return _Declaration{
    name = t[2]..tmpdef,
    ptr = '*',
    ret = '*',
    --type = rebuild_template(m[m.n], tb, timpl),
    type = m[m.n],
    mod = concat(m,1,m.n-1),
    is_parameter = is_parameter,
    kind = kind
+  }
  end
  -- check the form: mod type& name
  t = split_c_tokens(s,'&')
  if t.n == 2 then
   --local m = split(t[1],'%s%s*')
   local m = split_c_tokens(t[1],'%s+')
   return _Declaration{
    name = t[2]..tmpdef,
    ptr = '&',
    --type = rebuild_template(m[m.n], tb, timpl),
    type = m[m.n],
    mod = concat(m,1,m.n-1),
    is_parameter = is_parameter,
    kind = kind
+  }
  end
  -- check the form: mod type* name
  local s1 = gsub(s,"(%b\[\])",function (n) return gsub(n,'%*','\1') end)
  t = split_c_tokens(s1,'%*')
  if t.n == 2 then
   t[2] = gsub(t[2],'\1','%*') -- restore * in dimension expression
   --local m = split(t[1],'%s%s*')
   local m = split_c_tokens(t[1],'%s+')
   return _Declaration{
    name = t[2]..tmpdef,
    ptr = '*',
    type = m[m.n],
    --type = rebuild_template(m[m.n], tb, timpl),
    mod = concat(m,1,m.n-1)   ,
    is_parameter = is_parameter,
    kind = kind
+  }
  end
  if kind == 'var' then
   -- check the form: mod type name
   --t = split(s,'%s%s*')
   t = split_c_tokens(s,'%s+')
   local v
   if findtype(t[t.n]) then v = create_varname() else v = t[t.n]; t.n = t.n-1 end
   return _Declaration{
    name = v..tmpdef,
    --type = rebuild_template(t[t.n], tb, timpl),
    type = t[t.n],
    mod = concat(t,1,t.n-1),
    is_parameter = is_parameter,
    kind = kind
+  }
  else -- kind == "func"
   -- check the form: mod type name
   --t = split(s,'%s%s*')
   t = split_c_tokens(s,'%s+')
   local v = t[t.n]  -- last word is the function name
   local tp,md
   if t.n>1 then
    tp = t[t.n-1]
    md = concat(t,1,t.n-2)
   end
   --if tp then tp = rebuild_template(tp, tb, timpl) end
   return _Declaration{
    name = v,
    type = tp,
    mod = md,
    is_parameter = is_parameter,
    kind = kind
+  }
  end
 end
+    -- eliminate spaces if default value is provided
+    s = gsub(s,"%s*=%s*","=")
+    s = gsub(s, "%s*<", "<")
+    local defb,tmpdef
+    defb,_,tmpdef = string.find(s, "(=.*)$")
+    if defb then
+        s = string.gsub(s, "=.*$", "")
+    else
+        tmpdef = ''
+    end
+    if kind == "var" then
+        -- check the form: void
+        if s == '' or s == 'void' then
+            return _Declaration{type = 'void', kind = kind, is_parameter = is_parameter}
+        end
+    end
+    -- check the form: mod type*& name
+    local t = split_c_tokens(s,'%*%s*&')
+    if t.n == 2 then
+        if kind == 'func' then
+            error("#invalid function return type: "..s)
+        end
+        --local m = split(t[1],'%s%s*')
+        local m = split_c_tokens(t[1],'%s+')
+        return _Declaration {
+            name = t[2]..tmpdef,
+            ptr = '*',
+            ret = '&',
+            --type = rebuild_template(m[m.n], tb, timpl),
+            type = m[m.n],
+            mod = concat(m,1,m.n-1),
+            is_parameter = is_parameter,
+            kind = kind
+        }
+    end
+    -- check the form: mod type** name
+    t = split_c_tokens(s,'%*%s*%*')
+    if t.n == 2 then
+        if kind == 'func' then
+            error("#invalid function return type: "..s)
+        end
+        --local m = split(t[1],'%s%s*')
+        local m = split_c_tokens(t[1],'%s+')
+        return _Declaration {
+            name = t[2]..tmpdef,
+            ptr = '*',
+            ret = '*',
+            --type = rebuild_template(m[m.n], tb, timpl),
+            type = m[m.n],
+            mod = concat(m,1,m.n-1),
+            is_parameter = is_parameter,
+            kind = kind
+        }
+    end
+    -- check the form: mod type& name
+    t = split_c_tokens(s,'&')
+    if t.n == 2 then
+        --local m = split(t[1],'%s%s*')
+        local m = split_c_tokens(t[1],'%s+')
+        return _Declaration {
+            name = t[2]..tmpdef,
+            ptr = '&',
+            --type = rebuild_template(m[m.n], tb, timpl),
+            type = m[m.n],
+            mod = concat(m,1,m.n-1),
+            is_parameter = is_parameter,
+            kind = kind
+        }
+    end
+    -- check the form: mod type* name
+    local s1 = gsub(s,"(%b\[\])",function (n) return gsub(n,'%*','\1') end)
+    t = split_c_tokens(s1,'%*')
+    if t.n == 2 then
+        t[2] = gsub(t[2],'\1','%*') -- restore * in dimension expression
+        --local m = split(t[1],'%s%s*')
+        local m = split_c_tokens(t[1],'%s+')
+        return _Declaration {
+            name = t[2]..tmpdef,
+            ptr = '*',
+            type = m[m.n],
+            --type = rebuild_template(m[m.n], tb, timpl),
+            mod = concat(m,1,m.n-1)   ,
+            is_parameter = is_parameter,
+            kind = kind
+        }
+    end
+    if kind == 'var' then
+        -- check the form: mod type name
+        --t = split(s,'%s%s*')
+        t = split_c_tokens(s,'%s+')
+        local v
+        if findtype(t[t.n]) then v = create_varname() else v = t[t.n]; t.n = t.n-1 end
+        return _Declaration {
+            name = v..tmpdef,
+            --type = rebuild_template(t[t.n], tb, timpl),
+            type = t[t.n],
+            mod = concat(t,1,t.n-1),
+            is_parameter = is_parameter,
+            kind = kind
+        }
+    else -- kind == "func"
+        -- check the form: mod type name
+        --t = split(s,'%s%s*')
+        t = split_c_tokens(s,'%s+')
+        local v = t[t.n]  -- last word is the function name
+        local tp,md
+        if t.n>1 then
+            tp = t[t.n-1]
+            md = concat(t,1,t.n-2)
+        end
+        --if tp then tp = rebuild_template(tp, tb, timpl) end
+        return _Declaration {
+            name = v,
+            type = tp,
+            mod = md,
+            is_parameter = is_parameter,
+            kind = kind
+        }
+    end
+end

code/branches/buildsystem2/src/tolua/lua/define.lua

-                      r2087
+                      r2509
 --   name = constant name
 classDefine = {
  name = '',
+    name = '',
+}
 classDefine.__index = classDefine
 …
 -- register define
 function classDefine:register (pre)
         if not self:check_public_access() then
                 return
         end
+    if not self:check_public_access() then
+        return
+    end
  pre = pre or ''
  output(pre..'tolua_constant(tolua_S,"'..self.lname..'",'..self.name..');')
+    pre = pre or ''
+    output(pre..'tolua_constant(tolua_S,"'..self.lname..'",'..self.name..');')
 end
 -- Print method
 function classDefine:print (ident,close)
  print(ident.."Define{")
  print(ident.." name = '"..self.name.."',")
  print(ident.." lname = '"..self.lname.."',")
  print(ident.."}"..close)
+    print(ident.."Define{")
+    print(ident.." name = '"..self.name.."',")
+    print(ident.." lname = '"..self.lname.."',")
+    print(ident.."}"..close)
 end
 …
 -- Internal constructor
 function _Define (t)
  setmetatable(t,classDefine)
  t:buildnames()
+    setmetatable(t,classDefine)
+    t:buildnames()
  if t.name == '' then
   error("#invalid define")
  end
+    if t.name == '' then
+        error("#invalid define")
+    end
  append(t)
  return t
+    append(t)
+    return t
 end
 …
 -- Expects a string representing the constant name
 function Define (n)
  return _Define{
   name = n
+ }
+    return _Define {
+        name = n
+    }
 end

code/branches/buildsystem2/src/tolua/lua/doit.lua

-                      r2087
+                      r2509
 function parse_extra()
         for k,v in ipairs(_extra_parameters or {}) do
                 local b,e,name,value = string.find(v, "^([^=])=(.*)$")
                 if b then
                         _extra_parameters[name] = value
                 else
                         _extra_parameters[v] = true
                 end
         end
+    for k,v in ipairs(_extra_parameters or {}) do
+        local b,e,name,value = string.find(v, "^([^=])=(.*)$")
+        if b then
+            _extra_parameters[name] = value
+        else
+            _extra_parameters[v] = true
+        end
+    end
 end
 function doit ()
         -- define package name, if not provided
         if not flags.n then
                 if flags.f then
                         flags.n = gsub(flags.f,"%..*$","")
                         _,_,flags.n = string.find(flags.n, "([^/\\]*)$")
                 else
                         error("#no package name nor input file provided")
                 end
         end
+    -- define package name, if not provided
+    if not flags.n then
+        if flags.f then
+            flags.n = gsub(flags.f,"%..*$","")
+            _,_,flags.n = string.find(flags.n, "([^/\\]*)$")
+        else
+            error("#no package name nor input file provided")
+        end
+    end
         -- parse table with extra paramters
         parse_extra()
+    -- parse table with extra paramters
+    parse_extra()
+        -- do this after setting the package name
         if flags['L'] then
+                dofile(flags['L'])
         end
+    -- get potential working directory
+    if not flags.w then
+        flags.w = ''
+    end
+        -- add cppstring
+        if not flags['S'] then
+                _basic['string'] = 'cppstring'
+                _basic['std::string'] = 'cppstring'
+                _basic_ctype.cppstring = 'const char*'
+        end
+    -- do this after setting the package name
+    if flags.L then
+        if string.sub(flags.L, 1, 1) == '/' or string.sub(flags.L, 1, 1) == '\\' then
+            dofile(flags.L)
+        else
+            dofile(flags.w..'/'..flags.L)
+        end
+    end
+        -- proccess package
+        local p  = Package(flags.n,flags.f)
+    -- add cppstring
+    if not flags.S then
+        _basic['string'] = 'cppstring'
+        _basic['std::string'] = 'cppstring'
+        _basic_ctype.cppstring = 'const char*'
+    end
+        if flags.p then
+                return        -- only parse
+        end
+    -- proccess package
+    local file
+    if flags.f then
+        if string.sub(flags.f, 1, 1) == '/' or string.sub(flags.f, 1, 1) == '\\' then
+            file = flags.f
+        else
+            file = flags.w..'/'..flags.f
+        end
+    else
+        file = flags.f
+    end
+    local p  = Package(flags.n, file)
+        if flags.o then
+                local st,msg = writeto(flags.o)
+                if not st then
+                        error('#'..msg)
+                end
+        end
+    if flags.p then
+        return        -- only parse
+    end
+        p:decltype()
+        if flags.P then
+                p:print()
+        else
+                p:preamble()
+                p:supcode()
+                p:register()
+                push(p)
+                post_output_hook(p)
+                pop()
+        end
+    if flags.o then
+        local file
+        if string.sub(flags.o, 1, 1) == '/' or string.sub(flags.o, 1, 1) == '\\' then
+            file = flags.o
+        else
+            file = flags.w..'/'..flags.o
+        end
+        local st,msg = writeto(file)
+        if not st then
+            error('#'..msg)
+        end
+    end
+        if flags.o then
+                writeto()
+        end
+    p:decltype()
+    if flags.P then
+        p:print()
+    else
+        p:preamble()
+        p:supcode()
+        p:register()
+        push(p)
+        post_output_hook(p)
+        pop()
+    end
+        -- write header file
+        if not flags.P then
+                if flags.H then
+                        local st,msg = writeto(flags.H)
+                        if not st then
+                                error('#'..msg)
+                        end
+                        p:header()
+                        writeto()
+                end
+        end
+    if flags.o then
+        writeto()
+    end
+    -- write header file
+    if not flags.P then
+        if flags.H then
+            local file
+            if string.sub(flags.H, 1, 1) == '/' or string.sub(flags.H, 1, 1) == '\\' then
+                file = flags.H
+            else
+                file = flags.w..'/'..flags.H
+            end
+            local st,msg = writeto(file)
+            if not st then
+                error('#'..msg)
+            end
+            p:header()
+            writeto()
+        end
+    end
 end

code/branches/buildsystem2/src/tolua/lua/enumerate.lua

-                      r2087
+                      r2509
 -- register enumeration
 function classEnumerate:register (pre)
  pre = pre or ''
  local nspace = getnamespace(classContainer.curr)
  local i=1
  while self[i] do
   output(pre..'tolua_constant(tolua_S,"'..self.lnames[i]..'",'..nspace..self[i]..');')
   i = i+1
  end
+    pre = pre or ''
+    local nspace = getnamespace(classContainer.curr)
+    local i=1
+    while self[i] do
+        output(pre..'tolua_constant(tolua_S,"'..self.lnames[i]..'",'..nspace..self[i]..');')
+        i = i+1
+    end
 end
 -- Print method
 function classEnumerate:print (ident,close)
  print(ident.."Enumerate{")
  print(ident.." name = "..self.name)
  local i=1
  while self[i] do
   print(ident.." '"..self[i].."'("..self.lnames[i].."),")
   i = i+1
  end
  print(ident.."}"..close)
+    print(ident.."Enumerate{")
+    print(ident.." name = "..self.name)
+    local i=1
+    while self[i] do
+        print(ident.." '"..self[i].."'("..self.lnames[i].."),")
+        i = i+1
+    end
+    print(ident.."}"..close)
 end
 -- Internal constructor
 function _Enumerate (t,varname)
  setmetatable(t,classEnumerate)
  append(t)
  appendenum(t)
          if varname and varname ~= "" then
                 if t.name ~= "" then
                         Variable(t.name.." "..varname)
                 else
                         local ns = getcurrnamespace()
                         warning("Variable "..ns..varname.." of type <anonymous enum> is declared as read-only")
                         Variable("tolua_readonly int "..varname)
                 end
         end
 return t
+    setmetatable(t,classEnumerate)
+    append(t)
+    appendenum(t)
+    if varname and varname ~= "" then
+        if t.name ~= "" then
+            Variable(t.name.." "..varname)
+        else
+            local ns = getcurrnamespace()
+            warning("Variable "..ns..varname.." of type <anonymous enum> is declared as read-only")
+            Variable("tolua_readonly int "..varname)
+        end
+    end
+    return t
 end
 …
 -- Expects a string representing the enumerate body
 function Enumerate (n,b,varname)
         b = string.gsub(b, ",[%s\n]*}", "\n}") -- eliminate last ','
  local t = split(strsub(b,2,-2),',') -- eliminate braces
  local i = 1
  local e = {n=0}
  while t[i] do
   local tt = split(t[i],'=')  -- discard initial value
   e.n = e.n + 1
   e[e.n] = tt[1]
   i = i+1
  end
  -- set lua names
  i  = 1
  e.lnames = {}
  local ns = getcurrnamespace()
  while e[i] do
   local t = split(e[i],'@')
   e[i] = t[1]
                 if not t[2] then
                  t[2] = applyrenaming(t[1])
                 end
   e.lnames[i] = t[2] or t[1]
   _global_enums[ ns..e[i] ] = (ns..e[i])
   i = i+1
  end
         e.name = n
         if n ~= "" then
                 Typedef("int "..n)
         end
  return _Enumerate(e, varname)
+    b = string.gsub(b, ",[%s\n]*}", "\n}") -- eliminate last ','
+    local t = split(strsub(b,2,-2),',') -- eliminate braces
+    local i = 1
+    local e = {n=0}
+    while t[i] do
+        local tt = split(t[i],'=')  -- discard initial value
+        e.n = e.n + 1
+        e[e.n] = tt[1]
+        i = i+1
+    end
+    -- set lua names
+    i  = 1
+    e.lnames = {}
+    local ns = getcurrnamespace()
+    while e[i] do
+        local t = split(e[i],'@')
+        e[i] = t[1]
+        if not t[2] then
+            t[2] = applyrenaming(t[1])
+        end
+        e.lnames[i] = t[2] or t[1]
+        _global_enums[ ns..e[i] ] = (ns..e[i])
+        i = i+1
+    end
+    e.name = n
+    if n ~= "" then
+        Typedef("int "..n)
+    end
+    return _Enumerate(e, varname)
 end

code/branches/buildsystem2/src/tolua/lua/feature.lua

-                      r2087
+                      r2509
 -- check if it requires collection
 function classFeature:requirecollection (t)
  return false
+    return false
 end
 -- build names
 function classFeature:buildnames ()
  if self.name and self.name~='' then
   local n = split(self.name,'@')
   self.name = n[1]
   if not n[2] then
    n[2] = applyrenaming(n[1])
   end
   self.lname = n[2] or gsub(n[1],"%[.-%]","")
   self.original_name = self.name
   self.lname = clean_template(self.lname)
  end
  if not self.is_parameter then
          self.name = getonlynamespace() .. self.name
  end
+    if self.name and self.name~='' then
+        local n = split(self.name,'@')
+        self.name = n[1]
+        if not n[2] then
+            n[2] = applyrenaming(n[1])
+        end
+        self.lname = n[2] or gsub(n[1],"%[.-%]","")
+        self.original_name = self.name
+        self.lname = clean_template(self.lname)
+    end
+    if not self.is_parameter then
+        self.name = getonlynamespace() .. self.name
+    end
  local parent = classContainer.curr
  if parent then
         self.access = parent.curr_member_access
  else
  end
+    local parent = classContainer.curr
+    if parent then
+        self.access = parent.curr_member_access
+    else
+    end
 end
 function classFeature:check_public_access()
         if self.access and self.access ~= 0 then
                 return false
         end
+    if self.access and self.access ~= 0 then
+        return false
+    end
         local parent = classContainer.curr
         while parent do
                 if parent.access and parent.access ~= 0 then
                         return false
                 end
                 parent = parent.prox
         end
         return true
+    local parent = classContainer.curr
+    while parent do
+        if parent.access and parent.access ~= 0 then
+            return false
+        end
+        parent = parent.prox
+    end
+    return true
 end
 function clean_template(t)
         return string.gsub(t, "[<>:, %*]", "_")
+    return string.gsub(t, "[<>:, %*]", "_")
 end
 …
 -- it returns the container class name or nil.
 function classFeature:incontainer (which)
  if self.parent then
   local parent = self.parent
   while parent do
    if parent.classtype == which then
     return parent.name
    end
    parent = parent.parent
   end
  end
  return nil
+    if self.parent then
+        local parent = self.parent
+        while parent do
+            if parent.classtype == which then
+                return parent.name
+            end
+            parent = parent.parent
+        end
+    end
+    return nil
 end
 function classFeature:inclass ()
  return self:incontainer('class')
+    return self:incontainer('class')
 end
 function classFeature:inmodule ()
  return self:incontainer('module')
+    return self:incontainer('module')
 end
 function classFeature:innamespace ()
  return self:incontainer('namespace')
+    return self:incontainer('namespace')
 end
 …
 function classFeature:cfuncname (n)
  if self.parent then
   n = self.parent:cfuncname(n)
  end
+    if self.parent then
+        n = self.parent:cfuncname(n)
+    end
   n = string.gsub(n..'_'.. (self.lname or self.name), "[<>:, \.%*&]", "_")
+    n = string.gsub(n..'_'.. (self.lname or self.name), "[<>:, \.%*&]", "_")
   return n
+    return n
 end

code/branches/buildsystem2/src/tolua/lua/function.lua

-                      r2087
+                      r2509
     if e.ret == "nil" then
         output("catch(",nameToEcho," CEGUIDeadException(",exceptionDefs[e.name].var,"))\n{\n")
         else
         output("catch(",nameToEcho,exceptionDefs[e.name].var,")\n{\n")
         end
+    else
+        output("catch(",nameToEcho,exceptionDefs[e.name].var,")\n{\n")
+    end
     -- if just a nil
 …
 --  const = if it is a method receiving a const "this".
 classFunction = {
  mod = '',
  type = '',
  ptr = '',
  name = '',
  args = {n=0},
  const = '',
+    mod = '',
+    type = '',
+    ptr = '',
+    name = '',
+    args = {n=0},
+    const = '',
+}
 classFunction.__index = classFunction
 …
 -- declare tags
 function classFunction:decltype ()
  self.type = typevar(self.type)
  if strfind(self.mod,'const') then
          self.type = 'const '..self.type
                 self.mod = gsub(self.mod,'const','')
         end
  local i=1
  while self.args[i] do
   self.args[i]:decltype()
   i = i+1
  end
+    self.type = typevar(self.type)
+    if strfind(self.mod,'const') then
+        self.type = 'const '..self.type
+        self.mod = gsub(self.mod,'const','')
+    end
+    local i=1
+    while self.args[i] do
+        self.args[i]:decltype()
+        i = i+1
+    end
 end
 …
 function classFunction:supcode (local_constructor)
  local overload = strsub(self.cname,-2,-1) - 1  -- indicate overloaded func
  local nret = 0      -- number of returned values
  local class = self:inclass()
  local _,_,static = strfind(self.mod,'^%s*(static)')
  if class then
         if self.name == 'new' and self.parent.flags.pure_virtual then
                 -- no constructor for classes with pure virtual methods
                 return
         end
         if local_constructor then
                 output("/* method: new_local of class ",class," */")
         else
                 output("/* method:",self.name," of class ",class," */")
         end
  else
   output("/* function:",self.name," */")
  end
  if local_constructor then
   output("#ifndef TOLUA_DISABLE_"..self.cname.."_local")
   output("\nstatic int",self.cname.."_local","(lua_State* tolua_S)")
  else
   output("#ifndef TOLUA_DISABLE_"..self.cname)
   output("\nstatic int",self.cname,"(lua_State* tolua_S)")
  end
  output("{")
  -- check types
         if overload < 0 then
          output('#ifndef TOLUA_RELEASE\n')
         end
         output(' tolua_Error tolua_err;')
  output(' if (\n')
  -- check self
  local narg
  if class then narg=2 else narg=1 end
  if class then
                 local func = 'tolua_isusertype'
                 local type = self.parent.type
                 if self.name=='new' or static~=nil then
                         func = 'tolua_isusertable'
                         type = self.parent.type
                 end
                 if self.const ~= '' then
                         type = "const "..type
                 end
                 output('     !'..func..'(tolua_S,1,"'..type..'",0,&tolua_err) ||\n')
  end
  -- check args
  if self.args[1].type ~= 'void' then
   local i=1
   while self.args[i] do
    local btype = isbasic(self.args[i].type)
    if btype ~= 'value' and btype ~= 'state' then
     output('     !'..self.args[i]:outchecktype(narg)..' ||\n')
    end
    if btype ~= 'state' then
            narg = narg+1
    end
    i = i+1
   end
  end
  -- check end of list
  output('     !tolua_isnoobj(tolua_S,'..narg..',&tolua_err)\n )')
         output('  goto tolua_lerror;')
  output(' else\n')
         if overload < 0 then
          output('#endif\n')
         end
         output(' {')
  -- declare self, if the case
  local narg
  if class then narg=2 else narg=1 end
  if class and self.name~='new' and static==nil then
   output(' ',self.const,self.parent.type,'*','self = ')
   output('(',self.const,self.parent.type,'*) ')
   output('tolua_tousertype(tolua_S,1,0);')
  elseif static then
   _,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
  end
  -- declare parameters
  if self.args[1].type ~= 'void' then
   local i=1
   while self.args[i] do
    self.args[i]:declare(narg)
    if isbasic(self.args[i].type) ~= "state" then
            narg = narg+1
    end
    i = i+1
   end
  end
  -- check self
  if class and self.name~='new' and static==nil then
          output('#ifndef TOLUA_RELEASE\n')
   output('  if (!self) tolua_error(tolua_S,"invalid \'self\' in function \''..self.name..'\'",NULL);');
          output('#endif\n')
  end
  -- get array element values
  if class then narg=2 else narg=1 end
  if self.args[1].type ~= 'void' then
   local i=1
   while self.args[i] do
    self.args[i]:getarray(narg)
    narg = narg+1
    i = i+1
   end
  end
  --------------------------------------------------
  -- CEGUILua mod
  -- init exception handling
  local throws = false
  do
   local pattern = "tolua_throws|.*|"
   local i,j = string.find(self.mod, pattern)
   if i then
    throws = {}
    -- ensure table is empty.  Used to be: table.setn(throws,0)
    for x in pairs(throws) do
      throws[x] = nil
    end
    local excepts = string.sub(self.mod, i+12,j)
    local epattern = "|.-|"
    local i,j = string.find(excepts, epattern)
    while i do
     local e = string.sub(excepts,i+1,j-1)
     local _,_,name,rest = string.find(e, "([%w:_]+),?(.*)")
     table.insert(throws,{name=name, ret=rest})
     i,j = string.find(excepts, epattern, j)
    end
    self.mod = string.gsub(self.mod, pattern, "")
   end
  end
  local exRaiseError = false
  --------------------------------------------------
  local out = string.find(self.mod, "tolua_outside")
  ---------------
  -- CEGUILua mod
  -- remove "tolua_outside" from self.mod
  if out then
     self.mod = string.gsub(self.mod, "tolua_outside", "")
  end
  -- call function
  if class and self.name=='delete' then
   output('  delete self;')
  elseif class and self.name == 'operator&[]' then
   if flags['1'] then -- for compatibility with tolua5 ?
         output('  self->operator[](',self.args[1].name,'-1) = ',self.args[2].name,';')
   else
     output('  self->operator[](',self.args[1].name,') = ',self.args[2].name,';')
   end
  else
   -- CEGUILua mod begin- throws
   if throws then
     for i=1,table.getn(throws) do
         if string.find(throws[i].ret, "error") then
             output("char errorBuffer["..exceptionMessageBufferSize.."];\n")
             output("bool errorDoIt = false;\n")
             exRaiseError = true
             break
         end
     end
     output("try\n")
   end
   -- CEGUILua mod end - throws
   output('  {')
   if self.type ~= '' and self.type ~= 'void' then
    output('  ',self.mod,self.type,self.ptr,'tolua_ret = ')
    output('(',self.mod,self.type,self.ptr,') ')
   else
    output('  ')
   end
   if class and self.name=='new' then
    output('new',self.type,'(')
   elseif class and static then
         if out then
                 output(self.name,'(')
         else
                 output(class..'::'..self.name,'(')
         end
   elseif class then
         if out then
                 output(self.name,'(')
         else
           if self.cast_operator then
                 output('static_cast<',self.mod,self.type,self.ptr,'>(*self')
           else
                 output('self->'..self.name,'(')
           end
         end
   else
    output(self.name,'(')
   end
   if out and not static then
         output('self')
         if self.args[1] and self.args[1].name ~= '' then
                 output(',')
         end
   end
   -- write parameters
   local i=1
   while self.args[i] do
    self.args[i]:passpar()
    i = i+1
    if self.args[i] then
     output(',')
    end
   end
   if class and self.name == 'operator[]' and flags['1'] then
         output('-1);')
   else
         output(');')
   end
   -- return values
   if self.type ~= '' and self.type ~= 'void' then
    nret = nret + 1
    local t,ct = isbasic(self.type)
    if t then
         if self.cast_operator and _basic_raw_push[t] then
                 output('   ',_basic_raw_push[t],'(tolua_S,(',ct,')tolua_ret);')
         else
             output('   tolua_push'..t..'(tolua_S,(',ct,')tolua_ret);')
         end
    else
                          t = self.type
                          new_t = string.gsub(t, "const%s+", "")
     if self.ptr == '' then
      output('   {')
      output('#ifdef __cplusplus\n')
      output('    void* tolua_obj = new',new_t,'(tolua_ret);')
      output('    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"',t,'");')
      output('#else\n')
      output('    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(',t,'));')
      output('    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"',t,'");')
      output('#endif\n')
      output('   }')
     elseif self.ptr == '&' then
      output('   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"',t,'");')
     else
         if local_constructor then
           output('   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"',t,'");')
         else
                      output('   tolua_pushusertype(tolua_S,(void*)tolua_ret,"',t,'");')
             end
     end
    end
   end
   local i=1
   while self.args[i] do
    nret = nret + self.args[i]:retvalue()
    i = i+1
   end
   output('  }')
   ------------------------------------------
   -- CEGUILua mod
   -- finish exception handling
   -- catch
   if throws then
    outputExceptionCatchBlocks(self.name, throws, exRaiseError)
   end
   ------------------------------------------
   -- set array element values
   if class then narg=2 else narg=1 end
   if self.args[1].type ~= 'void' then
    local i=1
    while self.args[i] do
     self.args[i]:setarray(narg)
     narg = narg+1
     i = i+1
    end
   end
   -- free dynamically allocated array
   if self.args[1].type ~= 'void' then
    local i=1
    while self.args[i] do
     self.args[i]:freearray()
     i = i+1
    end
   end
  end
  output(' }')
  output(' return '..nret..';')
  -- call overloaded function or generate error
         if overload < 0 then
                 output('#ifndef TOLUA_RELEASE\n')
                 output('tolua_lerror:\n')
                 output(' tolua_error(tolua_S,"#ferror in function \''..self.lname..'\'.",&tolua_err);')
                 output(' return 0;')
                 output('#endif\n')
         else
                 local _local = ""
                 if local_constructor then
                         _local = "_local"
                 end
                 output('tolua_lerror:\n')
                 output(' return '..strsub(self.cname,1,-3)..format("%02d",overload).._local..'(tolua_S);')
         end
  output('}')
  output('#endif //#ifndef TOLUA_DISABLE\n')
  output('\n')
         -- recursive call to write local constructor
         if class and self.name=='new' and not local_constructor then
                 self:supcode(1)
         end
+    local overload = strsub(self.cname,-2,-1) - 1  -- indicate overloaded func
+    local nret = 0      -- number of returned values
+    local class = self:inclass()
+    local _,_,static = strfind(self.mod,'^%s*(static)')
+    if class then
+        if self.name == 'new' and self.parent.flags.pure_virtual then
+            -- no constructor for classes with pure virtual methods
+            return
+        end
+        if local_constructor then
+           output("/* method: new_local of class ",class," */")
+       else
+           output("/* method:",self.name," of class ",class," */")
+       end
+    else
+        output("/* function:",self.name," */")
+    end
+    if local_constructor then
+        output("#ifndef TOLUA_DISABLE_"..self.cname.."_local")
+        output("\nstatic int",self.cname.."_local","(lua_State* tolua_S)")
+    else
+        output("#ifndef TOLUA_DISABLE_"..self.cname)
+        output("\nstatic int",self.cname,"(lua_State* tolua_S)")
+    end
+    output("{")
+    -- check types
+    if overload < 0 then
+        output('#ifndef TOLUA_RELEASE\n')
+    end
+    output(' tolua_Error tolua_err;')
+    output(' if (\n')
+    -- check self
+    local narg
+    if class then narg=2 else narg=1 end
+    if class then
+        local func = 'tolua_isusertype'
+        local type = self.parent.type
+        if self.name=='new' or static~=nil then
+            func = 'tolua_isusertable'
+            type = self.parent.type
+        end
+        if self.const ~= '' then
+            type = "const "..type
+        end
+        output('     !'..func..'(tolua_S,1,"'..type..'",0,&tolua_err) ||\n')
+    end
+    -- check args
+    if self.args[1].type ~= 'void' then
+        local i=1
+        while self.args[i] do
+            local btype = isbasic(self.args[i].type)
+            if btype ~= 'value' and btype ~= 'state' then
+                output('     !'..self.args[i]:outchecktype(narg)..' ||\n')
+            end
+            if btype ~= 'state' then
+                narg = narg+1
+            end
+            i = i+1
+        end
+    end
+    -- check end of list
+    output('     !tolua_isnoobj(tolua_S,'..narg..',&tolua_err)\n )')
+    output('  goto tolua_lerror;')
+    output(' else\n')
+    if overload < 0 then
+        output('#endif\n')
+    end
+    output(' {')
+    -- declare self, if the case
+    local narg
+    if class then narg=2 else narg=1 end
+    if class and self.name~='new' and static==nil then
+        output(' ',self.const,self.parent.type,'*','self = ')
+        output('(',self.const,self.parent.type,'*) ')
+        output('tolua_tousertype(tolua_S,1,0);')
+    elseif static then
+        _,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
+    end
+    -- declare parameters
+    if self.args[1].type ~= 'void' then
+        local i=1
+        while self.args[i] do
+            self.args[i]:declare(narg)
+            if isbasic(self.args[i].type) ~= "state" then
+                narg = narg+1
+            end
+            i = i+1
+        end
+    end
+    -- check self
+    if class and self.name~='new' and static==nil then
+        output('#ifndef TOLUA_RELEASE\n')
+        output('  if (!self) tolua_error(tolua_S,"invalid \'self\' in function \''..self.name..'\'",NULL);');
+        output('#endif\n')
+    end
+    -- get array element values
+    if class then narg=2 else narg=1 end
+    if self.args[1].type ~= 'void' then
+        local i=1
+        while self.args[i] do
+            self.args[i]:getarray(narg)
+            narg = narg+1
+            i = i+1
+        end
+    end
+    --------------------------------------------------
+    -- CEGUILua mod
+    -- init exception handling
+    local throws = false
+    do
+        local pattern = "tolua_throws|.*|"
+        local i,j = string.find(self.mod, pattern)
+        if i then
+            throws = {}
+            -- ensure table is empty.  Used to be: table.setn(throws,0)
+            for x in pairs(throws) do
+                throws[x] = nil
+            end
+            local excepts = string.sub(self.mod, i+12,j)
+            local epattern = "|.-|"
+            local i,j = string.find(excepts, epattern)
+            while i do
+                local e = string.sub(excepts,i+1,j-1)
+                local _,_,name,rest = string.find(e, "([%w:_]+),?(.*)")
+                table.insert(throws,{name=name, ret=rest})
+                i,j = string.find(excepts, epattern, j)
+            end
+            self.mod = string.gsub(self.mod, pattern, "")
+        end
+    end
+    local exRaiseError = false
+    --------------------------------------------------
+    local out = string.find(self.mod, "tolua_outside")
+    ---------------
+    -- CEGUILua mod
+    -- remove "tolua_outside" from self.mod
+    if out then
+        self.mod = string.gsub(self.mod, "tolua_outside", "")
+    end
+    -- call function
+    if class and self.name=='delete' then
+        output('  delete self;')
+    elseif class and self.name == 'operator&[]' then
+        if flags['1'] then -- for compatibility with tolua5 ?
+            output('  self->operator[](',self.args[1].name,'-1) = ',self.args[2].name,';')
+        else
+            output('  self->operator[](',self.args[1].name,') = ',self.args[2].name,';')
+        end
+    else
+    -- CEGUILua mod begin- throws
+    if throws then
+        for i=1,table.getn(throws) do
+            if string.find(throws[i].ret, "error") then
+                output("char errorBuffer["..exceptionMessageBufferSize.."];\n")
+                output("bool errorDoIt = false;\n")
+                exRaiseError = true
+                break
+            end
+        end
+        output("try\n")
+    end
+    -- CEGUILua mod end - throws
+    output('  {')
+    if self.type ~= '' and self.type ~= 'void' then
+        output('  ',self.mod,self.type,self.ptr,'tolua_ret = ')
+        output('(',self.mod,self.type,self.ptr,') ')
+    else
+        output('  ')
+    end
+    if class and self.name=='new' then
+        output('new',self.type,'(')
+    elseif class and static then
+        if out then
+            output(self.name,'(')
+        else
+            output(class..'::'..self.name,'(')
+        end
+    elseif class then
+        if out then
+            output(self.name,'(')
+        else
+            if self.cast_operator then
+                output('static_cast<',self.mod,self.type,self.ptr,'>(*self')
+            else
+                output('self->'..self.name,'(')
+            end
+        end
+    else
+        output(self.name,'(')
+    end
+    if out and not static then
+        output('self')
+        if self.args[1] and self.args[1].name ~= '' then
+            output(',')
+        end
+    end
+    -- write parameters
+    local i=1
+    while self.args[i] do
+        self.args[i]:passpar()
+        i = i+1
+        if self.args[i] then
+            output(',')
+        end
+    end
+    if class and self.name == 'operator[]' and flags['1'] then
+        output('-1);')
+    else
+        output(');')
+    end
+    -- return values
+    if self.type ~= '' and self.type ~= 'void' then
+        nret = nret + 1
+        local t,ct = isbasic(self.type)
+        if t then
+            if self.cast_operator and _basic_raw_push[t] then
+                output('   ',_basic_raw_push[t],'(tolua_S,(',ct,')tolua_ret);')
+            else
+                output('   tolua_push'..t..'(tolua_S,(',ct,')tolua_ret);')
+            end
+            else
+                t = self.type
+                new_t = string.gsub(t, "const%s+", "")
+                if self.ptr == '' then
+                    output('   {')
+                    output('#ifdef __cplusplus\n')
+                    output('    void* tolua_obj = new',new_t,'(tolua_ret);')
+                    output('    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"',t,'");')
+                    output('#else\n')
+                    output('    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(',t,'));')
+                    output('    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"',t,'");')
+                    output('#endif\n')
+                    output('   }')
+                elseif self.ptr == '&' then
+                    output('   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"',t,'");')
+                else
+                    if local_constructor then
+                        output('   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"',t,'");')
+                    else
+                        output('   tolua_pushusertype(tolua_S,(void*)tolua_ret,"',t,'");')
+                    end
+                end
+            end
+        end
+        local i=1
+        while self.args[i] do
+            nret = nret + self.args[i]:retvalue()
+            i = i+1
+        end
+        output('  }')
+        ------------------------------------------
+        -- CEGUILua mod
+        -- finish exception handling
+        -- catch
+        if throws then
+            outputExceptionCatchBlocks(self.name, throws, exRaiseError)
+        end
+        ------------------------------------------
+        -- set array element values
+        if class then narg=2 else narg=1 end
+        if self.args[1].type ~= 'void' then
+            local i=1
+            while self.args[i] do
+                self.args[i]:setarray(narg)
+                narg = narg+1
+                i = i+1
+            end
+        end
+        -- free dynamically allocated array
+        if self.args[1].type ~= 'void' then
+            local i=1
+            while self.args[i] do
+                self.args[i]:freearray()
+                i = i+1
+            end
+        end
+    end
+    output(' }')
+    output(' return '..nret..';')
+    -- call overloaded function or generate error
+    if overload < 0 then
+        output('#ifndef TOLUA_RELEASE\n')
+        output('tolua_lerror:\n')
+        output(' tolua_error(tolua_S,"#ferror in function \''..self.lname..'\'.",&tolua_err);')
+        output(' return 0;')
+        output('#endif\n')
+    else
+        local _local = ""
+        if local_constructor then
+            _local = "_local"
+        end
+        output('tolua_lerror:\n')
+        output(' return '..strsub(self.cname,1,-3)..format("%02d",overload).._local..'(tolua_S);')
+    end
+    output('}')
+    output('#endif //#ifndef TOLUA_DISABLE\n')
+    output('\n')
+    -- recursive call to write local constructor
+    if class and self.name=='new' and not local_constructor then
+        self:supcode(1)
+    end
 end
 …
 function classFunction:register (pre)
         if not self:check_public_access() then
                 return
         end
         if self.name == 'new' and self.parent.flags.pure_virtual then
                 -- no constructor for classes with pure virtual methods
                 return
         end
  output(pre..'tolua_function(tolua_S,"'..self.lname..'",'..self.cname..');')
   if self.name == 'new' then
           output(pre..'tolua_function(tolua_S,"new_local",'..self.cname..'_local);')
           output(pre..'tolua_function(tolua_S,".call",'..self.cname..'_local);')
           --output(' tolua_set_call_event(tolua_S,'..self.cname..'_local, "'..self.parent.type..'");')
   end
+    if not self:check_public_access() then
+        return
+    end
+    if self.name == 'new' and self.parent.flags.pure_virtual then
+        -- no constructor for classes with pure virtual methods
+        return
+    end
+    output(pre..'tolua_function(tolua_S,"'..self.lname..'",'..self.cname..');')
+    if self.name == 'new' then
+        output(pre..'tolua_function(tolua_S,"new_local",'..self.cname..'_local);')
+        output(pre..'tolua_function(tolua_S,".call",'..self.cname..'_local);')
+        --output(' tolua_set_call_event(tolua_S,'..self.cname..'_local, "'..self.parent.type..'");')
+    end
 end
 -- Print method
 function classFunction:print (ident,close)
  print(ident.."Function{")
  print(ident.." mod  = '"..self.mod.."',")
  print(ident.." type = '"..self.type.."',")
  print(ident.." ptr  = '"..self.ptr.."',")
  print(ident.." name = '"..self.name.."',")
  print(ident.." lname = '"..self.lname.."',")
  print(ident.." const = '"..self.const.."',")
  print(ident.." cname = '"..self.cname.."',")
  print(ident.." lname = '"..self.lname.."',")
  print(ident.." args = {")
  local i=1
  while self.args[i] do
   self.args[i]:print(ident.."  ",",")
   i = i+1
  end
  print(ident.." }")
  print(ident.."}"..close)
+    print(ident.."Function{")
+    print(ident.." mod  = '"..self.mod.."',")
+    print(ident.." type = '"..self.type.."',")
+    print(ident.." ptr  = '"..self.ptr.."',")
+    print(ident.." name = '"..self.name.."',")
+    print(ident.." lname = '"..self.lname.."',")
+    print(ident.." const = '"..self.const.."',")
+    print(ident.." cname = '"..self.cname.."',")
+    print(ident.." lname = '"..self.lname.."',")
+    print(ident.." args = {")
+    local i=1
+    while self.args[i] do
+        self.args[i]:print(ident.."  ",",")
+        i = i+1
+    end
+    print(ident.." }")
+    print(ident.."}"..close)
 end
 -- check if it returns an object by value
 function classFunction:requirecollection (t)
         local r = false
         if self.type ~= '' and not isbasic(self.type) and self.ptr=='' then
                 local type = gsub(self.type,"%s*const%s+","")
          t[type] = "tolua_collect_" .. clean_template(type)
          r = true
         end
         local i=1
         while self.args[i] do
                 r = self.args[i]:requirecollection(t) or r
                 i = i+1
         end
         return r
+    local r = false
+    if self.type ~= '' and not isbasic(self.type) and self.ptr=='' then
+        local type = gsub(self.type,"%s*const%s+","")
+        t[type] = "tolua_collect_" .. clean_template(type)
+        r = true
+    end
+    local i=1
+    while self.args[i] do
+        r = self.args[i]:requirecollection(t) or r
+        i = i+1
+    end
+    return r
 end
 -- determine lua function name overload
 function classFunction:overload ()
  return self.parent:overload(self.lname)
+    return self.parent:overload(self.lname)
 end
 …
 function param_object(par) -- returns true if the parameter has an object as its default value
         if not string.find(par, '=') then return false end -- it has no default value
         local _,_,def = string.find(par, "=(.*)$")
         if string.find(par, "|") then -- a list of flags
                 return true
         end
         if string.find(par, "%*") then -- it's a pointer with a default value
                 if string.find(par, '=%s*new') then -- it's a pointer with an instance as default parameter.. is that valid?
                         return true
                 end
                 return false -- default value is 'NULL' or something
         end
         if string.find(par, "[%(&]") then
                 return true
         end -- default value is a constructor call (most likely for a const reference)
         --if string.find(par, "&") then
         --      if string.find(def, ":") or string.find(def, "^%s*new%s+") then
         --              -- it's a reference with default to something like Class::member, or 'new Class'
         --              return true
         --      end
         --end
         return false -- ?
+    if not string.find(par, '=') then return false end -- it has no default value
+    local _,_,def = string.find(par, "=(.*)$")
+    if string.find(par, "|") then -- a list of flags
+        return true
+    end
+    if string.find(par, "%*") then -- it's a pointer with a default value
+        if string.find(par, '=%s*new') then -- it's a pointer with an instance as default parameter.. is that valid?
+            return true
+        end
+        return false -- default value is 'NULL' or something
+    end
+    if string.find(par, "[%(&]") then
+        return true
+    end -- default value is a constructor call (most likely for a const reference)
+    --if string.find(par, "&") then
+    --    if string.find(def, ":") or string.find(def, "^%s*new%s+") then
+    --        -- it's a reference with default to something like Class::member, or 'new Class'
+    --        return true
+    --    end
+    --end
+    return false -- ?
 end
 function strip_last_arg(all_args, last_arg) -- strips the default value from the last argument
         local _,_,s_arg = string.find(last_arg, "^([^=]+)")
         last_arg = string.gsub(last_arg, "([%%%(%)])", "%%%1");
         all_args = string.gsub(all_args, "%s*,%s*"..last_arg.."%s*%)%s*$", ")")
         return all_args, s_arg
+    local _,_,s_arg = string.find(last_arg, "^([^=]+)")
+    last_arg = string.gsub(last_arg, "([%%%(%)])", "%%%1");
+    all_args = string.gsub(all_args, "%s*,%s*"..last_arg.."%s*%)%s*$", ")")
+    return all_args, s_arg
 end
 …
 -- Internal constructor
 function _Function (t)
  setmetatable(t,classFunction)
  if t.const ~= 'const' and t.const ~= '' then
   error("#invalid 'const' specification")
  end
  append(t)
  if t:inclass() then
  --print ('t.name is '..t.name..', parent.name is '..t.parent.name)
   if string.gsub(t.name, "%b<>", "") == string.gsub(t.parent.original_name or t.parent.name, "%b<>", "") then
    t.name = 'new'
    t.lname = 'new'
    t.parent._new = true
    t.type = t.parent.name
    t.ptr = '*'
   elseif string.gsub(t.name, "%b<>", "") == '~'..string.gsub(t.parent.original_name or t.parent.name, "%b<>", "") then
    t.name = 'delete'
    t.lname = 'delete'
    t.parent._delete = true
   end
  end
  t.cname = t:cfuncname("tolua")..t:overload(t)
  return t
+    setmetatable(t,classFunction)
+    if t.const ~= 'const' and t.const ~= '' then
+        error("#invalid 'const' specification")
+    end
+    append(t)
+    if t:inclass() then
+        --print ('t.name is '..t.name..', parent.name is '..t.parent.name)
+        if string.gsub(t.name, "%b<>", "") == string.gsub(t.parent.original_name or t.parent.name, "%b<>", "") then
+            t.name = 'new'
+            t.lname = 'new'
+            t.parent._new = true
+            t.type = t.parent.name
+            t.ptr = '*'
+        elseif string.gsub(t.name, "%b<>", "") == '~'..string.gsub(t.parent.original_name or t.parent.name, "%b<>", "") then
+            t.name = 'delete'
+            t.lname = 'delete'
+            t.parent._delete = true
+        end
+    end
+    t.cname = t:cfuncname("tolua")..t:overload(t)
+    return t
 end
 …
 -- the "const" or empty string.
 function Function (d,a,c)
  --local t = split(strsub(a,2,-2),',') -- eliminate braces
  --local t = split_params(strsub(a,2,-2))
         if not flags['W'] and string.find(a, "%.%.%.%s*%)") then
                 warning("Functions with variable arguments (`...') are not supported. Ignoring "..d..a..c)
                 return nil
         end
  local i=1
  local l = {n=0}
         a = string.gsub(a, "%s*([%(%)])%s*", "%1")
         local t,strip,last = strip_pars(strsub(a,2,-2));
         if strip then
                 --local ns = string.sub(strsub(a,1,-2), 1, -(string.len(last)+1))
                 local ns = join(t, ",", 1, last-1)
                 ns = "("..string.gsub(ns, "%s*,%s*$", "")..')'
                 --ns = strip_defaults(ns)
                 Function(d, ns, c)
                 for i=1,last do
                         t[i] = string.gsub(t[i], "=.*$", "")
                 end
         end
  while t[i] do
   l.n = l.n+1
   l[l.n] = Declaration(t[i],'var',true)
   i = i+1
  end
  local f = Declaration(d,'func')
  f.args = l
  f.const = c
  return _Function(f)
+    --local t = split(strsub(a,2,-2),',') -- eliminate braces
+    --local t = split_params(strsub(a,2,-2))
+    if not flags['W'] and string.find(a, "%.%.%.%s*%)") then
+        warning("Functions with variable arguments (`...') are not supported. Ignoring "..d..a..c)
+        return nil
+    end
+    local i=1
+    local l = {n=0}
+    a = string.gsub(a, "%s*([%(%)])%s*", "%1")
+    local t,strip,last = strip_pars(strsub(a,2,-2));
+    if strip then
+        --local ns = string.sub(strsub(a,1,-2), 1, -(string.len(last)+1))
+        local ns = join(t, ",", 1, last-1)
+        ns = "("..string.gsub(ns, "%s*,%s*$", "")..')'
+        --ns = strip_defaults(ns)
+        Function(d, ns, c)
+        for i=1,last do
+            t[i] = string.gsub(t[i], "=.*$", "")
+        end
+    end
+    while t[i] do
+        l.n = l.n+1
+        l[l.n] = Declaration(t[i],'var',true)
+        i = i+1
+    end
+    local f = Declaration(d,'func')
+    f.args = l
+    f.const = c
+    return _Function(f)
 end
 function join(t, sep, first, last)
         first = first or 1
         last = last or table.getn(t)
         local lsep = ""
         local ret = ""
         local loop = false
         for i = first,last do
                 ret = ret..lsep..t[i]
                 lsep = sep
                 loop = true
         end
         if not loop then
                 return ""
         end
         return ret
+    first = first or 1
+    last = last or table.getn(t)
+    local lsep = ""
+    local ret = ""
+    local loop = false
+    for i = first,last do
+        ret = ret..lsep..t[i]
+        lsep = sep
+        loop = true
+    end
+    if not loop then
+        return ""
+    end
+    return ret
 end
 function strip_pars(s)
         local t = split_c_tokens(s, ',')
         local strip = false
         local last
         for i=t.n,1,-1 do
                 if not strip and param_object(t[i]) then
                         last = i
                         strip = true
                 end
                 --if strip then
                 --      t[i] = string.gsub(t[i], "=.*$", "")
                 --end
         end
         return t,strip,last
+    local t = split_c_tokens(s, ',')
+    local strip = false
+    local last
+    for i=t.n,1,-1 do
+        if not strip and param_object(t[i]) then
+            last = i
+            strip = true
+        end
+        --if strip then
+        --    t[i] = string.gsub(t[i], "=.*$", "")
+        --end
+    end
+    return t,strip,last
 end
 …
 function strip_defaults(s)
         s = string.gsub(s, "^%(", "")
         s = string.gsub(s, "%)$", "")
         local t = split_c_tokens(s, ",")
         local sep, ret = "",""
         for i=1,t.n do
                 t[i] = string.gsub(t[i], "=.*$", "")
                 ret = ret..sep..t[i]
                 sep = ","
         end
         return "("..ret..")"
 end
+    s = string.gsub(s, "^%(", "")
+    s = string.gsub(s, "%)$", "")
+    local t = split_c_tokens(s, ",")
+    local sep, ret = "",""
+    for i=1,t.n do
+        t[i] = string.gsub(t[i], "=.*$", "")
+        ret = ret..sep..t[i]
+        sep = ","
+    end
+    return "("..ret..")"
+end

code/branches/buildsystem2/src/tolua/lua/module.lua

-                      r2087
+                      r2509
 --    {i} = list of objects in the module.
 classModule = {
  classtype = 'module'
+    classtype = 'module'
+}
 classModule.__index = classModule
 …
 -- register module
 function classModule:register (pre)
  pre = pre or ''
  push(self)
  output(pre..'tolua_module(tolua_S,"'..self.name..'",',self:hasvar(),');')
  output(pre..'tolua_beginmodule(tolua_S,"'..self.name..'");')
  local i=1
  while self[i] do
   self[i]:register(pre..' ')
   i = i+1
  end
  output(pre..'tolua_endmodule(tolua_S);')
         pop()
+    pre = pre or ''
+    push(self)
+    output(pre..'tolua_module(tolua_S,"'..self.name..'",',self:hasvar(),');')
+    output(pre..'tolua_beginmodule(tolua_S,"'..self.name..'");')
+    local i=1
+    while self[i] do
+        self[i]:register(pre..' ')
+        i = i+1
+    end
+    output(pre..'tolua_endmodule(tolua_S);')
+    pop()
 end
 -- Print method
 function classModule:print (ident,close)
  print(ident.."Module{")
  print(ident.." name = '"..self.name.."';")
  local i=1
  while self[i] do
   self[i]:print(ident.." ",",")
   i = i+1
  end
  print(ident.."}"..close)
+    print(ident.."Module{")
+    print(ident.." name = '"..self.name.."';")
+    local i=1
+    while self[i] do
+        self[i]:print(ident.." ",",")
+        i = i+1
+    end
+    print(ident.."}"..close)
 end
 -- Internal constructor
 function _Module (t)
  setmetatable(t,classModule)
  append(t)
  return t
+    setmetatable(t,classModule)
+    append(t)
+    return t
 end
 …
 -- Expects two string representing the module name and body.
 function Module (n,b)
  local t = _Module(_Container{name=n})
  push(t)
  t:parse(strsub(b,2,strlen(b)-1)) -- eliminate braces
  pop()
  return t
+    local t = _Module(_Container{name=n})
+    push(t)
+    t:parse(strsub(b,2,strlen(b)-1)) -- eliminate braces
+    pop()
+    return t
 end

code/branches/buildsystem2/src/tolua/lua/namespace.lua

-                      r2087
+                      r2509
 --    {i}  = list of members
 classNamespace = {
  classtype = 'namespace',
  name = '',
+    classtype = 'namespace',
+    name = '',
+}
 classNamespace.__index = classNamespace
 …
 -- Print method
 function classNamespace:print (ident,close)
  print(ident.."Namespace{")
  print(ident.." name = '"..self.name.."',")
  local i=1
  while self[i] do
   self[i]:print(ident.." ",",")
   i = i+1
  end
  print(ident.."}"..close)
+    print(ident.."Namespace{")
+    print(ident.." name = '"..self.name.."',")
+    local i=1
+    while self[i] do
+        self[i]:print(ident.." ",",")
+        i = i+1
+    end
+    print(ident.."}"..close)
 end
 -- Internal constructor
 function _Namespace (t)
  setmetatable(t,classNamespace)
  append(t)
  return t
+    setmetatable(t,classNamespace)
+    append(t)
+    return t
 end
 …
 -- Expects the name and the body of the namespace.
 function Namespace (n,b)
  local c = _Namespace(_Container{name=n})
  push(c)
  c:parse(strsub(b,2,strlen(b)-1)) -- eliminate braces
  pop()
+    local c = _Namespace(_Container{name=n})
+    push(c)
+    c:parse(strsub(b,2,strlen(b)-1)) -- eliminate braces
+    pop()
 end

code/branches/buildsystem2/src/tolua/lua/operator.lua

-                      r2087
+                      r2509
 --  kind = set of character representing the operator (as it appers in C++ code)
 classOperator = {
  kind = '',
+    kind = '',
+}
 classOperator.__index = classOperator
 …
 -- table to transform operator kind into the appropriate tag method name
+_TM = {['+'] = 'add',
+       ['-'] = 'sub',
+       ['*'] = 'mul',
+       ['/'] = 'div',
+       ['<'] = 'lt',
+       ['<='] = 'le',
+       ['=='] = 'eq',
+       ['[]'] = 'geti',
+       ['&[]'] = 'seti',
+       --['->'] = 'flechita',
+      }
+_TM = {
+    ['+'] = 'add',
+    ['-'] = 'sub',
+    ['*'] = 'mul',
+    ['/'] = 'div',
+    ['<'] = 'lt',
+    ['<='] = 'le',
+    ['=='] = 'eq',
+    ['[]'] = 'geti',
+    ['&[]'] = 'seti',
+    --['->'] = 'flechita',
+}
 -- Print method
 function classOperator:print (ident,close)
  print(ident.."Operator{")
  print(ident.." kind  = '"..self.kind.."',")
  print(ident.." mod  = '"..self.mod.."',")
  print(ident.." type = '"..self.type.."',")
  print(ident.." ptr  = '"..self.ptr.."',")
  print(ident.." name = '"..self.name.."',")
  print(ident.." const = '"..self.const.."',")
  print(ident.." cname = '"..self.cname.."',")
  print(ident.." lname = '"..self.lname.."',")
  print(ident.." args = {")
  local i=1
  while self.args[i] do
   self.args[i]:print(ident.."  ",",")
   i = i+1
  end
  print(ident.." }")
  print(ident.."}"..close)
+    print(ident.."Operator{")
+    print(ident.." kind  = '"..self.kind.."',")
+    print(ident.." mod  = '"..self.mod.."',")
+    print(ident.." type = '"..self.type.."',")
+    print(ident.." ptr  = '"..self.ptr.."',")
+    print(ident.." name = '"..self.name.."',")
+    print(ident.." const = '"..self.const.."',")
+    print(ident.." cname = '"..self.cname.."',")
+    print(ident.." lname = '"..self.lname.."',")
+    print(ident.." args = {")
+    local i=1
+    while self.args[i] do
+        self.args[i]:print(ident.."  ",",")
+        i = i+1
+    end
+    print(ident.." }")
+    print(ident.."}"..close)
 end
 function classOperator:supcode_tmp()
         if not _TM[self.kind] then
                 return classFunction.supcode(self)
         end
         -- no overload, no parameters, always inclass
         output("/* method:",self.name," of class ",self:inclass()," */")
         output("#ifndef TOLUA_DISABLE_"..self.cname)
         output("\nstatic int",self.cname,"(lua_State* tolua_S)")
         if overload < 0 then
          output('#ifndef TOLUA_RELEASE\n')
         end
         output(' tolua_Error tolua_err;')
         output(' if (\n')
         -- check self
         output('     !'..'tolua_isusertype(tolua_S,1,"'..self.parent.type..'",0,&tolua_err) ||\n')
         output('     !tolua_isnoobj(tolua_S,2,&tolua_err)\n )')
         output('  goto tolua_lerror;')
         output(' else\n')
         output('#endif\n') -- tolua_release
         output(' {')
         -- declare self
         output(' ',self.const,self.parent.type,'*','self = ')
         output('(',self.const,self.parent.type,'*) ')
         output('tolua_tousertype(tolua_S,1,0);')
         -- check self
         output('#ifndef TOLUA_RELEASE\n')
         output('  if (!self) tolua_error(tolua_S,"invalid \'self\' in function \''..self.name..'\'",NULL);');
         output('#endif\n')
         -- cast self
         output('  ',self.mod,self.type,self.ptr,'tolua_ret = ')
         output('(',self.mod,self.type,self.ptr,')(*self);')
         -- return value
         local t,ct = isbasic(self.type)
         if t then
                 output('   tolua_push'..t..'(tolua_S,(',ct,')tolua_ret);')
         else
                 t = self.type
                 new_t = string.gsub(t, "const%s+", "")
                 if self.ptr == '' then
                         output('   {')
                         output('#ifdef __cplusplus\n')
                         output('    void* tolua_obj = new',new_t,'(tolua_ret);')
                         output('    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"',t,'");')
                         output('#else\n')
                         output('    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(',t,'));')
                         output('    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"',t,'");')
                         output('#endif\n')
                         output('   }')
                 elseif self.ptr == '&' then
                         output('   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"',t,'");')
                 else
                         if local_constructor then
                                 output('   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"',t,'");')
                         else
                                 output('   tolua_pushusertype(tolua_S,(void*)tolua_ret,"',t,'");')
                         end
                 end
         end
         output('  }')
         output(' return 1;')
         output('#ifndef TOLUA_RELEASE\n')
         output('tolua_lerror:\n')
         output(' tolua_error(tolua_S,"#ferror in function \''..self.lname..'\'.",&tolua_err);')
         output(' return 0;')
         output('#endif\n')
         output('}')
         output('#endif //#ifndef TOLUA_DISABLE\n')
         output('\n')
+    if not _TM[self.kind] then
+        return classFunction.supcode(self)
+    end
+    -- no overload, no parameters, always inclass
+    output("/* method:",self.name," of class ",self:inclass()," */")
+    output("#ifndef TOLUA_DISABLE_"..self.cname)
+    output("\nstatic int",self.cname,"(lua_State* tolua_S)")
+    if overload < 0 then
+        output('#ifndef TOLUA_RELEASE\n')
+    end
+    output(' tolua_Error tolua_err;')
+    output(' if (\n')
+    -- check self
+    output('     !'..'tolua_isusertype(tolua_S,1,"'..self.parent.type..'",0,&tolua_err) ||\n')
+    output('     !tolua_isnoobj(tolua_S,2,&tolua_err)\n )')
+    output('  goto tolua_lerror;')
+    output(' else\n')
+    output('#endif\n') -- tolua_release
+    output(' {')
+    -- declare self
+    output(' ',self.const,self.parent.type,'*','self = ')
+    output('(',self.const,self.parent.type,'*) ')
+    output('tolua_tousertype(tolua_S,1,0);')
+    -- check self
+    output('#ifndef TOLUA_RELEASE\n')
+    output('  if (!self) tolua_error(tolua_S,"invalid \'self\' in function \''..self.name..'\'",NULL);');
+    output('#endif\n')
+    -- cast self
+    output('  ',self.mod,self.type,self.ptr,'tolua_ret = ')
+    output('(',self.mod,self.type,self.ptr,')(*self);')
+    -- return value
+    local t,ct = isbasic(self.type)
+    if t then
+        output('   tolua_push'..t..'(tolua_S,(',ct,')tolua_ret);')
+    else
+        t = self.type
+        new_t = string.gsub(t, "const%s+", "")
+        if self.ptr == '' then
+            output('   {')
+            output('#ifdef __cplusplus\n')
+            output('    void* tolua_obj = new',new_t,'(tolua_ret);')
+            output('    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"',t,'");')
+            output('#else\n')
+            output('    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(',t,'));')
+            output('    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"',t,'");')
+            output('#endif\n')
+            output('   }')
+        elseif self.ptr == '&' then
+            output('   tolua_pushusertype(tolua_S,(void*)&tolua_ret,"',t,'");')
+        else
+            if local_constructor then
+                output('   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"',t,'");')
+            else
+                output('   tolua_pushusertype(tolua_S,(void*)tolua_ret,"',t,'");')
+            end
+        end
+    end
+    output('  }')
+    output(' return 1;')
+    output('#ifndef TOLUA_RELEASE\n')
+    output('tolua_lerror:\n')
+    output(' tolua_error(tolua_S,"#ferror in function \''..self.lname..'\'.",&tolua_err);')
+    output(' return 0;')
+    output('#endif\n')
+    output('}')
+    output('#endif //#ifndef TOLUA_DISABLE\n')
+    output('\n')
 end
 -- Internal constructor
 function _Operator (t)
  setmetatable(t,classOperator)
  if t.const ~= 'const' and t.const ~= '' then
   error("#invalid 'const' specification")
  end
  append(t)
  if not t:inclass() then
   error("#operator can only be defined as class member")
  end
  --t.name = t.name .. "_" .. (_TM[t.kind] or t.kind)
  t.cname = t:cfuncname("tolua")..t:overload(t)
  t.name = "operator" .. t.kind  -- set appropriate calling name
  return t
+    setmetatable(t,classOperator)
+    if t.const ~= 'const' and t.const ~= '' then
+        error("#invalid 'const' specification")
+    end
+    append(t)
+    if not t:inclass() then
+        error("#operator can only be defined as class member")
+    end
+    --t.name = t.name .. "_" .. (_TM[t.kind] or t.kind)
+    t.cname = t:cfuncname("tolua")..t:overload(t)
+    t.name = "operator" .. t.kind  -- set appropriate calling name
+    return t
 end
 …
 function Operator (d,k,a,c)
         local op_k = string.gsub(k, "^%s*", "")
         op_k = string.gsub(k, "%s*$", "")
         --if string.find(k, "^[%w_:%d<>%*%&]+$") then
         if d == "operator" and k ~= '' then
                 d = k.." operator"
         elseif not _TM[op_k] then
                 if flags['W'] then
                         error("tolua: no support for operator" .. f.kind)
                 else
                         warning("No support for operator "..op_k..", ignoring")
                         return nil
                 end
         end
         local ref = ''
  local t = split_c_tokens(strsub(a,2,strlen(a)-1),',') -- eliminate braces
  local i=1
  local l = {n=0}
  while t[i] do
   l.n = l.n+1
   l[l.n] = Declaration(t[i],'var')
   i = i+1
  end
  if k == '[]' then
          local _
          _, _, ref = strfind(d,'(&)')
   d = gsub(d,'&','')
  elseif k=='&[]' then
   l.n = l.n+1
   l[l.n] = Declaration(d,'var')
   l[l.n].name = 'tolua_value'
  end
  local f = Declaration(d,'func')
  if k == '[]' and (l[1]==nil or isbasic(l[1].type)~='number') then
   error('operator[] can only be defined for numeric index.')
  end
  f.args = l
  f.const = c
  f.kind = op_k
  f.lname = "."..(_TM[f.kind] or f.kind)
  if not _TM[f.kind] then
         f.cast_operator = true
  end
  if f.kind == '[]' and ref=='&' and f.const~='const' then
   Operator(d,'&'..k,a,c)        -- create correspoding set operator
  end
  return _Operator(f)
 end
+    local op_k = string.gsub(k, "^%s*", "")
+    op_k = string.gsub(k, "%s*$", "")
+    --if string.find(k, "^[%w_:%d<>%*%&]+$") then
+    if d == "operator" and k ~= '' then
+        d = k.." operator"
+    elseif not _TM[op_k] then
+        if flags['W'] then
+            error("tolua: no support for operator" .. f.kind)
+        else
+            warning("No support for operator "..op_k..", ignoring")
+            return nil
+        end
+    end
+    local ref = ''
+    local t = split_c_tokens(strsub(a,2,strlen(a)-1),',') -- eliminate braces
+    local i=1
+    local l = {n=0}
+    while t[i] do
+        l.n = l.n+1
+        l[l.n] = Declaration(t[i],'var')
+        i = i+1
+    end
+    if k == '[]' then
+        local _
+        _, _, ref = strfind(d,'(&)')
+        d = gsub(d,'&','')
+    elseif k=='&[]' then
+        l.n = l.n+1
+        l[l.n] = Declaration(d,'var')
+        l[l.n].name = 'tolua_value'
+    end
+    local f = Declaration(d,'func')
+    if k == '[]' and (l[1]==nil or isbasic(l[1].type)~='number') then
+        error('operator[] can only be defined for numeric index.')
+    end
+    f.args = l
+    f.const = c
+    f.kind = op_k
+    f.lname = "."..(_TM[f.kind] or f.kind)
+    if not _TM[f.kind] then
+        f.cast_operator = true
+    end
+    if f.kind == '[]' and ref=='&' and f.const~='const' then
+        Operator(d,'&'..k,a,c)     -- create correspoding set operator
+    end
+    return _Operator(f)
+end

code/branches/buildsystem2/src/tolua/lua/package.lua

-                      r2087
+                      r2509
 --    {i} = list of objects in the package.
 classPackage = {
  classtype = 'package'
+    classtype = 'package'
+}
 classPackage.__index = classPackage
 …
 -- Print method
 function classPackage:print ()
  print("Package: "..self.name)
  local i=1
  while self[i] do
   self[i]:print("","")
   i = i+1
  end
+    print("Package: "..self.name)
+    local i=1
+    while self[i] do
+        self[i]:print("","")
+        i = i+1
+    end
 end
 function classPackage:preprocess ()
  -- avoid preprocessing embedded Lua code
  local L = {}
  self.code = gsub(self.code,"\n%s*%$%[","\1") -- deal with embedded lua code
  self.code = gsub(self.code,"\n%s*%$%]","\2")
  self.code = gsub(self.code,"(%b\1\2)",       function (c)
+    -- avoid preprocessing embedded Lua code
+    local L = {}
+    self.code = gsub(self.code,"\n%s*%$%[","\1") -- deal with embedded lua code
+    self.code = gsub(self.code,"\n%s*%$%]","\2")
+    self.code = gsub(self.code,"(%b\1\2)", function (c)
                                                tinsert(L,c)
                                                return "\n#["..getn(L).."]#"
+                                              end)
+ -- avoid preprocessing embedded C code
+ local C = {}
+ self.code = gsub(self.code,"\n%s*%$%<","\3") -- deal with embedded C code
+ self.code = gsub(self.code,"\n%s*%$%>","\4")
+ self.code = gsub(self.code,"(%b\3\4)",       function (c)
+                                           end
+    )
+    -- avoid preprocessing embedded C code
+    local C = {}
+    self.code = gsub(self.code,"\n%s*%$%<","\3") -- deal with embedded C code
+    self.code = gsub(self.code,"\n%s*%$%>","\4")
+    self.code = gsub(self.code,"(%b\3\4)", function (c)
                                                tinsert(C,c)
                                                return "\n#<"..getn(C)..">#"
+                                              end)
+ -- avoid preprocessing embedded C code
+ self.code = gsub(self.code,"\n%s*%$%{","\5") -- deal with embedded C code
+ self.code = gsub(self.code,"\n%s*%$%}","\6")
+ self.code = gsub(self.code,"(%b\5\6)",       function (c)
+                                           end
+    )
+    -- avoid preprocessing embedded C code
+    self.code = gsub(self.code,"\n%s*%$%{","\5") -- deal with embedded C code
+    self.code = gsub(self.code,"\n%s*%$%}","\6")
+    self.code = gsub(self.code,"(%b\5\6)", function (c)
                                                tinsert(C,c)
                                                return "\n#<"..getn(C)..">#"
+                                              end)
+ --self.code = gsub(self.code,"\n%s*#[^d][^\n]*\n", "\n\n") -- eliminate preprocessor directives that don't start with 'd'
+ self.code = gsub(self.code,"\n[ \t]*#[ \t]*[^d%<%[]", "\n//") -- eliminate preprocessor directives that don't start with 'd'
+ -- avoid preprocessing verbatim lines
+ local V = {}
+ self.code = gsub(self.code,"\n(%s*%$[^%[%]][^\n]*)",function (v)
+                                               tinsert(V,v)
+                                               return "\n#"..getn(V).."#"
+                                              end)
+ -- perform global substitution
+ self.code = gsub(self.code,"(//[^\n]*)","")     -- eliminate C++ comments
+ self.code = gsub(self.code,"/%*","\1")
+ self.code = gsub(self.code,"%*/","\2")
+ self.code = gsub(self.code,"%b\1\2","")
+ self.code = gsub(self.code,"\1","/%*")
+ self.code = gsub(self.code,"\2","%*/")
+ self.code = gsub(self.code,"%s*@%s*","@") -- eliminate spaces beside @
+ self.code = gsub(self.code,"%s?inline(%s)","%1") -- eliminate 'inline' keyword
+ --self.code = gsub(self.code,"%s?extern(%s)","%1") -- eliminate 'extern' keyword
+ --self.code = gsub(self.code,"%s?virtual(%s)","%1") -- eliminate 'virtual' keyword
+ --self.code = gsub(self.code,"public:","") -- eliminate 'public:' keyword
+ self.code = gsub(self.code,"([^%w_])void%s*%*","%1_userdata ") -- substitute 'void*'
+ self.code = gsub(self.code,"([^%w_])void%s*%*","%1_userdata ") -- substitute 'void*'
+ self.code = gsub(self.code,"([^%w_])char%s*%*","%1_cstring ")  -- substitute 'char*'
+ self.code = gsub(self.code,"([^%w_])lua_State%s*%*","%1_lstate ")  -- substitute 'lua_State*'
+ -- restore embedded Lua code
+ self.code = gsub(self.code,"%#%[(%d+)%]%#",function (n)
+                                              return L[tonumber(n)]
+                                            end)
+ -- restore embedded C code
+ self.code = gsub(self.code,"%#%<(%d+)%>%#",function (n)
+                                             return C[tonumber(n)]
+                                            end)
+ -- restore verbatim lines
+ self.code = gsub(self.code,"%#(%d+)%#",function (n)
+                                         return V[tonumber(n)]
+                                        end)
+ self.code = string.gsub(self.code, "\n%s*%$([^\n]+)", function (l)
+                                                                                        Verbatim(l.."\n")
+                                                                                        return "\n"
+                                                                                  end)
+                                           end
+    )
+    --self.code = gsub(self.code,"\n%s*#[^d][^\n]*\n", "\n\n") -- eliminate preprocessor directives that don't start with 'd'
+    self.code = gsub(self.code,"\n[ \t]*#[ \t]*[^d%<%[]", "\n//") -- eliminate preprocessor directives that don't start with 'd'
+    -- avoid preprocessing verbatim lines
+    local V = {}
+    self.code = gsub(self.code,"\n(%s*%$[^%[%]][^\n]*)", function (v)
+                                                             tinsert(V,v)
+                                                             return "\n#"..getn(V).."#"
+                                                         end
+    )
+    -- perform global substitution
+    self.code = gsub(self.code,"(//[^\n]*)","")     -- eliminate C++ comments
+    self.code = gsub(self.code,"/%*","\1")
+    self.code = gsub(self.code,"%*/","\2")
+    self.code = gsub(self.code,"%b\1\2","")
+    self.code = gsub(self.code,"\1","/%*")
+    self.code = gsub(self.code,"\2","%*/")
+    self.code = gsub(self.code,"%s*@%s*","@") -- eliminate spaces beside @
+    self.code = gsub(self.code,"%s?inline(%s)","%1") -- eliminate 'inline' keyword
+    --self.code = gsub(self.code,"%s?extern(%s)","%1") -- eliminate 'extern' keyword
+    --self.code = gsub(self.code,"%s?virtual(%s)","%1") -- eliminate 'virtual' keyword
+    --self.code = gsub(self.code,"public:","") -- eliminate 'public:' keyword
+    self.code = gsub(self.code,"([^%w_])void%s*%*","%1_userdata ") -- substitute 'void*'
+    self.code = gsub(self.code,"([^%w_])void%s*%*","%1_userdata ") -- substitute 'void*'
+    self.code = gsub(self.code,"([^%w_])char%s*%*","%1_cstring ")  -- substitute 'char*'
+    self.code = gsub(self.code,"([^%w_])lua_State%s*%*","%1_lstate ")  -- substitute 'lua_State*'
+    -- restore embedded Lua code
+    self.code = gsub(self.code,"%#%[(%d+)%]%#", function (n)
+                                                    return L[tonumber(n)]
+                                                end
+    )
+    -- restore embedded C code
+    self.code = gsub(self.code,"%#%<(%d+)%>%#", function (n)
+                                                    return C[tonumber(n)]
+                                                end
+    )
+    -- restore verbatim lines
+    self.code = gsub(self.code,"%#(%d+)%#", function (n)
+                                                return V[tonumber(n)]
+                                            end
+    )
+    self.code = string.gsub(self.code, "\n%s*%$([^\n]+)", function (l)
+                                                              Verbatim(l.."\n")
+                                                              return "\n"
+                                                          end
+    )
 end
 -- translate verbatim
 function classPackage:preamble ()
+ output('/*\n')
+ output('** Lua binding: '..self.name..'\n')
+ output('** Generated automatically by '..TOLUA_VERSION..' on '..date()..'.\n')
+ output('*/\n\n')
+        output('#ifndef __cplusplus\n')
+        output('#include "stdlib.h"\n')
+        output('#endif\n')
+        output('#include "string.h"\n\n')
+ output('#include "tolua/tolua++.h"\n\n')
+ if not flags.h then
+--  local temp = string.reverse(flags.H)
+--  local start1, end1 = string.find(temp, '/')
+--  local start2, end2 = string.find(temp, '\\')
+--  local res
+--  if not start1 == nil then
+--   if not start2 == nil then
+--    if start1 > start2 then
+--     res = string.sub(temp, 1, start2)
+--    else
+--     res = string.sub(temp, 1, start1)
+--    end
+--   else
+--    res = string.sub(temp, 1, start1)
+--   end
+--  elseif not start2 == nil then
+--   res = string.sub(temp, 1, start2)
+--  end
+--  res = string.reverse(res)
+  output('#include "tolua_bind.h"')
+  output('\n')
+ end
+ local i=1
+ while self[i] do
+  self[i]:preamble()
+  i = i+1
+ end
+        if self:requirecollection(_collect) then
+                output('\n')
+                output('/* function to release collected object via destructor */')
+                output('#ifdef __cplusplus\n')
+                for i,v in pairs(_collect) do
+                 output('\nstatic int '..v..' (lua_State* tolua_S)')
+                        output('{')
+                        output(' '..i..'* self = ('..i..'*) tolua_tousertype(tolua_S,1,0);')
+                        output('        delete self;')
+                        output('        return 0;')
+                        output('}')
+                end
+                output('#endif\n\n')
+        end
+ output('\n')
+ output('/* function to register type */')
+ output('static void tolua_reg_types (lua_State* tolua_S)')
+ output('{')
+ foreach(_usertype,function(n,v) output(' tolua_usertype(tolua_S,"',v,'");') end)
+        if flags.t then
+                output("#ifndef Mtolua_typeid\n#define Mtolua_typeid(L,TI,T)\n#endif\n")
+                foreach(_usertype,function(n,v) output(' Mtolua_typeid(tolua_S,typeid(',v,'), "',v,'");') end)
+        end
+ output('}')
+ output('\n')
+    output('/*\n')
+    output('** Lua binding: '..self.name..'\n')
+    output('** Generated automatically by '..TOLUA_VERSION..' on '..date()..'.\n')
+    output('*/\n\n')
+    output('#ifndef __cplusplus\n')
+    output('#include "stdlib.h"\n')
+    output('#endif\n')
+    output('#include "string.h"\n\n')
+    output('#include "tolua++.h"\n\n')
+    if flags.H then
+        local header = gsub(flags.H, '^.-([%w_]*%.[%w_]*)$', '%1')
+        local package_lower = string.lower(self.name)
+        output('#include "'..package_lower..'/'..header..'"\n')
+    end
+    local i=1
+    while self[i] do
+        self[i]:preamble()
+        i = i+1
+    end
+    if self:requirecollection(_collect) then
+        output('\n')
+        output('/* function to release collected object via destructor */')
+        output('#ifdef __cplusplus\n')
+        for i,v in pairs(_collect) do
+            output('\nstatic int '..v..' (lua_State* tolua_S)')
+            output('{')
+            output(' '..i..'* self = ('..i..'*) tolua_tousertype(tolua_S,1,0);')
+            output('    delete self;')
+            output('    return 0;')
+            output('}')
+        end
+        output('#endif\n\n')
+    end
+    output('\n')
+    output('/* function to register type */')
+    output('static void tolua_reg_types (lua_State* tolua_S)')
+    output('{')
+    foreach(_usertype,function(n,v) output(' tolua_usertype(tolua_S,"',v,'");') end)
+    if flags.t then
+        output("#ifndef Mtolua_typeid\n#define Mtolua_typeid(L,TI,T)\n#endif\n")
+        foreach(_usertype,function(n,v) output(' Mtolua_typeid(tolua_S,typeid(',v,'), "',v,'");') end)
+    end
+    output('}')
+    output('\n')
 end
 …
 -- write package open function
 function classPackage:register (pre)
  pre = pre or ''
  push(self)
  output(pre.."/* Open function */")
  output(pre.."int tolua_"..self.name.."_open (lua_State* tolua_S)")
  output(pre.."{")
  output(pre.." tolua_open(tolua_S);")
  output(pre.." tolua_reg_types(tolua_S);")
  output(pre.." tolua_module(tolua_S,NULL,",self:hasvar(),");")
  output(pre.." tolua_beginmodule(tolua_S,NULL);")
  local i=1
  while self[i] do
   self[i]:register(pre.."  ")
   i = i+1
  end
  output(pre.." tolua_endmodule(tolua_S);")
  output(pre.." return 1;")
  output(pre.."}")
  output("\n\n")
  output("#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501\n");
  output(pre.."int luaopen_"..self.name.." (lua_State* tolua_S) {")
  output(pre.." return tolua_"..self.name.."_open(tolua_S);")
  output(pre.."};")
  output("#endif\n\n")
         pop()
+    pre = pre or ''
+    push(self)
+    output(pre.."/* Open function */")
+    output(pre.."int tolua_"..self.name.."_open (lua_State* tolua_S)")
+    output(pre.."{")
+    output(pre.." tolua_open(tolua_S);")
+    output(pre.." tolua_reg_types(tolua_S);")
+    output(pre.." tolua_module(tolua_S,NULL,",self:hasvar(),");")
+    output(pre.." tolua_beginmodule(tolua_S,NULL);")
+    local i=1
+    while self[i] do
+        self[i]:register(pre.."  ")
+        i = i+1
+    end
+    output(pre.." tolua_endmodule(tolua_S);")
+    output(pre.." return 1;")
+    output(pre.."}")
+    output("\n\n")
+    output("#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501\n");
+    output(pre.."int luaopen_"..self.name.." (lua_State* tolua_S) {")
+    output(pre.." return tolua_"..self.name.."_open(tolua_S);")
+    output(pre.."};")
+    output("#endif\n\n")
+    pop()
 end
 -- write header file
 function classPackage:header ()
+ output('/*\n') output('** Lua binding: '..self.name..'\n')
+ output('** Generated automatically by '..TOLUA_VERSION..' on '..date()..'.\n')
+ output('*/\n\n')
+ if not flags.h then
+  output('#include "../'..self.name..'Prereqs.h"\n')
+  output('/* Exported function */')
+  output('_'..self.name..'Export int  tolua_'..self.name..'_open (lua_State* tolua_S);')
+  output('\n')
+ end
+    output('/*\n') output('** Lua binding: '..self.name..'\n')
+    output('** Generated automatically by '..TOLUA_VERSION..' on '..date()..'.\n')
+    output('*/\n\n')
+    if flags.H then
+        local package_lower = string.lower(self.name)
+        output('#include "'..package_lower..'/'..self.name..'Prereqs.h"\n')
+        output('/* Exported function */')
+        output('_'..self.name..'Export')
+        output('int  tolua_'..self.name..'_open (lua_State* tolua_S);')
+        output('\n')
+    end
 end
 -- Internal constructor
 function _Package (self)
  setmetatable(self,classPackage)
  return self
+    setmetatable(self,classPackage)
+    return self
 end
 …
 -- *** Thanks to Ariel Manzur for fixing bugs in nested directives ***
 function extract_code(fn,s)
+        local code = '\n$#include "'..fn..'"\n'
+        s= "\n" .. s .. "\n" -- add blank lines as sentinels
+        local _,e,c,t = strfind(s, "\n([^\n]-)[Tt][Oo][Ll][Uu][Aa]_([^%s]*)[^\n]*\n")
+        while e do
+                t = strlower(t)
+                if t == "begin" then
+                        _,e,c = strfind(s,"(.-)\n[^\n]*[Tt][Oo][Ll][Uu][Aa]_[Ee][Nn][Dd][^\n]*\n",e)
+                        if not e then
+                         tolua_error("Unbalanced 'tolua_begin' directive in header file")
+                        end
+                end
+                code = code .. c .. "\n"
+         _,e,c,t = strfind(s, "\n([^\n]-)[Tt][Oo][Ll][Uu][Aa]_([^%s]*)[^\n]*\n",e)
+        end
+        return code
+    local code = '\n$#include "'..string.lower(flags.n)..'/'..fn..'"\n'
+    s= "\n" .. s .. "\n" -- add blank lines as sentinels
+    -- eliminate export macro problems in class declarations
+    s = gsub(s, ' _%w*Export ', ' ')
+    local _,e,c,t = strfind(s, "\n([^\n]-)[Tt][Oo][Ll][Uu][Aa]_([^%s]*)[^\n]*\n")
+    while e do
+        t = strlower(t)
+        if t == "begin" then
+            _,e,c = strfind(s,"(.-)\n[^\n]*[Tt][Oo][Ll][Uu][Aa]_[Ee][Nn][Dd][^\n]*\n",e)
+            if not e then
+             tolua_error("Unbalanced 'tolua_begin' directive in header file")
+            end
+        end
+        code = code .. c .. "\n"
+        _,e,c,t = strfind(s, "\n([^\n]-)[Tt][Oo][Ll][Uu][Aa]_([^%s]*)[^\n]*\n",e)
+    end
+    return code
 end
 …
 -- Expects the package name, the file extension, and the file text.
 function Package (name,fn)
+ local ext = "pkg"
+ -- open input file, if any
+ if fn then
+  local st, msg = readfrom(flags.f)
+  if not st then
+   error('#'..msg)
+  end
+                local _; _, _, ext = strfind(fn,".*%.(.*)$")
+ end
+ local code = "\n" .. read('*a')
+        if ext == 'h' or ext == 'hpp' then
+         code = extract_code(fn,code)
+        end
+ -- close file
+ if fn then
+  readfrom()
+ end
+ -- deal with include directive
+ local nsubst
+ repeat
+  code,nsubst = gsub(code,'\n%s*%$(.)file%s*"(.-)"([^\n]*)\n',
+                function (kind,fn,extra)
+                        local _, _, ext = strfind(fn,".*%.(.*)$")
+                        local fp,msg = openfile(fn,'r')
+                        if not fp then
+                                error('#'..msg..': '..fn)
+                        end
+                        local s = read(fp,'*a')
+                        closefile(fp)
+                        if kind == 'c' or kind == 'h' then
+                                return extract_code(fn,s)
+                        elseif kind == 'p' then
+                                return "\n\n" .. s
+                        elseif kind == 'l' then
+                                return "\n$[--##"..fn.."\n" .. s .. "\n$]\n"
+                        elseif kind == 'i' then
+                                local t = {code=s}
+                                extra = string.gsub(extra, "^%s*,%s*", "")
+                                local pars = split_c_tokens(extra, ",")
+                                include_file_hook(t, fn, unpack(pars))
+                                return "\n\n" .. t.code
+                        else
+                                error('#Invalid include directive (use $cfile, $pfile, $lfile or $ifile)')
+                        end
+                end)
+ until nsubst==0
+ -- deal with renaming directive
+ repeat -- I don't know why this is necesary
+        code,nsubst = gsub(code,'\n%s*%$renaming%s*(.-)%s*\n', function (r) appendrenaming(r) return "\n" end)
+ until nsubst == 0
+ local t = _Package(_Container{name=name, code=code})
+ push(t)
+ preprocess_hook(t)
+ t:preprocess()
+ preparse_hook(t)
+ t:parse(t.code)
+ pop()
+ return t
+end
+    local ext = "pkg"
+    -- open input file, if any
+    if fn then
+        local file
+        if flags.f then
+            if string.sub(flags.f, 1, 1) == '/' or string.sub(flags.f, 1, 1) == '\\' then
+                file = flags.f
+            else
+                file = flags.w..'/'..flags.f
+            end
+        else
+            file = flags.f
+        end
+        local st, msg = readfrom(file)
+        if not st then
+            error('#'..msg..' path: '..flags.f)
+        end
+        local _; _, _, ext = strfind(fn,".*%.(.*)$")
+    end
+    local code = "\n" .. read('*a')
+    if ext == 'h' or ext == 'hpp' then
+        code = extract_code(fn,code)
+    end
+    -- close file
+    if fn then
+        readfrom()
+    end
+    -- prepare working directory
+    local current_path
+    if not flags.w and flags.f then
+        current_path = gsub(flags.f, '(/)[^/]*%.?[^/]*$', '%1')
+    elseif flags.w then
+        if not (string.sub(flags.w, string.len(flags.w)) == '/') then
+            current_path = flags.w..'/'
+        else
+            current_path = flags.w
+        end
+    else
+        current_path = ''
+    end
+    -- deal with include directive
+    local nsubst
+    repeat
+        code,nsubst = gsub(code,'\n%s*%$(.)file%s*"(.-)"([^\n]*)\n',
+            function (kind,fn,extra)
+                local _, _, ext = strfind(fn,".*%.(.*)$")
+                local fp,msg = openfile(current_path..fn,'r')
+                if not fp then
+                    error('#'..msg..': '..fn)
+                end
+                local s = read(fp,'*a')
+                closefile(fp)
+                if kind == 'c' or kind == 'h' then
+                    return extract_code(fn,s)
+                elseif kind == 'p' then
+                    return "\n\n" .. s
+                elseif kind == 'l' then
+                    return "\n$[--##"..fn.."\n" .. s .. "\n$]\n"
+                elseif kind == 'i' then
+                    local t = {code=s}
+                    extra = string.gsub(extra, "^%s*,%s*", "")
+                    local pars = split_c_tokens(extra, ",")
+                    include_file_hook(t, fn, unpack(pars))
+                    return "\n\n" .. t.code
+                else
+                    error('#Invalid include directive (use $cfile, $pfile, $lfile or $ifile)')
+                end
+            end
+        )
+    until nsubst==0
+    -- deal with renaming directive
+    repeat -- I don't know why this is necesary
+        code,nsubst = gsub(code,'\n%s*%$renaming%s*(.-)%s*\n', function (r) appendrenaming(r) return "\n" end)
+    until nsubst == 0
+    local t = _Package(_Container{name=name, code=code})
+    push(t)
+    preprocess_hook(t)
+    t:preprocess()
+    preparse_hook(t)
+    t:parse(t.code)
+    pop()
+    return t
+end

code/branches/buildsystem2/src/tolua/lua/typedef.lua

-                      r2087
+                      r2509
 --   mod = modifiers to the 'de facto' type
 classTypedef = {
  utype = '',
  mod = '',
  type = ''
+    utype = '',
+    mod = '',
+    type = ''
+}
 classTypedef.__index = classTypedef
 …
 -- Print method
 function classTypedef:print (ident,close)
  print(ident.."Typedef{")
  print(ident.." utype = '"..self.utype.."',")
  print(ident.." mod = '"..self.mod.."',")
  print(ident.." type = '"..self.type.."',")
  print(ident.."}"..close)
+    print(ident.."Typedef{")
+    print(ident.." utype = '"..self.utype.."',")
+    print(ident.." mod = '"..self.mod.."',")
+    print(ident.." type = '"..self.type.."',")
+    print(ident.."}"..close)
 end
 -- Return it's not a variable
 function classTypedef:isvariable ()
  return false
+    return false
 end
 -- Internal constructor
 function _Typedef (t)
  setmetatable(t,classTypedef)
  t.type = resolve_template_types(t.type)
  appendtypedef(t)
  return t
+    setmetatable(t,classTypedef)
+    t.type = resolve_template_types(t.type)
+    appendtypedef(t)
+    return t
 end
 …
 -- Expects one string representing the type definition.
 function Typedef (s)
  if strfind(string.gsub(s, '%b<>', ''),'[%*&]') then
   tolua_error("#invalid typedef: pointers (and references) are not supported")
  end
  local o = {mod = ''}
  if string.find(s, "[<>]") then
         _,_,o.type,o.utype = string.find(s, "^%s*([^<>]+%b<>[^%s]*)%s+(.-)$")
  else
         local t = split(gsub(s,"%s%s*"," ")," ")
         o = {
           utype = t[t.n],
           type = t[t.n-1],
           mod = concat(t,1,t.n-2),
+         }
  end
  return _Typedef(o)
+    if strfind(string.gsub(s, '%b<>', ''),'[%*&]') then
+        tolua_error("#invalid typedef: pointers (and references) are not supported")
+    end
+    local o = {mod = ''}
+    if string.find(s, "[<>]") then
+        _,_,o.type,o.utype = string.find(s, "^%s*([^<>]+%b<>[^%s]*)%s+(.-)$")
+    else
+        local t = split(gsub(s,"%s%s*"," ")," ")
+        o = {
+            utype = t[t.n],
+            type = t[t.n-1],
+            mod = concat(t,1,t.n-2),
+        }
+    end
+    return _Typedef(o)
 end

code/branches/buildsystem2/src/tolua/lua/variable.lua

-                      r2087
+                      r2509
 -- Stores all fields present in a declaration.
 classVariable = {
  _get = {},   -- mapped get functions
  _set = {},   -- mapped set functions
+    _get = {},   -- mapped get functions
+    _set = {},   -- mapped set functions
+}
 classVariable.__index = classVariable
 …
 -- Print method
 function classVariable:print (ident,close)
  print(ident.."Variable{")
  print(ident.." mod  = '"..self.mod.."',")
  print(ident.." type = '"..self.type.."',")
  print(ident.." ptr  = '"..self.ptr.."',")
  print(ident.." name = '"..self.name.."',")
  if self.dim then print(ident.." dim = '"..self.dim.."',") end
  print(ident.." def  = '"..self.def.."',")
  print(ident.." ret  = '"..self.ret.."',")
  print(ident.."}"..close)
+    print(ident.."Variable{")
+    print(ident.." mod  = '"..self.mod.."',")
+    print(ident.." type = '"..self.type.."',")
+    print(ident.." ptr  = '"..self.ptr.."',")
+    print(ident.." name = '"..self.name.."',")
+    if self.dim then print(ident.." dim = '"..self.dim.."',") end
+    print(ident.." def  = '"..self.def.."',")
+    print(ident.." ret  = '"..self.ret.."',")
+    print(ident.."}"..close)
 end
 -- Generates C function name
 function classVariable:cfuncname (prefix)
  local parent = ""
  local unsigned = ""
  local ptr = ""
  local p = self:inmodule() or self:innamespace() or self:inclass()
  if p then
         if self.parent.classtype == 'class' then
                 parent = "_" .. self.parent.type
         else
           parent = "_" .. p
         end
  end
  if strfind(self.mod,"(unsigned)") then
   unsigned = "_unsigned"
  end
  if self.ptr == "*" then ptr = "_ptr"
  elseif self.ptr == "&" then ptr = "_ref"
  end
  local name =  prefix .. parent .. unsigned .. "_" .. gsub(self.lname or self.name,".*::","") .. ptr
         name = clean_template(name)
  return name
+    local parent = ""
+    local unsigned = ""
+    local ptr = ""
+    local p = self:inmodule() or self:innamespace() or self:inclass()
+    if p then
+        if self.parent.classtype == 'class' then
+            parent = "_" .. self.parent.type
+        else
+            parent = "_" .. p
+        end
+    end
+    if strfind(self.mod,"(unsigned)") then
+        unsigned = "_unsigned"
+    end
+    if self.ptr == "*" then ptr = "_ptr"
+    elseif self.ptr == "&" then ptr = "_ref"
+    end
+    local name =  prefix .. parent .. unsigned .. "_" .. gsub(self.lname or self.name,".*::","") .. ptr
+    name = clean_template(name)
+    return name
 end
 …
 -- check if it is a variable
 function classVariable:isvariable ()
  return true
+    return true
 end
 …
 function classVariable:getvalue (class,static, prop_get)
         local name
         if prop_get then
                 name = prop_get.."()"
         else
                 name = self.name
         end
         if class and static then
          return self.parent.type..'::'..name
         elseif class then
          return 'self->'..name
         else
          return name
         end
+    local name
+    if prop_get then
+        name = prop_get.."()"
+    else
+        name = self.name
+    end
+    if class and static then
+        return self.parent.type..'::'..name
+    elseif class then
+        return 'self->'..name
+    else
+        return name
+    end
 end
 -- get variable pointer value
 function classVariable:getpointervalue (class,static)
  if class and static then
   return class..'::p'
  elseif class then
   return 'self->p'
  else
   return 'p'
  end
+    if class and static then
+        return class..'::p'
+    elseif class then
+        return 'self->p'
+    else
+        return 'p'
+    end
 end
 …
  local class = self:inclass()
         local prop_get,prop_set
         if string.find(self.mod, 'tolua_property') then
                 _,_,type = string.find(self.mod, "tolua_property__([^%s]*)")
                 type = type or "default"
                 prop_get,prop_set = get_property_methods(type, self.name)
                 self.mod = string.gsub(self.mod, "tolua_property[^%s]*", "")
         end
  -- get function ------------------------------------------------
  if class then
   output("/* get function:",self.name," of class ",class," */")
  else
   output("/* get function:",self.name," */")
  end
  self.cgetname = self:cfuncname("tolua_get")
  output("#ifndef TOLUA_DISABLE_"..self.cgetname)
  output("\nstatic int",self.cgetname,"(lua_State* tolua_S)")
  output("{")
  -- declare self, if the case
  local _,_,static = strfind(self.mod,'^%s*(static)')
  if class and static==nil then
   output(' ',self.parent.type,'*','self = ')
   output('(',self.parent.type,'*) ')
   output('tolua_tousertype(tolua_S,1,0);')
  elseif static then
   _,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
  end
  -- check self value
  if class and static==nil then
          output('#ifndef TOLUA_RELEASE\n')
   output('  if (!self) tolua_error(tolua_S,"invalid \'self\' in accessing variable \''..self.name..'\'",NULL);');
                 output('#endif\n')
  end
  -- return value
  if string.find(self.mod, 'tolua_inherits') then
         output('#ifdef __cplusplus\n')
         output('  tolua_pushusertype(tolua_S,(void*)static_cast<'..self.type..'*>(self), "',self.type,'");')
         output('#else\n')
         output('  tolua_pushusertype(tolua_S,(void*)(('..self.type..'*)self), "',self.type,'");')
         output('#endif\n')
  else
         local t,ct = isbasic(self.type)
         if t then
                 output('  tolua_push'..t..'(tolua_S,(',ct,')'..self:getvalue(class,static,prop_get)..');')
         else
                 t = self.type
                 if self.ptr == '&' or self.ptr == '' then
                         output('  tolua_pushusertype(tolua_S,(void*)&'..self:getvalue(class,static,prop_get)..',"',t,'");')
                 else
                         output('  tolua_pushusertype(tolua_S,(void*)'..self:getvalue(class,static,prop_get)..',"',t,'");')
                 end
         end
  end
  output(' return 1;')
  output('}')
  output('#endif //#ifndef TOLUA_DISABLE\n')
  output('\n')
  -- set function ------------------------------------------------
  if not (strfind(self.type,'const%s+') or string.find(self.mod, 'tolua_readonly') or string.find(self.mod, 'tolua_inherits'))  then
   if class then
    output("/* set function:",self.name," of class ",class," */")
   else
    output("/* set function:",self.name," */")
   end
   self.csetname = self:cfuncname("tolua_set")
   output("#ifndef TOLUA_DISABLE_"..self.csetname)
   output("\nstatic int",self.csetname,"(lua_State* tolua_S)")
   output("{")
   -- declare self, if the case
   if class and static==nil then
    output(' ',self.parent.type,'*','self = ')
    output('(',self.parent.type,'*) ')
    output('tolua_tousertype(tolua_S,1,0);')
    -- check self value
                 end
   -- check types
                 output('#ifndef TOLUA_RELEASE\n')
                 output('  tolua_Error tolua_err;')
   if class and static==nil then
    output('  if (!self) tolua_error(tolua_S,"invalid \'self\' in accessing variable \''..self.name..'\'",NULL);');
   elseif static then
    _,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
   end
   -- check variable type
   output('  if (!'..self:outchecktype(2)..')')
   output('   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);')
                 output('#endif\n')
   -- assign value
                 local def = 0
                 if self.def ~= '' then def = self.def end
                 if self.type == 'char*' and self.dim ~= '' then -- is string
                  output(' strncpy(')
                         if class and static then
                                 output(self.parent.type..'::'..self.name)
                         elseif class then
                                 output('self->'..self.name)
                         else
                                 output(self.name)
                         end
                         output(',tolua_tostring(tolua_S,2,',def,'),',self.dim,'-1);')
                 else
                         local ptr = ''
                         if self.ptr~='' then ptr = '*' end
                         output(' ')
                         local name = prop_set or self.name
                         if class and static then
                                 output(self.parent.type..'::'..name)
                         elseif class then
                                 output('self->'..name)
                         else
                                 output(name)
                         end
                         local t = isbasic(self.type)
                         if prop_set then
                                 output('(')
                         else
                                 output(' = ')
                         end
                         if not t and ptr=='' then output('*') end
                         output('((',self.mod,self.type)
                         if not t then
                                 output('*')
                         end
                         output(') ')
                         if t then
                                 if isenum(self.type) then
                                         output('(int) ')
                                 end
                                 output('tolua_to'..t,'(tolua_S,2,',def,'))')
                         else
                                 output('tolua_tousertype(tolua_S,2,',def,'))')
                         end
                         if prop_set then
                                 output(")")
                         end
                         output(";")
                 end
   output(' return 0;')
   output('}')
   output('#endif //#ifndef TOLUA_DISABLE\n')
   output('\n')
  end
+    local prop_get,prop_set
+    if string.find(self.mod, 'tolua_property') then
+        _,_,type = string.find(self.mod, "tolua_property__([^%s]*)")
+        type = type or "default"
+        prop_get,prop_set = get_property_methods(type, self.name)
+        self.mod = string.gsub(self.mod, "tolua_property[^%s]*", "")
+    end
+    -- get function ------------------------------------------------
+    if class then
+        output("/* get function:",self.name," of class ",class," */")
+    else
+        output("/* get function:",self.name," */")
+    end
+    self.cgetname = self:cfuncname("tolua_get")
+    output("#ifndef TOLUA_DISABLE_"..self.cgetname)
+    output("\nstatic int",self.cgetname,"(lua_State* tolua_S)")
+    output("{")
+    -- declare self, if the case
+    local _,_,static = strfind(self.mod,'^%s*(static)')
+    if class and static==nil then
+        output(' ',self.parent.type,'*','self = ')
+        output('(',self.parent.type,'*) ')
+        output('tolua_tousertype(tolua_S,1,0);')
+    elseif static then
+        _,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
+    end
+    -- check self value
+    if class and static==nil then
+        output('#ifndef TOLUA_RELEASE\n')
+        output('  if (!self) tolua_error(tolua_S,"invalid \'self\' in accessing variable \''..self.name..'\'",NULL);');
+        output('#endif\n')
+    end
+    -- return value
+    if string.find(self.mod, 'tolua_inherits') then
+        output('#ifdef __cplusplus\n')
+        output('  tolua_pushusertype(tolua_S,(void*)static_cast<'..self.type..'*>(self), "',self.type,'");')
+        output('#else\n')
+        output('  tolua_pushusertype(tolua_S,(void*)(('..self.type..'*)self), "',self.type,'");')
+        output('#endif\n')
+    else
+        local t,ct = isbasic(self.type)
+        if t then
+            output('  tolua_push'..t..'(tolua_S,(',ct,')'..self:getvalue(class,static,prop_get)..');')
+        else
+            t = self.type
+            if self.ptr == '&' or self.ptr == '' then
+                output('  tolua_pushusertype(tolua_S,(void*)&'..self:getvalue(class,static,prop_get)..',"',t,'");')
+            else
+                output('  tolua_pushusertype(tolua_S,(void*)'..self:getvalue(class,static,prop_get)..',"',t,'");')
+            end
+        end
+    end
+    output(' return 1;')
+    output('}')
+    output('#endif //#ifndef TOLUA_DISABLE\n')
+    output('\n')
+    -- set function ------------------------------------------------
+    if not (strfind(self.type,'const%s+') or string.find(self.mod, 'tolua_readonly') or string.find(self.mod, 'tolua_inherits'))  then
+    if class then
+        output("/* set function:",self.name," of class ",class," */")
+    else
+        output("/* set function:",self.name," */")
+    end
+    self.csetname = self:cfuncname("tolua_set")
+    output("#ifndef TOLUA_DISABLE_"..self.csetname)
+    output("\nstatic int",self.csetname,"(lua_State* tolua_S)")
+    output("{")
+    -- declare self, if the case
+    if class and static==nil then
+        output(' ',self.parent.type,'*','self = ')
+        output('(',self.parent.type,'*) ')
+        output('tolua_tousertype(tolua_S,1,0);')
+        -- check self value
+    end
+    -- check types
+    output('#ifndef TOLUA_RELEASE\n')
+    output('  tolua_Error tolua_err;')
+    if class and static==nil then
+        output('  if (!self) tolua_error(tolua_S,"invalid \'self\' in accessing variable \''..self.name..'\'",NULL);');
+    elseif static then
+        _,_,self.mod = strfind(self.mod,'^%s*static%s%s*(.*)')
+    end
+    -- check variable type
+    output('  if (!'..self:outchecktype(2)..')')
+    output('   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);')
+    output('#endif\n')
+    -- assign value
+    local def = 0
+    if self.def ~= '' then def = self.def end
+    if self.type == 'char*' and self.dim ~= '' then -- is string
+        output(' strncpy(')
+        if class and static then
+            output(self.parent.type..'::'..self.name)
+            elseif class then
+                output('self->'..self.name)
+            else
+                output(self.name)
+            end
+            output(',tolua_tostring(tolua_S,2,',def,'),',self.dim,'-1);')
+        else
+            local ptr = ''
+            if self.ptr~='' then ptr = '*' end
+            output(' ')
+            local name = prop_set or self.name
+            if class and static then
+                output(self.parent.type..'::'..name)
+            elseif class then
+                output('self->'..name)
+            else
+                output(name)
+            end
+            local t = isbasic(self.type)
+            if prop_set then
+                output('(')
+            else
+                output(' = ')
+            end
+            if not t and ptr=='' then output('*') end
+            output('((',self.mod,self.type)
+            if not t then
+                output('*')
+            end
+            output(') ')
+            if t then
+                if isenum(self.type) then
+                    output('(int) ')
+                end
+                output('tolua_to'..t,'(tolua_S,2,',def,'))')
+            else
+                output('tolua_tousertype(tolua_S,2,',def,'))')
+            end
+            if prop_set then
+                output(")")
+            end
+            output(";")
+        end
+        output(' return 0;')
+        output('}')
+        output('#endif //#ifndef TOLUA_DISABLE\n')
+        output('\n')
+    end
 end
 …
 function classVariable:register (pre)
         if not self:check_public_access() then
                 return
         end
  pre = pre or ''
  local parent = self:inmodule() or self:innamespace() or self:inclass()
  if not parent then
   if classVariable._warning==nil then
    warning("Mapping variable to global may degrade performance")
    classVariable._warning = 1
   end
  end
  if self.csetname then
   output(pre..'tolua_variable(tolua_S,"'..self.lname..'",'..self.cgetname..','..self.csetname..');')
  else
   output(pre..'tolua_variable(tolua_S,"'..self.lname..'",'..self.cgetname..',NULL);')
  end
+    if not self:check_public_access() then
+        return
+    end
+    pre = pre or ''
+    local parent = self:inmodule() or self:innamespace() or self:inclass()
+    if not parent then
+        if classVariable._warning==nil then
+            warning("Mapping variable to global may degrade performance")
+            classVariable._warning = 1
+        end
+    end
+    if self.csetname then
+        output(pre..'tolua_variable(tolua_S,"'..self.lname..'",'..self.cgetname..','..self.csetname..');')
+    else
+        output(pre..'tolua_variable(tolua_S,"'..self.lname..'",'..self.cgetname..',NULL);')
+    end
 end
 -- Internal constructor
 function _Variable (t)
  setmetatable(t,classVariable)
  append(t)
  return t
+    setmetatable(t,classVariable)
+    append(t)
+    return t
 end
 …
 -- Expects a string representing the variable declaration.
 function Variable (s)
  return _Variable (Declaration(s,'var'))
 end
+    return _Variable (Declaration(s,'var'))
+end

code/branches/buildsystem2/src/tolua/lua/verbatim.lua

-                      r2087
+                      r2509
 --   line = line text
 classVerbatim = {
  line = '',
         cond = nil,    -- condition: where to generate the code (s=suport, r=register)
+    line = '',
+    cond = nil,    -- condition: where to generate the code (s=suport, r=register)
+}
 classVerbatim.__index = classVerbatim
 …
 -- preamble verbatim
 function classVerbatim:preamble ()
  if self.cond == '' then
   write(self.line)
  end
+    if self.cond == '' then
+        write(self.line)
+    end
 end
 -- support code
 function classVerbatim:supcode ()
  if strfind(self.cond,'s') then
   write(self.line)
   write('\n')
  end
+    if strfind(self.cond,'s') then
+        write(self.line)
+        write('\n')
+    end
 end
 -- register code
 function classVerbatim:register (pre)
  if strfind(self.cond,'r') then
   write(self.line)
  end
+    if strfind(self.cond,'r') then
+        write(self.line)
+    end
 end
 …
 -- Print method
 function classVerbatim:print (ident,close)
  print(ident.."Verbatim{")
  print(ident.." line = '"..self.line.."',")
  print(ident.."}"..close)
 end
+    print(ident.."Verbatim{")
+    print(ident.." line = '"..self.line.."',")
+    print(ident.."}"..close)
+    end
 -- Internal constructor
 function _Verbatim (t)
  setmetatable(t,classVerbatim)
  append(t)
  return t
+    setmetatable(t,classVerbatim)
+    append(t)
+    return t
 end
 …
 -- Expects a string representing the text line
 function Verbatim (l,cond)
  if strsub(l,1,1) == "'" then
   l = strsub(l,2)
  elseif strsub(l,1,1) == '$' then
   cond = 'sr'       -- generates in both suport and register fragments
   l = strsub(l,2)
  end
  return _Verbatim {
   line = l,
   cond = cond or '',
+ }
+    if strsub(l,1,1) == "'" then
+        l = strsub(l,2)
+    elseif strsub(l,1,1) == '$' then
+        cond = 'sr'       -- generates in both suport and register fragments
+        l = strsub(l,2)
+    end
+    return _Verbatim {
+        line = l,
+        cond = cond or '',
+    }
 end

code/branches/buildsystem2/src/tolua/tolua++.h

-                      r1810
+                      r2509
 typedef int lua_Object;
 #include "lua/lua.h"
 #include "lua/lauxlib.h"
+#include "lua.h"
+#include "lauxlib.h"
 struct tolua_Error

code/branches/buildsystem2/src/tolua/tolua.c

-                      r1810
+                      r2509
 ** Aug 2003
 ** $Id:$
+** Extension by Orxonox (Reto Grieder) to support working directory
+** and direct usage of lua files. (2008)
 */
 …
 #include "tolua++.h"
 #include "lua/lua.h"
 #include "lua/lualib.h"
 #include "lua/lauxlib.h"
+#include "lua.h"
+#include "lualib.h"
+#include "lauxlib.h"
 #include <stdio.h>
 …
          "  -H  file : create include file.\n"
          "  -n  name : set package name; default is input file root name.\n"
+         "  -w  directory : set working directory; default is location of package file.\n"
+         "  -s  file : specify source lua code for the parser; all.lua is default.\n"
          "  -p       : parse only.\n"
          "  -P       : parse and print structure information (for debug).\n"
 …
 static void add_extra (lua_State* L, char* value) {
         int len;
         lua_getglobal(L, "_extra_parameters");
         len = luaL_getn(L, -1);
         lua_pushstring(L, value);
         lua_rawseti(L, -2, len+1);
         lua_pop(L, 1);
+ int len;
+ lua_getglobal(L, "_extra_parameters");
+ len = luaL_getn(L, -1);
+ lua_pushstring(L, value);
+ lua_rawseti(L, -2, len+1);
+ lua_pop(L, 1);
 };
 …
 int main (int argc, char* argv[])
+{
+ char* working_directory = "";
+ char* lua_source = "";
  #ifdef LUA_VERSION_NUM /* lua 5.1 */
  lua_State* L = luaL_newstate();
 …
  lua_pushstring(L,TOLUA_VERSION); lua_setglobal(L,"TOLUA_VERSION");
  lua_pushstring(L,LUA_VERSION); lua_setglobal(L,"TOLUA_LUA_VERSION");
  if (argc==1)
 …
      case 'n': setfield(L,t,"n",argv[++i]); break;
      case 'H': setfield(L,t,"H",argv[++i]); break;
+     case 'w':
+      working_directory = argv[++i];
+      setfield(L,t,"w",argv[i]);
+      break;
+     case 's':
+      lua_source = argv[++i];
+      setfield(L,t,"s",argv[i]);
+      break;
      case 'S': setfield(L,t,"S",""); break;
      case '1': setfield(L,t,"1",""); break;
 …
   lua_pop(L,1);
+ }
+/* #define TOLUA_SCRIPT_RUN */
+#ifndef TOLUA_SCRIPT_RUN
+ {
+  int tolua_tolua_open (lua_State* L);
+  tolua_tolua_open(L);
+  char path[BUFSIZ];
+  char file[BUFSIZ];
+  path[0] = '\0';
+  file[0] = '\0';
+  if (strlen(lua_source) > 0 &&
+      lua_source[0] != '/' &&
+      lua_source[0] != '\\' &&
+      strlen(lua_source) > 1 &&
+      lua_source[1] != ':')
+  {
+   /* Relative path, prefix working directory */
+   strcpy(path, working_directory);
+   /* Make sure there is '\\' or '/' at the end of the path */
+   if (strlen(path) > 0)
+   {
+    char last = path[strlen(path) - 1];
+    if (last != '\\' && last != '/')
+     strcat(path, "/");
+   }
+  }
+  strcat(path, lua_source);
+  /* Extract the full path */
+  {
+   char* p;
+   p = strrchr(path, '/');
+   if (p == NULL)
+    p = strrchr(path, '\\');
+   p = (p == NULL) ? path : p + 1;
+   strcpy(file, p);
+   *p = '\0';
+  }
+  if (strlen(file) == 0)
+   strcpy(file, "all.lua");
+  lua_pushstring(L, path);
+  lua_setglobal(L, "path");
+  strcat(path, file);
+#ifdef LUA_VERSION_NUM /* lua 5.1 */
+  luaL_dofile(L, path);
+#else
+  lua_dofile(L, path);
+#endif
+ }
-#else
+ {
-  char* p;
-  char  path[BUFSIZ];
-  strcpy(path,argv[0]);
-  p = strrchr(path,'/');
-  if (p==NULL) p = strrchr(path,'\\');
-  p = (p==NULL) ? path : p+1;
-  sprintf(p,"%s","../src/bin/lua/");
-  lua_pushstring(L,path); lua_setglobal(L,"path");
-                strcat(path,"all.lua");
-  lua_dofile(L,path);
+ }
-#endif
  return 0;
+}

code/branches/buildsystem2/src/tolua/tolua_is.c

r1810	r2509
14	14
15	15	#include "tolua++.h"
16		#include "l~~ua/l~~auxlib.h"
	16	#include "lauxlib.h"
17	17
18	18	#include <stdlib.h>

code/branches/buildsystem2/src/tolua/tolua_map.c

r1810	r2509
15	15	#include "tolua++.h"
16	16	#include "tolua_event.h"
17		#include "l~~ua/l~~auxlib.h"
	17	#include "lauxlib.h"
18	18
19	19	#include <string.h>

code/branches/buildsystem2/src/tolua/tolua_push.c

r1810	r2509
14	14
15	15	#include "tolua++.h"
16		#include "l~~ua/l~~auxlib.h"
	16	#include "lauxlib.h"
17	17
18	18	#include <stdlib.h>

code/branches/buildsystem2/src/util

Property svn:mergeinfo changed
/code/branches/buildsystem/src/util (added) merged: 2197-2198,2244

code/branches/buildsystem2/src/util/CMakeLists.txt

-                      r2295
+                      r2509
 ADD_LIBRARY(util SHARED ${UTIL_SRC_FILES})
+TARGET_LINK_LIBRARIES(util ${OGRE_LIBRARY})
-TARGET_LINK_LIBRARIES(util
-  ${OGRE_LIBRARIES}
+)

code/branches/buildsystem2/src/util/Exception.cc

Property svn:mergeinfo changed (with no actual effect on merging)

code/branches/buildsystem2/src/util/Exception.h

Property svn:mergeinfo changed (with no actual effect on merging)

code/branches/buildsystem2/src/util/String.cc

-                      r2171
+                      r2509
+    }
+}
+/**
+    @brief Converts a path string to windows with "\" instead of "/".
+    @param str String pointer to be manipulated
+*/
+void convertToWindowsPath(std::string* str)
+{
+    std::string& path = *str;
+    // replace all occurences of "/" with "\"
+    for (unsigned int i = 0; i < path.length(); ++i)
+    {
+        if (path[i] == '/')
+            path[i] = '\\';
+    }
+    // add an extra '\\' at the end to make it a complete path
+    if (path != "" && path[path.length() - 1] != '\\')
+        path.append("\\");
+}
+/**
+    @brief Converts a path string to unix with "/" instead of "\".
+    @param str String pointer to be manipulated
+*/
+void convertToUnixPath(std::string* str)
+{
+    std::string& path = *str;
+    // replace all occurences of "\" with "/"
+    for (unsigned int i = 0; i < path.length(); ++i)
+    {
+        if (path[i] == '\\')
+            path[i] = '/';
+    }
+    // add an extra '\\' at the end to make it a complete path
+    if (path != "" && path[path.length() - 1] != '/')
+        path.append("/");
+}

code/branches/buildsystem2/src/util/String.h

r2171	r2509
81	81	}
82	82
	83	_UtilExport void convertToWindowsPath(std::string* str);
	84	_UtilExport void convertToUnixPath(std::string* str);
	85
83	86	#endif /* _Util_String_H__ */

code/branches/buildsystem2/visual_studio/vc8/audio.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/branches/buildsystem2/visual_studio/vc8/base.vsprops

Property svn:mergeinfo changed
/code/branches/buildsystem/visual_studio/vc8/base.vsprops (added) merged: 2217,2220

-                      r2261
+                      r2509
         <Tool
                 Name="VCCLCompilerTool"
                 AdditionalIncludeDirectories="&quot;$(RootDir)&quot;;&quot;$(RootDir)src&quot;;&quot;$(RootDir)src\orxonox&quot;;&quot;$(RootDir)src\ceguilua-0.6.1&quot;;&quot;$(LibDir)ogre-1.4.9\include&quot;;&quot;$(LibDir)boost-1.35.0\include&quot;;&quot;$(LibDir)cegui-0.6.1\include&quot;;&quot;$(LibDir)enet-1.2\include&quot;;&quot;$(LibDir)libogg-1.1.3\include&quot;;&quot;$(LibDir)libvorbis-1.2.0\include&quot;;&quot;$(LibDir)openal-1.1\include&quot;;&quot;$(LibDir)freealut-1.1.0\include&quot;;&quot;$(LibDir)tcl-8.5.2\include&quot;;&quot;$(LibDir)zlib-1.2.3\include&quot;"
                 PreprocessorDefinitions="WIN32;__WIN32__;_WIN32;_WINDOWS;BOOST_ALL_DYN_LINK;OIS_DYNAMIC_LIB;ZLIB_WINAPI"
+                AdditionalIncludeDirectories="&quot;$(RootDir)src&quot;;&quot;$(RootDir)src\tolua&quot;;&quot;$(RootDir)src\orxonox&quot;;&quot;$(RootDir)src\ceguilua-0.6.1\ceguilua&quot;;&quot;$(LibDir)ogre-1.4.9\include&quot;;&quot;$(LibDir)boost-1.35.0\include&quot;;&quot;$(LibDir)cegui-0.6.1\include&quot;;&quot;$(LibDir)enet-1.2\include&quot;;&quot;$(LibDir)libogg-1.1.3\include&quot;;&quot;$(LibDir)libvorbis-1.2.0\include&quot;;&quot;$(LibDir)openal-1.1\include&quot;;&quot;$(LibDir)freealut-1.1.0\include&quot;;&quot;$(LibDir)tcl-8.5.2\include&quot;;&quot;$(LibDir)zlib-1.2.3\include&quot;;&quot;$(LibDir)lua-5.1.3\include&quot;"
+                PreprocessorDefinitions="WIN32;__WIN32__;_WIN32;_WINDOWS;BOOST_ALL_DYN_LINK;OIS_DYNAMIC_LIB;ZLIB_WINAPI;LUA_BUILD_AS_DLL;TIXML_USE_TICPP;_CRT_SECURE_NO_WARNINGS"
                 WarningLevel="3"
                 DisableSpecificWarnings="4522;4251;4800"
 …
                 Name="VCLinkerTool"
                 OutputFile="$(OutDir)$(ProjectName)$(CS).dll"
                 AdditionalLibraryDirectories="&quot;$(LibDir)boost-1.35.0\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)cegui-0.6.1\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)enet-1.2\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)freealut-1.1.0\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)libogg-1.1.3\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)libvorbis-1.2.0\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)ogre-1.4.9\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)openal-1.1\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)tcl-8.5.2\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)zlib-1.2.3\lib\$(ConfigurationName)&quot;"
+                AdditionalLibraryDirectories="&quot;$(LibDir)boost-1.35.0\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)cegui-0.6.1\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)enet-1.2\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)freealut-1.1.0\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)libogg-1.1.3\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)libvorbis-1.2.0\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)ogre-1.4.9\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)openal-1.1\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)tcl-8.5.2\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)zlib-1.2.3\lib\$(ConfigurationName)&quot;;&quot;$(LibDir)lua-5.1.3\lib\$(ConfigurationName)&quot;"
                 SubSystem="1"
                 ImportLibrary="$(IntDir)\$(TargetName).lib"
                 TargetMachine="1"
+        />
+        <UserMacro
+                Name="LibOutDir"
+                Value="$(RootDir)build\"
         />
         <UserMacro

code/branches/buildsystem2/visual_studio/vc8/ceguilua.vsprops

Property svn:mergeinfo changed
/code/branches/buildsystem/visual_studio/vc8/ceguilua.vsprops (added) merged: 2217

r2261	r2509
13	13	<Tool
14	14	Name="VCLinkerTool"
15		AdditionalDependencies="CEGUIBase$(CS).lib"
	15	AdditionalDependencies="CEGUIBase$(CS).lib lua$(CS).lib"
16	16	/>
17	17	</VisualStudioPropertySheet>

code/branches/buildsystem2/visual_studio/vc8/core.vcproj

-                      r2087
+                      r2509
                         </File>
                         <File
+                                RelativePath="..\..\src\core\CMakeLists.txt"
+                                >
+                                <FileConfiguration
+                                        Name="Debug|Win32"
+                                        >
+                                        <Tool
+                                                Name="VCCustomBuildTool"
+                                                Description="Generating tolua bind files..."
+                                                CommandLine="path $(LibDir)\..\..\bin\$(SolutionName)\$(ConfigurationName); %path%&#x0D;&#x0A;cd $(RootDir)\bin&#x0D;&#x0A;echo $cfile &quot;CommandExecutor.h&quot; &gt; $(RootDir)\src\core\tolua.pkg&#x0D;&#x0A;echo $cfile &quot;Script.h&quot; &gt;&gt; $(RootDir)\src\core\tolua.pkg&#x0D;&#x0A;$(OutDir)\toluaexe$(CS).exe -n Core -w $(RootDir)\src\core\ -s $(RootDir)\src\tolua\all.lua -o ToluaBindCore.cc -H ToluaBindCore.h tolua.pkg&#x0D;&#x0A;"
+                                                AdditionalDependencies="$(RootDir)\src\core\Script.h;$(RootDir)\src\core\CommandExecutor.h"
+                                                Outputs="$(RootDir)\src\core\ToluaBindCore.cc; $(RootDir)\src\core\ToluaBindCore.h"
+                                        />
+                                </FileConfiguration>
+                                <FileConfiguration
+                                        Name="Release|Win32"
+                                        >
+                                        <Tool
+                                                Name="VCCustomBuildTool"
+                                                Description="Generating tolua bind files..."
+                                                CommandLine="path $(LibDir)\..\..\bin\$(SolutionName)\$(ConfigurationName); %path%&#x0D;&#x0A;cd $(RootDir)\bin&#x0D;&#x0A;echo $cfile &quot;CommandExecutor.h&quot; &gt; $(RootDir)\src\core\tolua.pkg&#x0D;&#x0A;echo $cfile &quot;Script.h&quot; &gt;&gt; $(RootDir)\src\core\tolua.pkg&#x0D;&#x0A;$(OutDir)\toluaexe$(CS).exe -n Core -w $(RootDir)\src\core\ -s $(RootDir)\src\tolua\all.lua -o ToluaBindCore.cc -H ToluaBindCore.h tolua.pkg&#x0D;&#x0A;"
+                                                AdditionalDependencies="$(RootDir)\src\core\Script.h;$(RootDir)\src\core\CommandExecutor.h"
+                                                Outputs="$(RootDir)\src\core\ToluaBindCore.cc; $(RootDir)\src\core\ToluaBindCore.h"
+                                        />
+                                </FileConfiguration>
+                        </File>
+                        <File
                                 RelativePath="..\..\src\core\ConfigFileManager.cc"
+                                >
 …
+                                >
                         </File>
+                        <Filter
+                                Name="tolua"
+                                >
+                                <File
+                                        RelativePath="..\..\src\core\tolua\tolua.pkg"
+                                        >
+                                        <FileConfiguration
+                                                Name="Debug|Win32"
+                                                >
+                                                <Tool
+                                                        Name="VCCustomBuildTool"
+                                                        Description="Generating tolua bind files..."
+                                                        CommandLine="&quot;$(RootDir)\build\$(SolutionName)\$(ConfigurationName)\toluagen_orxonox\toluagen_orxonox$(CS).exe&quot; -n Core -o $(RootDir)/src/core/tolua/tolua_bind.cc -H $(RootDir)/src/core/tolua/tolua_bind.h $(RootDir)/src/core/tolua/tolua.pkg&#x0D;&#x0A;"
+                                                        AdditionalDependencies="$(RootDir)\src\core\Script.h;$(RootDir)\src\core\CommandExecutor.h"
+                                                        Outputs="$(RootDir)\src\core\tolua\tolua_bind.cc; $(RootDir)\src\core\tolua\tolua_bind.h"
+                                                />
+                                        </FileConfiguration>
+                                        <FileConfiguration
+                                                Name="Release|Win32"
+                                                >
+                                                <Tool
+                                                        Name="VCCustomBuildTool"
+                                                        Description="Generating tolua bind files..."
+                                                        CommandLine="&quot;$(RootDir)\build\$(SolutionName)\$(ConfigurationName)\toluagen_orxonox\toluagen_orxonox$(CS).exe&quot; -n Core -o $(RootDir)/src/core/tolua/tolua_bind.cc -H $(RootDir)/src/core/tolua/tolua_bind.h $(RootDir)/src/core/tolua/tolua.pkg&#x0D;&#x0A;"
+                                                        AdditionalDependencies="$(RootDir)\src\core\Script.h;$(RootDir)\src\core\CommandExecutor.h"
+                                                        Outputs="$(RootDir)\src\core\tolua\tolua_bind.cc; $(RootDir)\src\core\tolua\tolua_bind.h"
+                                                />
+                                        </FileConfiguration>
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\core\tolua\tolua_bind.cc"
+                                        >
+                                </File>
+                        </Filter>
+                        <File
+                                RelativePath="..\..\src\core\ToluaBindCore.cc"
+                                >
+                        </File>
                         <Filter
                                 Name="command"
 …
                         </File>
                         <File
+                                RelativePath="..\..\src\core\tolua_bind.h"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\core\ToluaBindCore.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\core\XMLIncludes.h"
+                                >
 …
                                 <File
                                         RelativePath="..\..\src\core\XMLPort.h"
+                                        >
-                                </File>
-                        </Filter>
-                        <Filter
-                                Name="tolua"
+                                >
-                                <File
-                                        RelativePath="..\..\src\core\tolua\tolua_bind.h"
+                                        >
                                 </File>

code/branches/buildsystem2/visual_studio/vc8/core.vsprops

Property svn:mergeinfo changed
/code/branches/buildsystem/visual_studio/vc8/core.vsprops (added) merged: 2217

r2261	r2509
13	13	<Tool
14	14	Name="VCLinkerTool"
15		AdditionalDependencies="OgreMain$(CS).lib tcl85t.lib"
	15	AdditionalDependencies="OgreMain$(CS).lib tcl85t.lib lua$(CS).lib"
16	16	/>
17	17	</VisualStudioPropertySheet>

code/branches/buildsystem2/visual_studio/vc8/cpptcl.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/branches/buildsystem2/visual_studio/vc8/debug.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/branches/buildsystem2/visual_studio/vc8/directories.vsprops

Property svn:mergeinfo changed
/code/branches/buildsystem/visual_studio/vc8/directories.vsprops (added) merged: 2217

code/branches/buildsystem2/visual_studio/vc8/network.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/branches/buildsystem2/visual_studio/vc8/orxonox.vcproj

-                      r2171
+                      r2509
                         <Tool
                                 Name="VCPostBuildEventTool"
+                                Description="Copying files from init folder..."
+                                CommandLine="for %%a in ($(RootDir)\bin\msvc\$(ConfigurationName)\*) do replace %%a $(OutDir). /A &gt;nul&#x0D;&#x0A;rem for %%a in ($(RootDir)\init\common\*) do replace %%a $(OutDir). /A &gt;nul&#x0D;&#x0A;"
                         />
                 </Configuration>
 …
                         <Tool
                                 Name="VCPostBuildEventTool"
+                                Description="Copying files from init folder..."
+                                CommandLine="for %%a in ($(RootDir)\bin\msvc\$(ConfigurationName)\*) do replace %%a $(OutDir). /A &gt;nul&#x0D;&#x0A;rem for %%a in ($(RootDir)\init\common\*) do replace %%a $(OutDir). /A &gt;nul&#x0D;&#x0A;"
                         />
                 </Configuration>
 …
                         </File>
                         <File
+                                RelativePath="..\..\src\orxonox\CMakeLists.txt"
+                                >
+                                <FileConfiguration
+                                        Name="Debug|Win32"
+                                        >
+                                        <Tool
+                                                Name="VCCustomBuildTool"
+                                                Description="Generating tolua bind files..."
+                                                CommandLine="path $(LibDir)\..\..\bin\$(SolutionName)\$(ConfigurationName); %path%&#x0D;&#x0A;cd $(RootDir)\bin&#x0D;&#x0A;echo $cfile &quot;gui/GUIManager.h&quot; &gt; $(RootDir)\src\orxonox\tolua.pkg&#x0D;&#x0A;&quot;$(OutDir)\toluaexe$(CS).exe&quot; -n Orxonox -w $(RootDir)\src\orxonox\ -s $(RootDir)\src\tolua\all.lua -o ToluaBindOrxonox.cc -H ToluaBindOrxonox.h tolua.pkg&#x0D;&#x0A;"
+                                                AdditionalDependencies="$(RootDir)\src\orxonox\gui\GUIManager.h"
+                                                Outputs="$(RootDir)\src\orxonox\ToluaBindOrxonox.cc; $(RootDir)\src\orxonox\ToluaBindOrxonox.h"
+                                        />
+                                </FileConfiguration>
+                                <FileConfiguration
+                                        Name="Release|Win32"
+                                        >
+                                        <Tool
+                                                Name="VCCustomBuildTool"
+                                                Description="Generating tolua bind files..."
+                                                CommandLine="path $(LibDir)\..\..\bin\$(SolutionName)\$(ConfigurationName); %path%&#x0D;&#x0A;cd $(RootDir)\bin&#x0D;&#x0A;echo $cfile &quot;gui/GUIManager.h&quot; &gt; $(RootDir)\src\orxonox\tolua.pkg&#x0D;&#x0A;&quot;$(OutDir)\toluaexe$(CS).exe&quot; -n Orxonox -w $(RootDir)\src\orxonox\ -s $(RootDir)\src\tolua\all.lua -o ToluaBindOrxonox.cc -H ToluaBindOrxonox.h tolua.pkg&#x0D;&#x0A;"
+                                                AdditionalDependencies="$(RootDir)\src\orxonox\gui\GUIManager.h"
+                                                Outputs="$(RootDir)\src\orxonox\ToluaBindOrxonox.cc; $(RootDir)\src\orxonox\ToluaBindOrxonox.h"
+                                        />
+                                </FileConfiguration>
+                        </File>
+                        <File
                                 RelativePath="..\..\src\orxonox\GraphicsEngine.cc"
+                                >
 …
                                 RelativePath="..\..\src\orxonox\Settings.cc"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\orxonox\ToluaBindOrxonox.cc"
+                                >
+                                <FileConfiguration
+                                        Name="Debug|Win32"
+                                        >
+                                        <Tool
+                                                Name="VCCLCompilerTool"
+                                                UsePrecompiledHeader="0"
+                                        />
+                                </FileConfiguration>
+                                <FileConfiguration
+                                        Name="Release|Win32"
+                                        >
+                                        <Tool
+                                                Name="VCCLCompilerTool"
+                                                UsePrecompiledHeader="0"
+                                        />
+                                </FileConfiguration>
                         </File>
                         <Filter
 …
                         </Filter>
                         <Filter
-                                Name="tolua"
+                                >
-                                <File
-                                        RelativePath="..\..\src\orxonox\tolua\tolua.pkg"
+                                        >
-                                        <FileConfiguration
-                                                Name="Debug|Win32"
+                                                >
-                                                <Tool
-                                                        Name="VCCustomBuildTool"
-                                                        Description="Generating tolua bind files..."
-                                                        CommandLine="&quot;$(RootDir)\build\$(SolutionName)\$(ConfigurationName)\toluagen_orxonox\toluagen_orxonox$(CS).exe&quot; -n Orxonox -o $(RootDir)/src/orxonox/tolua/tolua_bind.cc -H $(RootDir)/src/orxonox/tolua/tolua_bind.h $(RootDir)/src/orxonox/tolua/tolua.pkg&#x0D;&#x0A;"
-                                                        AdditionalDependencies="$(RootDir)\src\orxonox\gui\GUIManager.h"
-                                                        Outputs="$(RootDir)\src\orxonox\tolua\tolua_bind.cc; $(RootDir)\src\orxonox\tolua\tolua_bind.h"
-                                                />
-                                        </FileConfiguration>
-                                        <FileConfiguration
-                                                Name="Release|Win32"
+                                                >
-                                                <Tool
-                                                        Name="VCCustomBuildTool"
-                                                        Description="Generating tolua bind files..."
-                                                        CommandLine="&quot;$(RootDir)\build\$(SolutionName)\$(ConfigurationName)\toluagen_orxonox\toluagen_orxonox$(CS).exe&quot; -n Orxonox -o $(RootDir)/src/orxonox/tolua/tolua_bind.cc -H $(RootDir)/src/orxonox/tolua/tolua_bind.h $(RootDir)/src/orxonox/tolua/tolua.pkg&#x0D;&#x0A;"
-                                                        AdditionalDependencies="$(RootDir)\src\orxonox\gui\GUIManager.h"
-                                                        Outputs="$(RootDir)\src\orxonox\tolua\tolua_bind.cc; $(RootDir)\src\orxonox\tolua\tolua_bind.h"
-                                                />
-                                        </FileConfiguration>
-                                </File>
-                                <File
-                                        RelativePath="..\..\src\orxonox\tolua\tolua_bind.cc"
+                                        >
-                                        <FileConfiguration
-                                                Name="Debug|Win32"
+                                                >
-                                                <Tool
-                                                        Name="VCCLCompilerTool"
-                                                        UsePrecompiledHeader="0"
-                                                />
-                                        </FileConfiguration>
-                                        <FileConfiguration
-                                                Name="Release|Win32"
+                                                >
-                                                <Tool
-                                                        Name="VCCLCompilerTool"
-                                                        UsePrecompiledHeader="0"
-                                                />
-                                        </FileConfiguration>
-                                </File>
-                        </Filter>
-                        <Filter
                                 Name="overlays"
+                                >
 …
+                                >
                         </File>
+                        <File
+                                RelativePath="..\..\src\orxonox\tolua_bind.h"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\orxonox\ToluaBindOrxonox.h"
+                                >
+                        </File>
                         <Filter
                                 Name="objects"
 …
                                 <File
                                         RelativePath="..\..\src\orxonox\tools\WindowEventListener.h"
+                                        >
-                                </File>
-                        </Filter>
-                        <Filter
-                                Name="tolua"
+                                >
-                                <File
-                                        RelativePath="..\..\src\orxonox\tolua\tolua_bind.h"
+                                        >
                                 </File>

code/branches/buildsystem2/visual_studio/vc8/orxonox.vsprops

Property svn:mergeinfo changed
/code/branches/buildsystem/visual_studio/vc8/orxonox.vsprops (added) merged: 2217

r2261	r2509
15	15	<Tool
16	16	Name="VCLinkerTool"
17		AdditionalDependencies="OgreMain$(CS).lib tcl85t.lib enet$(CS).lib zlib$(CS).lib CEGUIBase$(CS).lib"
	17	AdditionalDependencies="OgreMain$(CS).lib tcl85t.lib enet$(CS).lib zlib$(CS).lib CEGUIBase$(CS).lib lua$(CS).lib"
18	18	OutputFile="$(OutDir)$(ProjectName)$(CS).exe"
19	19	IgnoreDefaultLibraryNames=""

code/branches/buildsystem2/visual_studio/vc8/orxonox_vc8.sln

Property svn:mergeinfo changed
/code/branches/buildsystem/visual_studio/vc8/orxonox_vc8.sln (added) merged: 2217

-                      r2261
+                      r2509
 Microsoft Visual Studio Solution File, Format Version 9.00
 # Visual Studio 2005
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "orxonox", "orxonox.vcproj", "{0B6C5CFD-F91B-432A-80A3-2610F61E060B}"
-        ProjectSection(WebsiteProperties) = preProject
-                Debug.AspNetCompiler.Debug = "True"
-                Release.AspNetCompiler.Debug = "False"
-        EndProjectSection
-        ProjectSection(ProjectDependencies) = postProject
-                {4BBBB49F-3203-4BB4-AAE3-48BCA96FCB4F} = {4BBBB49F-3203-4BB4-AAE3-48BCA96FCB4F}
-                {F101C2F0-1CB9-4A57-827B-6C399A99B28F} = {F101C2F0-1CB9-4A57-827B-6C399A99B28F}
-                {271715F3-5B90-4110-A552-70C788084A86} = {271715F3-5B90-4110-A552-70C788084A86}
-                {2240ECD7-2F48-4431-8E1B-25466A384CCC} = {2240ECD7-2F48-4431-8E1B-25466A384CCC}
-                {35575B59-E1AE-40E8-89C4-2862B5B09B68} = {35575B59-E1AE-40E8-89C4-2862B5B09B68}
-                {4733BD1A-E04C-458D-8BFB-5010250EA497} = {4733BD1A-E04C-458D-8BFB-5010250EA497}
-                {63B3E57A-4382-42F3-85EC-E869CFCCA88F} = {63B3E57A-4382-42F3-85EC-E869CFCCA88F}
-                {35E36A06-0A5C-4A0D-9AB6-5A05EAA87626} = {35E36A06-0A5C-4A0D-9AB6-5A05EAA87626}
-                {71FC0211-5EB5-4637-BE8A-A48EC3CC27D0} = {71FC0211-5EB5-4637-BE8A-A48EC3CC27D0}
-        EndProjectSection
-EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cpptcl", "cpptcl.vcproj", "{53C56131-E2AA-4A27-B460-7AC05D61A0E6}"
-        ProjectSection(WebsiteProperties) = preProject
-                Debug.AspNetCompiler.Debug = "True"
-                Release.AspNetCompiler.Debug = "False"
-        EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tinyxml", "tinyxml.vcproj", "{F101C2F0-1CB9-4A57-827B-6C399A99B28F}"
-        ProjectSection(WebsiteProperties) = preProject
-                Debug.AspNetCompiler.Debug = "True"
-                Release.AspNetCompiler.Debug = "False"
-        EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tolua", "tolua.vcproj", "{35E36A06-0A5C-4A0D-9AB6-5A05EAA87626}"
+        ProjectSection(WebsiteProperties) = preProject
+                Debug.AspNetCompiler.Debug = "True"
+                Release.AspNetCompiler.Debug = "False"
+        EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "toluaexe", "toluaexe.vcproj", "{A0724246-CB7C-420B-BCF0-68EF205AFE34}"
         ProjectSection(ProjectDependencies) = postProject
+                {63B3E57A-4382-42F3-85EC-E869CFCCA88F} = {63B3E57A-4382-42F3-85EC-E869CFCCA88F}
+        EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "toluagen_orxonox", "toluagen_orxonox.vcproj", "{71FC0211-5EB5-4637-BE8A-A48EC3CC27D0}"
+        ProjectSection(WebsiteProperties) = preProject
+                Debug.AspNetCompiler.Debug = "True"
+                Release.AspNetCompiler.Debug = "False"
+        EndProjectSection
+        ProjectSection(ProjectDependencies) = postProject
+                {8F5B7ED0-D380-4B4F-A744-3A568718176C} = {8F5B7ED0-D380-4B4F-A744-3A568718176C}
+                {C6692661-9160-49E6-B109-A155F9485402} = {C6692661-9160-49E6-B109-A155F9485402}
+                {A0724246-CB7C-420B-BCF0-68EF205AFE34} = {A0724246-CB7C-420B-BCF0-68EF205AFE34}
+        EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "toluagen", "toluagen.vcproj", "{A0724246-CB7C-420B-BCF0-68EF205AFE34}"
+        ProjectSection(WebsiteProperties) = preProject
+                Debug.AspNetCompiler.Debug = "True"
+                Release.AspNetCompiler.Debug = "False"
+        EndProjectSection
+        ProjectSection(ProjectDependencies) = postProject
+                {8F5B7ED0-D380-4B4F-A744-3A568718176C} = {8F5B7ED0-D380-4B4F-A744-3A568718176C}
+                {C6692661-9160-49E6-B109-A155F9485402} = {C6692661-9160-49E6-B109-A155F9485402}
+                {35E36A06-0A5C-4A0D-9AB6-5A05EAA87626} = {35E36A06-0A5C-4A0D-9AB6-5A05EAA87626}
         EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "util", "util.vcproj", "{2240ECD7-2F48-4431-8E1B-25466A384CCC}"
-        ProjectSection(WebsiteProperties) = preProject
-                Debug.AspNetCompiler.Debug = "True"
-                Release.AspNetCompiler.Debug = "False"
-        EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "core", "core.vcproj", "{271715F3-5B90-4110-A552-70C788084A86}"
-        ProjectSection(WebsiteProperties) = preProject
-                Debug.AspNetCompiler.Debug = "True"
-                Release.AspNetCompiler.Debug = "False"
-        EndProjectSection
         ProjectSection(ProjectDependencies) = postProject
+                {35E36A06-0A5C-4A0D-9AB6-5A05EAA87626} = {35E36A06-0A5C-4A0D-9AB6-5A05EAA87626}
+                {A0724246-CB7C-420B-BCF0-68EF205AFE34} = {A0724246-CB7C-420B-BCF0-68EF205AFE34}
+                {53C56131-E2AA-4A27-B460-7AC05D61A0E6} = {53C56131-E2AA-4A27-B460-7AC05D61A0E6}
+                {2240ECD7-2F48-4431-8E1B-25466A384CCC} = {2240ECD7-2F48-4431-8E1B-25466A384CCC}
+                {F101C2F0-1CB9-4A57-827B-6C399A99B28F} = {F101C2F0-1CB9-4A57-827B-6C399A99B28F}
                 {EA969DF2-70AF-46E6-BBE2-E03112E04CB8} = {EA969DF2-70AF-46E6-BBE2-E03112E04CB8}
-                {F101C2F0-1CB9-4A57-827B-6C399A99B28F} = {F101C2F0-1CB9-4A57-827B-6C399A99B28F}
-                {2240ECD7-2F48-4431-8E1B-25466A384CCC} = {2240ECD7-2F48-4431-8E1B-25466A384CCC}
-                {53C56131-E2AA-4A27-B460-7AC05D61A0E6} = {53C56131-E2AA-4A27-B460-7AC05D61A0E6}
-                {35E36A06-0A5C-4A0D-9AB6-5A05EAA87626} = {35E36A06-0A5C-4A0D-9AB6-5A05EAA87626}
-                {63B3E57A-4382-42F3-85EC-E869CFCCA88F} = {63B3E57A-4382-42F3-85EC-E869CFCCA88F}
-                {71FC0211-5EB5-4637-BE8A-A48EC3CC27D0} = {71FC0211-5EB5-4637-BE8A-A48EC3CC27D0}
         EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "audio", "audio.vcproj", "{4733BD1A-E04C-458D-8BFB-5010250EA497}"
-        ProjectSection(WebsiteProperties) = preProject
-                Debug.AspNetCompiler.Debug = "True"
-                Release.AspNetCompiler.Debug = "False"
-        EndProjectSection
         ProjectSection(ProjectDependencies) = postProject
+                {2240ECD7-2F48-4431-8E1B-25466A384CCC} = {2240ECD7-2F48-4431-8E1B-25466A384CCC}
                 {271715F3-5B90-4110-A552-70C788084A86} = {271715F3-5B90-4110-A552-70C788084A86}
-                {2240ECD7-2F48-4431-8E1B-25466A384CCC} = {2240ECD7-2F48-4431-8E1B-25466A384CCC}
         EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "network", "network.vcproj", "{35575B59-E1AE-40E8-89C4-2862B5B09B68}"
-        ProjectSection(WebsiteProperties) = preProject
-                Debug.AspNetCompiler.Debug = "True"
-                Release.AspNetCompiler.Debug = "False"
-        EndProjectSection
         ProjectSection(ProjectDependencies) = postProject
+                {2240ECD7-2F48-4431-8E1B-25466A384CCC} = {2240ECD7-2F48-4431-8E1B-25466A384CCC}
                 {271715F3-5B90-4110-A552-70C788084A86} = {271715F3-5B90-4110-A552-70C788084A86}
-                {2240ECD7-2F48-4431-8E1B-25466A384CCC} = {2240ECD7-2F48-4431-8E1B-25466A384CCC}
         EndProjectSection
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lua", "lua.vcproj", "{63B3E57A-4382-42F3-85EC-E869CFCCA88F}"
+        ProjectSection(WebsiteProperties) = preProject
+                Debug.AspNetCompiler.Debug = "True"
+                Release.AspNetCompiler.Debug = "False"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "orxonox", "orxonox.vcproj", "{0B6C5CFD-F91B-432A-80A3-2610F61E060B}"
+        ProjectSection(ProjectDependencies) = postProject
+                {35E36A06-0A5C-4A0D-9AB6-5A05EAA87626} = {35E36A06-0A5C-4A0D-9AB6-5A05EAA87626}
+                {A0724246-CB7C-420B-BCF0-68EF205AFE34} = {A0724246-CB7C-420B-BCF0-68EF205AFE34}
+                {4733BD1A-E04C-458D-8BFB-5010250EA497} = {4733BD1A-E04C-458D-8BFB-5010250EA497}
+                {35575B59-E1AE-40E8-89C4-2862B5B09B68} = {35575B59-E1AE-40E8-89C4-2862B5B09B68}
+                {4BBBB49F-3203-4BB4-AAE3-48BCA96FCB4F} = {4BBBB49F-3203-4BB4-AAE3-48BCA96FCB4F}
+                {2240ECD7-2F48-4431-8E1B-25466A384CCC} = {2240ECD7-2F48-4431-8E1B-25466A384CCC}
+                {271715F3-5B90-4110-A552-70C788084A86} = {271715F3-5B90-4110-A552-70C788084A86}
+                {F101C2F0-1CB9-4A57-827B-6C399A99B28F} = {F101C2F0-1CB9-4A57-827B-6C399A99B28F}
         EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ceguilua", "ceguilua.vcproj", "{4BBBB49F-3203-4BB4-AAE3-48BCA96FCB4F}"
-        ProjectSection(WebsiteProperties) = preProject
-                Debug.AspNetCompiler.Debug = "True"
-                Release.AspNetCompiler.Debug = "False"
-        EndProjectSection
         ProjectSection(ProjectDependencies) = postProject
                 {35E36A06-0A5C-4A0D-9AB6-5A05EAA87626} = {35E36A06-0A5C-4A0D-9AB6-5A05EAA87626}
-                {63B3E57A-4382-42F3-85EC-E869CFCCA88F} = {63B3E57A-4382-42F3-85EC-E869CFCCA88F}
         EndProjectSection
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ois", "ois.vcproj", "{EA969DF2-70AF-46E6-BBE2-E03112E04CB8}"
-        ProjectSection(WebsiteProperties) = preProject
-                Debug.AspNetCompiler.Debug = "True"
-                Release.AspNetCompiler.Debug = "False"
-        EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "externals", "externals", "{B9D56701-B4DB-43F8-9920-241CA418C1CE}"
-        ProjectSection(WebsiteProperties) = preProject
-                Debug.AspNetCompiler.Debug = "True"
-                Release.AspNetCompiler.Debug = "False"
-        EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tolua_static", "tolua_static.vcproj", "{C6692661-9160-49E6-B109-A155F9485402}"
-        ProjectSection(WebsiteProperties) = preProject
-                Debug.AspNetCompiler.Debug = "True"
-                Release.AspNetCompiler.Debug = "False"
-        EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lua_static", "lua_static.vcproj", "{8F5B7ED0-D380-4B4F-A744-3A568718176C}"
-        ProjectSection(WebsiteProperties) = preProject
-                Debug.AspNetCompiler.Debug = "True"
-                Release.AspNetCompiler.Debug = "False"
-        EndProjectSection
 EndProject
 Global
 …
                 {35E36A06-0A5C-4A0D-9AB6-5A05EAA87626}.Release|Win32.ActiveCfg = Release|Win32
                 {35E36A06-0A5C-4A0D-9AB6-5A05EAA87626}.Release|Win32.Build.0 = Release|Win32
-                {71FC0211-5EB5-4637-BE8A-A48EC3CC27D0}.Debug|Win32.ActiveCfg = Debug|Win32
-                {71FC0211-5EB5-4637-BE8A-A48EC3CC27D0}.Debug|Win32.Build.0 = Debug|Win32
-                {71FC0211-5EB5-4637-BE8A-A48EC3CC27D0}.Release|Win32.ActiveCfg = Release|Win32
-                {71FC0211-5EB5-4637-BE8A-A48EC3CC27D0}.Release|Win32.Build.0 = Release|Win32
                 {A0724246-CB7C-420B-BCF0-68EF205AFE34}.Debug|Win32.ActiveCfg = Debug|Win32
                 {A0724246-CB7C-420B-BCF0-68EF205AFE34}.Debug|Win32.Build.0 = Debug|Win32
 …
                 {0B6C5CFD-F91B-432A-80A3-2610F61E060B}.Release|Win32.ActiveCfg = Release|Win32
                 {0B6C5CFD-F91B-432A-80A3-2610F61E060B}.Release|Win32.Build.0 = Release|Win32
-                {63B3E57A-4382-42F3-85EC-E869CFCCA88F}.Debug|Win32.ActiveCfg = Debug|Win32
-                {63B3E57A-4382-42F3-85EC-E869CFCCA88F}.Debug|Win32.Build.0 = Debug|Win32
-                {63B3E57A-4382-42F3-85EC-E869CFCCA88F}.Release|Win32.ActiveCfg = Release|Win32
-                {63B3E57A-4382-42F3-85EC-E869CFCCA88F}.Release|Win32.Build.0 = Release|Win32
                 {4BBBB49F-3203-4BB4-AAE3-48BCA96FCB4F}.Debug|Win32.ActiveCfg = Debug|Win32
                 {4BBBB49F-3203-4BB4-AAE3-48BCA96FCB4F}.Debug|Win32.Build.0 = Debug|Win32
 …
                 {EA969DF2-70AF-46E6-BBE2-E03112E04CB8}.Release|Win32.ActiveCfg = Release|Win32
                 {EA969DF2-70AF-46E6-BBE2-E03112E04CB8}.Release|Win32.Build.0 = Release|Win32
-                {C6692661-9160-49E6-B109-A155F9485402}.Debug|Win32.ActiveCfg = Debug|Win32
-                {C6692661-9160-49E6-B109-A155F9485402}.Debug|Win32.Build.0 = Debug|Win32
-                {C6692661-9160-49E6-B109-A155F9485402}.Release|Win32.ActiveCfg = Release|Win32
-                {C6692661-9160-49E6-B109-A155F9485402}.Release|Win32.Build.0 = Release|Win32
-                {8F5B7ED0-D380-4B4F-A744-3A568718176C}.Debug|Win32.ActiveCfg = Debug|Win32
-                {8F5B7ED0-D380-4B4F-A744-3A568718176C}.Debug|Win32.Build.0 = Debug|Win32
-                {8F5B7ED0-D380-4B4F-A744-3A568718176C}.Release|Win32.ActiveCfg = Release|Win32
-                {8F5B7ED0-D380-4B4F-A744-3A568718176C}.Release|Win32.Build.0 = Release|Win32
         EndGlobalSection
         GlobalSection(SolutionProperties) = preSolution
 …
                 {F101C2F0-1CB9-4A57-827B-6C399A99B28F} = {B9D56701-B4DB-43F8-9920-241CA418C1CE}
                 {35E36A06-0A5C-4A0D-9AB6-5A05EAA87626} = {B9D56701-B4DB-43F8-9920-241CA418C1CE}
-                {71FC0211-5EB5-4637-BE8A-A48EC3CC27D0} = {B9D56701-B4DB-43F8-9920-241CA418C1CE}
                 {A0724246-CB7C-420B-BCF0-68EF205AFE34} = {B9D56701-B4DB-43F8-9920-241CA418C1CE}
-                {63B3E57A-4382-42F3-85EC-E869CFCCA88F} = {B9D56701-B4DB-43F8-9920-241CA418C1CE}
                 {4BBBB49F-3203-4BB4-AAE3-48BCA96FCB4F} = {B9D56701-B4DB-43F8-9920-241CA418C1CE}
                 {EA969DF2-70AF-46E6-BBE2-E03112E04CB8} = {B9D56701-B4DB-43F8-9920-241CA418C1CE}
                 {53C56131-E2AA-4A27-B460-7AC05D61A0E6} = {B9D56701-B4DB-43F8-9920-241CA418C1CE}
-                {C6692661-9160-49E6-B109-A155F9485402} = {B9D56701-B4DB-43F8-9920-241CA418C1CE}
-                {8F5B7ED0-D380-4B4F-A744-3A568718176C} = {B9D56701-B4DB-43F8-9920-241CA418C1CE}
         EndGlobalSection
 EndGlobal

code/branches/buildsystem2/visual_studio/vc8/release.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/branches/buildsystem2/visual_studio/vc8/tinyxml.vcproj

Property svn:mergeinfo changed (with no actual effect on merging)

code/branches/buildsystem2/visual_studio/vc8/tinyxml.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/branches/buildsystem2/visual_studio/vc8/tolua.vsprops

Property svn:mergeinfo changed
/code/branches/buildsystem/visual_studio/vc8/tolua.vsprops (added) merged: 2217

-                      r2261
+                      r2509
                 DisableSpecificWarnings="4996"
         />
+        <Tool
+                Name="VCLinkerTool"
+                AdditionalDependencies="lua$(CS).lib"
+        />
 </VisualStudioPropertySheet>

code/branches/buildsystem2/visual_studio/vc8/util.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

Context Navigation

Legend:

Download in other formats: