Builds on gcc / clang!

Author: AustinBrunkhorst

Examples/CMakeLists.txt

@@ -40,6 +40,21 @@ meta_parser_prebuild(
 
 add_library(${TEST_MODULE_TARGET} ${META_GENERATED_FILES})
 
+target_link_libraries(${TEST_MODULE_TARGET} MetaRuntime)
+
+if (MSVC)
+	add_compile_options(
+		# treat warnings as errors
+		/WX
+		# multi process compilation
+		/MP
+	)
+else ()
+	add_compile_options(
+		-std=c++11
+	)
+endif ()
+
 macro (add_meta_test TARGET SOURCES)
 	add_executable(${TARGET} 
 		${TEST_HEADERS} 
@@ -68,4 +83,4 @@ meta_parser_build(
     MODULE_SOURCE_FILE ${META_MODULE_SOURCE}
     HEADER_FILES ${TEST_HEADERS}
     PARSER_EXECUTABLE "$<TARGET_FILE:MetaParser>"
-)
+)

Examples/FunctionsAndMethods.cpp

@@ -3,6 +3,8 @@
 #include "TestTypes.h"
 #include "TestProperties.h"
 
+#include "TypeCreator.h"
+
 using namespace ursine::meta;
 
 int main(void)
@@ -16,7 +18,7 @@ int main(void)
     Method loadMethod = soundEffectType.GetMethod( "Load" );
 
     // creates an instance of a sound effect
-    Variant effect = soundEffectType.Create( );
+    Variant effect = TypeCreator::Create( soundEffectType );
 
     // effect.volume is now 85
     volumeField.SetValue( effect, 85.0f );

Resources/Templates/module-file-source.mustache

@@ -82,16 +82,10 @@ void meta_generated::DefineModuleFile{{targetName}}{{moduleFileName}}(m::Reflect
     // Global Definitions
     ///////////////////////////////////////////////////////////////////////////
     {{#global}}
-    db.AddGlobal<{{& type}}>( "{{& qualifiedName}}",{{#isGetterAccessible}}
-        [](void)
-        {
-            return m::Variant { {{> getterBody}} };
-        },{{/isGetterAccessible}}{{^isGetterAccessible}}
-        nullptr,{{/isGetterAccessible}}{{#isSetterAccessible}}
-        [](const m::Argument &value)
-        {
-            {{> setterBody}}
-        },{{/isSetterAccessible}}{{^isSetterAccessible}}
+    db.AddGlobal<{{& type}}>( "{{& qualifiedName}}",
+        {{#isGetterAccessible}}{{> getterBody}},{{/isGetterAccessible}}{{^isGetterAccessible}}
+			nullptr,{{/isGetterAccessible}}{{#isSetterAccessible}}
+        {{> setterBody}},{{/isSetterAccessible}}{{^isSetterAccessible}}
         nullptr,{{/isSetterAccessible}}
         {
             {{> metaDataInitializerList}}
@@ -114,9 +108,9 @@ void meta_generated::DefineModuleFile{{targetName}}{{moduleFileName}}(m::Reflect
     ///////////////////////////////////////////////////////////////////////////
     {{#enum}}
     {
-        auto typeID = m::TypeInfo<{{& qualifiedName}}>::ID;
+        auto typeID = typeidof( {{& qualifiedName}} );
 
-        if (typeID != m::Type::Invalid && !m::TypeInfo<{{& qualifiedName}}>::Defined)
+        if (typeID != m::InvalidTypeID && !m::TypeInfo<{{& qualifiedName}}>::Defined)
         {
             auto &type = db.types[ typeID ];
 
@@ -142,9 +136,9 @@ void meta_generated::DefineModuleFile{{targetName}}{{moduleFileName}}(m::Reflect
      * {{& qualifiedName}}
      */
     {
-        auto typeID = m::TypeInfo<{{& qualifiedName}}>::ID;
+        auto typeID = typeidof( {{& qualifiedName}} );
 
-        if (typeID != m::Type::Invalid && !m::TypeInfo<{{& qualifiedName}}>::Defined)
+        if (typeID != m::InvalidTypeID && !m::TypeInfo<{{& qualifiedName}}>::Defined)
         {
             auto &type = db.types[ typeID ];
 
@@ -220,4 +214,4 @@ void meta_generated::DefineModuleFile{{targetName}}{{moduleFileName}}(m::Reflect
             m::TypeInfo<{{& qualifiedName}}>::Defined = true;
         }
     }{{/class}}
-}
+}

Source/CMake/FindLLVM.cmake

@@ -1,13 +1,22 @@
+# by default, only use the libclang static lib on MSVC
+if (NOT DEFINED LIBCLANG_USE_STATIC_LIBRARY)
+    if (MSVC)
+        set(LIBCLANG_USE_STATIC_LIBRARY YES)
+    else ()
+        set(LIBCLANG_USE_STATIC_LIBRARY NO)
+    endif ()
+endif ()
+
 set(LLVM_SEARCH_PATHS
     ${LLVM_ROOT}
     $ENV{LLVM_ROOT}
 )
 
-set(LIBCLANG_LIBRARY_NAME 
+set(LIBCLANG_STATIC_LIBRARY_NAME
     "libclang${CMAKE_STATIC_LIBRARY_SUFFIX}"
 )
 
-set(LIBCLANG_SHARED_LIBRARY_NAME 
+set(LIBCLANG_SHARED_LIBRARY_NAME
     "libclang${CMAKE_SHARED_LIBRARY_SUFFIX}"
 )
 
@@ -18,34 +27,41 @@ find_path(LLVM_INCLUDE_DIRS
     PATH_SUFFIXES "include"
 )
 
-# static library directory
-find_path(LLVM_LIBRARY_DIR
-    NAMES ${LIBCLANG_LIBRARY_NAME}
-    PATHS ${LLVM_SEARCH_PATHS}
-    PATH_SUFFIXES "lib"
-)
+if (LIBCLANG_USE_STATIC_LIBRARY)
+    # find static library directory
+    find_path(LLVM_STATIC_LIBRARY_DIR
+        NAMES ${LIBCLANG_LIBRARY_NAME}
+        PATHS ${LLVM_SEARCH_PATHS}
+        PATH_SUFFIXES "lib" "bin"
+    )
+endif ()
 
 # shared library directory
 find_path(LLVM_BINARY_DIR
     NAMES ${LIBCLANG_SHARED_LIBRARY_NAME}
     PATHS ${LLVM_SEARCH_PATHS}
-    PATH_SUFFIXES "bin"
+    PATH_SUFFIXES "bin" "lib"
 )
 
 # unable to find everything
-if (NOT LLVM_INCLUDE_DIRS OR 
-    NOT LLVM_LIBRARY_DIR OR
-    NOT LLVM_BINARY_DIR)
+if (NOT LLVM_INCLUDE_DIRS OR
+    NOT LLVM_BINARY_DIR OR
+    (NOT LLVM_LIBRARY_DIR AND LIBCLANG_USE_STATIC_LIBRARY))
     message(SEND_ERROR 
         "Unable to find LLVM installation. "
         "Make sure that \"LLVM_ROOT\" is set with the installation directory in either an environment variable or through the CMake GUI."
     )
 endif ()
 
-set(LLVM_LIBCLANG_LIBRARY 
-    "${LLVM_LIBRARY_DIR}/${LIBCLANG_LIBRARY_NAME}"
+set(LIBCLANG_SHARED_LIBRARY
+    "${LLVM_BINARY_DIR}/${LIBCLANG_SHARED_LIBRARY_NAME}"
 )
 
-set(LLVM_LIBCLANG_SHARED_LIBRARY 
-    "${LLVM_BINARY_DIR}/${LIBCLANG_SHARED_LIBRARY_NAME}"
-)
+if (LIBCLANG_USE_STATIC_LIBRARY)
+    set(LIBCLANG_LIBRARY
+        "${LLVM_LIBRARY_DIR}/${LIBCLANG_STATIC_LIBRARY_NAME}"
+    )
+else ()
+    # we can assume this is a unix system, in which case we link to the shared object file
+    set(LIBCLANG_LIBRARY ${LIBCLANG_SHARED_LIBRARY})
+endif ()

Source/CMake/MetaParser.cmake

@@ -39,6 +39,11 @@ function(meta_parser_prebuild)
         get_filename_component(BASE_NAME ${HEADER} NAME_WE)
         get_filename_component(EXTENSION ${HEADER} EXT)
 
+        # make sure the path is absolute
+        if (NOT IS_ABSOLUTE ${HEADER})
+            set(DIRECTORY_NAME "${PREBUILD_META_SOURCE_ROOT}/${DIRECTORY_NAME}")
+        endif ()
+
         # skip hpp files
         if (NOT "${EXTENSION}" STREQUAL ".hpp")
             file(RELATIVE_PATH RELATIVE 
@@ -137,7 +142,7 @@ function(meta_parser_build)
     add_custom_command(
         OUTPUT ${BUILD_META_GENERATED_FILES}
         DEPENDS ${BUILD_META_HEADER_FILES}
-        COMMAND call ${BUILD_META_PARSER_EXECUTABLE}
+        COMMAND ${BUILD_META_PARSER_EXECUTABLE}
         --target-name "${BUILD_META_TARGET}"
         --source-root "${BUILD_META_SOURCE_ROOT}"
         --in-source "${BUILD_META_SOURCE_ROOT}/${BUILD_META_SOURCE_FILE}"

Source/Common/Compiler.h

@@ -1,6 +1,14 @@
 #pragma once
 
-#if _MSC_VER && !__INTEL_COMPILER
+#if defined(__clang__)
+
+#define COMPILER_CLANG
+
+#elif defined(__GNUC__) || defined(__GNUG__)
+
+#define COMPILER_GNU
+
+#elif defined(_MSC_VER) && !__INTEL_COMPILER
 
 #define COMPILER_MSVC
 

Source/Parser/CMakeLists.txt

@@ -98,20 +98,24 @@ include_directories(../Common/Lib)
 # them in the solution explorer without them being added to the list of sources
 add_executable(MetaParser ${HEADER_FILES} ${SOURCE_FILES})
 
+link_directories(${LLVM_LIBRARY_DIR})
+
 # statically link with Boost & LibClang
-target_link_libraries(MetaParser ${Boost_LIBRARIES} ${LLVM_LIBCLANG_LIBRARY})
+target_link_libraries(MetaParser ${Boost_LIBRARIES} ${LIBCLANG_LIBRARY})
 
 set_precompiled_header(MetaParser Precompiled.h Precompiled.cpp)
 
 if (MSVC)
     # disable security warnings
     add_definitions(-D_CRT_SECURE_NO_WARNINGS=1)
 
-     # treat warnings as errors
-    target_compile_options(MetaParser PUBLIC /WX)
-
-    # multi process compilation
-    target_compile_options(MetaParser PUBLIC /MP)
+    target_compile_options(MetaRuntime 
+        PUBLIC
+        # treat warnings as errors
+        /WX 
+        # multi process compilation
+        /MP
+    )
 
 	# detect version of Visual Studio
 	if (MSVC10)
@@ -131,19 +135,29 @@ if (MSVC)
 
     # normalize slashes
     string(REPLACE "\\" "/" SYSTEM_INCLUDES "${SYSTEM_INCLUDES}")
+else ()
+    target_compile_options(MetaParser
+        PUBLIC -std=c++11
+    )
+
+    set(SYSTEM_INCLUDES "/usr/include/c++/${CMAKE_CXX_COMPILER_VERSION}")
+endif ()
 
+if (SYSTEM_INCLUDES)
     # visual studio seems to have issues with escape characters in post build commands
     set_property(TARGET MetaParser APPEND PROPERTY COMPILE_DEFINITIONS SYSTEM_INCLUDE_DIRECTORY="${SYSTEM_INCLUDES}")
 else ()
     message(FATAL_ERROR "System include directories not implemented for this compiler.")
 endif ()
 
-# copy shared libraries and resources on post build
+# copy resources on post build
 add_custom_command(TARGET MetaParser POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E copy_if_different
-        ${LLVM_LIBCLANG_SHARED_LIBRARY}
-        $<TARGET_FILE_DIR:MetaParser>
+    # mustache templates directory
 	COMMAND ${CMAKE_COMMAND} -E copy_directory
         "${CMAKE_CURRENT_LIST_DIR}/../../Resources"
         $<TARGET_FILE_DIR:MetaParser>
-)
+    # LibClang shared library
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different
+        ${LIBCLANG_SHARED_LIBRARY}
+        $<TARGET_FILE_DIR:MetaParser>
+)

Source/Parser/LanguageTypes/Class.cpp

@@ -104,27 +104,6 @@ Class::Class(const Cursor &cursor, const Namespace &currentNamespace)
     }
 }
 
-Class::~Class(void)
-{
-    for (auto *baseClass : m_baseClasses)
-        delete baseClass;
-
-    for (auto *constructor : m_constructors)
-        delete constructor;
-
-    for (auto *field : m_fields)
-        delete field;
-
-    for (auto *staticField : m_staticFields)
-        delete staticField;
-
-    for (auto *method : m_methods)
-        delete method;
-
-    for (auto *staticMethod : m_staticMethods)
-        delete staticMethod;
-}
-
 bool Class::ShouldCompile(void) const
 {
     return isAccessible( ) && !isNativeType( m_qualifiedName );
@@ -152,7 +131,7 @@ TemplateData Class::CompileTemplate(const ReflectionParser *context) const
 
         int i = 0;
 
-        for (auto *baseClass : m_baseClasses)
+        for (auto &baseClass : m_baseClasses)
         {
             // ignore native types
             if (isNativeType( baseClass->name ))
@@ -181,12 +160,11 @@ TemplateData Class::CompileTemplate(const ReflectionParser *context) const
     {
         TemplateData constructors { TemplateData::Type::List };
 
-        for (auto *ctor : m_constructors)
+        for (auto &ctor : m_constructors)
         {
             if (ctor->ShouldCompile( ))
                 constructors << ctor->CompileTemplate( context );
         }
-            
 
         data[ "constructor" ] = constructors;
         data[ "dynamicConstructor" ] = constructors;
@@ -196,7 +174,7 @@ TemplateData Class::CompileTemplate(const ReflectionParser *context) const
     {
         TemplateData fields { TemplateData::Type::List };
 
-        for (auto *field : m_fields)
+        for (auto &field : m_fields)
         {
             if (field->ShouldCompile( ))
                 fields << field->CompileTemplate( context );
@@ -209,7 +187,7 @@ TemplateData Class::CompileTemplate(const ReflectionParser *context) const
     {
         TemplateData staticFields { TemplateData::Type::List };
 
-        for (auto *staticField : m_staticFields)
+        for (auto &staticField : m_staticFields)
         {
             if (staticField->ShouldCompile( ))
                 staticFields << staticField->CompileTemplate( context );
@@ -222,7 +200,7 @@ TemplateData Class::CompileTemplate(const ReflectionParser *context) const
     {
         TemplateData methods { TemplateData::Type::List };
 
-        for (auto *method : m_methods)
+        for (auto &method : m_methods)
         {
             if (method->ShouldCompile( ))
                 methods << method->CompileTemplate( context );
@@ -235,7 +213,7 @@ TemplateData Class::CompileTemplate(const ReflectionParser *context) const
     {
         TemplateData staticMethods { TemplateData::Type::List };
 
-        for (auto *staticMethod : m_staticMethods)
+        for (auto &staticMethod : m_staticMethods)
         {
             if (staticMethod->ShouldCompile( ))
                 staticMethods << staticMethod->CompileTemplate( context );