diff --git a/KDevelop-PG-QtConfig.cmake.in b/KDevelop-PG-QtConfig.cmake.in
index 4f39441..7211612 100644
--- a/KDevelop-PG-QtConfig.cmake.in
+++ b/KDevelop-PG-QtConfig.cmake.in
@@ -1,194 +1,197 @@
 #
 # Find the KDevelop Parser Generator and set various variables accordingly
 #
 # KDEVPGQT_DIR and can be set to adjust the directory where the kdevelop-pg-qt
 # headers and executable are searched. This should point to the installation
 # directory of kdevelop-pg-qt
 #
 # KDEVPGQT_FOUND - set to TRUE if KDevelop-PG was found FALSE otherwise
 #
 # KDEVPGQT_INCLUDE_DIR         - include dir of kdevelop-pg, for example /usr/include/kdevelop-pg
 #                              can be set by the user to select different include dirs
 # KDEVPGQT_EXECUTABLE          - the absolute path to the kdevelop-pg executable
 #
 # KDEVPGQT_GENERATE(SRC_FILE_VAR OUTPUT language
 #                     [NAMESPACE ns] [DEBUG_VISITOR] [TOKEN_TEXT] [DUMP_INFO]
 #                     GRAMMARFILE ADDITIONALDEPS)
 #     macro to add a custom target for the generation of the parser
 #     OUTPUT will be given to kdev-pg as the --output parameter and thus sets the filename prefix
 #     NAMESPACE can be given to choose a namespace different from the OUTPUT value
 #     DEBUG_VISITOR will run kdevelop-pg with the --debug-visitor argument to generate a simple
 #                   visitor that will print debug messages
 #     TOKEN_TEXT will run kdevelop-pg with the --token-text argument to generate a simple
 #                function that returns a readable name of a token
 #     DUMP_INFO will tell kdevelop-pg to dump extra information about symbols, terminals and rules
 #               into files in the binary dir
 #     Note: The macro only exists when KDEVPG was found
 #
 # Copyright (c) 2007 Andreas Pakulat <apaku@gmx.de>
 # Redistribution and use is allowed according to the terms of the BSD license.
 # For details see the accompanying COPYING-CMAKE-SCRIPTS file.
 
 @PACKAGE_INIT@
 
 if( KDEVPGQT_INCLUDE_DIR AND KDEVPGQT_EXECUTABLE )
     set(KDevelop-PG-Qt_FIND_QUIETLY TRUE)
 endif()
 
 if(WIN32)
     file(TO_CMAKE_PATH "$ENV{PROGRAMFILES}" _progFiles)
     set(_KDEVPGQT_DIR ${_progFiles}/kdevelop-pg-qt)
 endif()
 
 if( NOT KDEVPGQT_DIR )
     find_path( _kdevpgqtIncDir kdevelop-pg-qt/kdev-pg-token-stream.h
         PATHS
         ${CMAKE_INSTALL_PREFIX}/include
         ${_KDEVPGQT_DIR}/include
     )
     if( _kdevpgqtIncDir )
         set(KDEVPGQT_INCLUDE_DIR ${_kdevpgqtIncDir}/kdevelop-pg-qt)
     endif()
     find_program( KDEVPGQT_EXECUTABLE NAMES kdev-pg-qt
         PATHS
         ${CMAKE_INSTALL_PREFIX}/bin
         ${_KDEVPGQT_DIR}/bin
     )
 
     set(KDEVPGQT_INCLUDE_DIR ${KDEVPGQT_INCLUDE_DIR} CACHE PATH "kdevelop-pg-qt include directory containing the headers")
     set( KDEVPGQT_EXECUTABLE ${KDEVPGQT_EXECUTABLE} CACHE PATH "executable for kdevelop-pg-qt" )
 else()
     find_path( _kdevpgqtIncDir kdevelop-pg-qt/kdev-pg-token-stream.h
         PATHS
         ${CMAKE_INSTALL_PREFIX}/include
         ${_KDEVPGQT_DIR}/include
         ${KDEVPGQT_DIR}/include
     )
     set(KDEVPGQT_INCLUDE_DIR ${_kdevpgIncDir}/kdevelop-pg-qt)
     find_program( KDEVPGQT_EXECUTABLE NAMES kdev-pg-qt
         PATHS
         ${CMAKE_INSTALL_PREFIX}/bin
         ${_KDEVPGQT_DIR}/bin
         ${KDEVPGQT_DIR}/bin
     )
     set(KDEVPGQT_INCLUDE_DIR ${KDEVPGQT_INCLUDE_DIR} CACHE PATH "kdevelop-pg-qt include directory containing the headers")
     set( KDEVPGQT_EXECUTABLE ${KDEVPGQT_EXECUTABLE} CACHE PATH "executable for kdevelop-pg-qt" )
 endif()
 if( KDEVPGQT_INCLUDE_DIR
  AND KDEVPGQT_EXECUTABLE)
 
     if( NOT KDevelop-PG-Qt_FIND_QUIETLY )
         message(STATUS "Found KDevelop-PG-Qt")
         message(STATUS "  Using kdevelop-pg-qt include dir: ${KDEVPGQT_INCLUDE_DIR}")
         message(STATUS "  Using kdevelop-pg-qt executable: ${KDEVPGQT_EXECUTABLE}")
     endif()
 
 # if all modules found
     set(KDEVPGQT_FOUND TRUE)
 
     macro(KDEVPGQT_GENERATE _srcVar _language )
         set(_outputList
             "${CMAKE_CURRENT_BINARY_DIR}/${_language}tokentype.h")
         set(_depList ${ARGN})
         set(_astList
             "${CMAKE_CURRENT_BINARY_DIR}/${_language}ast.h")
         set(_parserList
             "${CMAKE_CURRENT_BINARY_DIR}/${_language}parser.h"
             "${CMAKE_CURRENT_BINARY_DIR}/${_language}parser.cpp"
             "${CMAKE_CURRENT_BINARY_DIR}/${_language}visitor.h"
             "${CMAKE_CURRENT_BINARY_DIR}/${_language}visitor.cpp"
             "${CMAKE_CURRENT_BINARY_DIR}/${_language}defaultvisitor.h"
             "${CMAKE_CURRENT_BINARY_DIR}/${_language}defaultvisitor.cpp")
         set(_lexerList)
         set(_dbgVisit)
         set(_namespace)
         set(_tokenText)
         set(_dumpInfo)
         if(CMAKE_COMPILER_IS_GNUCC)
           set(_beautifulCode)
         else()
           set(_beautifulCode --compatible-error-aware-code)
         endif()
         set(_conflicts)
         while(1)
         list(GET _depList 0 _arg)
         if( ${_arg} STREQUAL "NAMESPACE" )
             list(GET _depList 1 _namespace)
             list(REMOVE_AT _depList 0 1)
             set(_namespace --namespace=${_namespace})
         elseif( ${_arg} STREQUAL "DEBUG_VISITOR" )
             list(REMOVE_AT _depList 0)
             set(_dbgVisit "--debug-visitor")
             set(_outputList ${_outputList}
                 "${CMAKE_CURRENT_BINARY_DIR}/${_language}debugvisitor.h"
             )
         elseif( ${_arg} STREQUAL "TOKEN_TEXT" )
             list(REMOVE_AT _depList 0)
             set(_tokenText "--token-text")
             set(_outputList ${_outputList}
                 "${CMAKE_CURRENT_BINARY_DIR}/${_language}tokentext.h"
             )
         elseif( ${_arg} STREQUAL "DUMP_INFO" )
             list(REMOVE_AT _depList 0)
             set(_dumpInfo --terminals --symbols --rules)
             set(_outputList ${_outputList}
                 "${CMAKE_CURRENT_BINARY_DIR}/kdev-pg-terminals"
                 "${CMAKE_CURRENT_BINARY_DIR}/kdev-pg-symbols"
                 "${CMAKE_CURRENT_BINARY_DIR}/kdev-pg-rules"
             )
         elseif( ${_arg} STREQUAL "BEAUTIFUL_CODE" )
             list(REMOVE_AT _depList 0)
             set(_beautifulCode --beautiful-code)
         elseif( ${_arg} STREQUAL "STRICT_CONFLICTS" )
             list(REMOVE_AT _depList 0)
             set(_conflicts --strict-conflicts)
         elseif( ${_arg} STREQUAL "IGNORE_CONFLICTS" )
             list(REMOVE_AT _depList 0)
             set(_conflicts --ignore-conflicts)
         elseif( ${_arg} STREQUAL "GENERATE_LEXER" )
           list(REMOVE_AT _depList 0)
           set(_lexerList
               "${CMAKE_CURRENT_BINARY_DIR}/${_language}lexer.h"
               "${CMAKE_CURRENT_BINARY_DIR}/${_language}lexer.cpp")
         else()
             break()
         endif()
         endwhile(1)
         
         set(_outputList ${_outputList} ${_lexerList} ${_astList} ${_parserList})
         
         list(GET _depList 0 _grammarFile)
         list(REMOVE_AT _depList 0)
         if(NOT _grammarFile)
             message(ERROR "No grammar file given to KDEVPGQT_GENERATE macro")
         endif()
         add_custom_command(
             OUTPUT
                     ${_outputList}
             MAIN_DEPENDENCY "${_grammarFile}"
             DEPENDS ${_depList} ${KDEVPGQT_EXECUTABLE}
             COMMAND ${KDEVPGQT_EXECUTABLE}
             ARGS    --output=${_language} ${_namespace}
                     ${_dbgVisit} ${_dumpInfo} ${_beautifulCode} ${_conflicts} "${_grammarFile}"
             WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
         )
-        set_source_files_properties("${_outputList}" GENERATED)
+        set_source_files_properties(${_outputList} PROPERTIES
+            GENERATED TRUE
+            SKIP_AUTOMOC ON
+        )
         set( ${_srcVar}
               "${_outputList}"
            )
     endmacro(KDEVPGQT_GENERATE)
 
 
 else( KDEVPGQT_INCLUDE_DIR
  AND KDEVPGQT_EXECUTABLE)
 
     if( KDevelop-PG-Qt_FIND_REQUIRED)
         message(FATAL_ERROR "Couldn't find KDevelop-PG-Qt.")
     else()
         message(STATUS "Couldn't find KDevelop-PG-Qt.")
     endif()
     message(STATUS "You can set KDEVPGQT_DIR to help cmake find KDevelop-PG-Qt")
     set(KDEVPGQT_FOUND FALSE)
 
 endif( KDEVPGQT_INCLUDE_DIR
  AND KDEVPGQT_EXECUTABLE)
diff --git a/examples/cc/CMakeLists.txt b/examples/cc/CMakeLists.txt
index 1853f97..822f487 100644
--- a/examples/cc/CMakeLists.txt
+++ b/examples/cc/CMakeLists.txt
@@ -1,60 +1,62 @@
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 ADD_DEFINITIONS(-DQT_NO_STL)
 
 # autogenerate the lexer and the parser
 
 SET(parser_srcs)
 
 FIND_PROGRAM(FLEX_EXECUTABLE
     NAMES flex
     PATHS /usr/bin
     DOC "Flex executable")
 
 
 SET(KDEVPGQT_EXECUTABLE ${CMAKE_CURRENT_BINARY_DIR}/../../kdev-pg/kdev-pg-qt)
 SET(KDEVPGQT_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/../../../include)
 include(${CMAKE_CURRENT_BINARY_DIR}/../../KDevelop-PG-QtConfig.cmake)
 kdevpgqt_generate(parser_srcs cc NAMESPACE cc
     "${CMAKE_CURRENT_SOURCE_DIR}/cc.g"
 )
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
 IF(FLEX_EXECUTABLE)
     # Add command to generate the lexer.
     ADD_CUSTOM_COMMAND(
         OUTPUT  "${CMAKE_CURRENT_SOURCE_DIR}/cclexer.cpp"
         DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/cc.ll"
                 "${CMAKE_CURRENT_SOURCE_DIR}/FlexLexer.h"
                 "${CMAKE_CURRENT_BINARY_DIR}/ccparser.h"
         COMMAND ${FLEX_EXECUTABLE}
         ARGS    -o"cclexer.cpp"
                 "cc.ll"
         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
         )
 
     SET(parser_srcs ${CMAKE_CURRENT_SOURCE_DIR}/cclexer.cpp ${parser_srcs})
 
     SET_SOURCE_FILES_PROPERTIES(
         ${CMAKE_CURRENT_SOURCE_DIR}/cclexer.cpp
-        GENERATED
+        PROPERTIES
+            GENERATED TUE
+            SKIP_AUTOMOC ON
         )
 ELSE(FLEX_EXECUTABLE)
     MESSAGE("--- Assuming existence of the generated lexer file cclexer.cpp")
     SET(parser_srcs ${CMAKE_CURRENT_SOURCE_DIR}/cclexer.cpp ${parser_srcs})
 ENDIF(FLEX_EXECUTABLE)
 
 
 SET(cc_parser_srcs
     ${parser_srcs}
     main.cpp
     dumptree.cpp
 )
 
 
 # add definitions, compiler switches, etc.
 ADD_DEFINITIONS(-Wall -O2)
 
 # tell CMake to generate the executable
 ADD_EXECUTABLE(cc-parser ${cc_parser_srcs})
 
 TARGET_LINK_LIBRARIES( cc-parser Qt5::Core)
diff --git a/examples/cool/CMakeLists.txt b/examples/cool/CMakeLists.txt
index 62475d9..672a0bf 100644
--- a/examples/cool/CMakeLists.txt
+++ b/examples/cool/CMakeLists.txt
@@ -1,56 +1,58 @@
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 REMOVE_DEFINITIONS(-DQT_NO_STL)
 ADD_DEFINITIONS(-DQT_STL)
 
 # autogenerate the lexer and the parser
 
 SET(parser_srcs)
 
 SET(KDEVPGQT_EXECUTABLE ${CMAKE_CURRENT_BINARY_DIR}/../../kdev-pg/kdev-pg-qt)
 SET(KDEVPGQT_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/../../../include)
 include(${CMAKE_CURRENT_BINARY_DIR}/../../KDevelop-PG-QtConfig.cmake)
 kdevpgqt_generate(parser_srcs cool NAMESPACE cool
     "${CMAKE_CURRENT_SOURCE_DIR}/cool.g"
 )
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
 
 IF(FLEX_EXECUTABLE)
     # Add command to generate the lexer.
     ADD_CUSTOM_COMMAND(
         OUTPUT  "${CMAKE_CURRENT_SOURCE_DIR}/cool_lexer.cpp"
         DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/cool_lexer.ll"
                 "${CMAKE_CURRENT_SOURCE_DIR}/cool_lexer.h"
                 "${CMAKE_CURRENT_BINARY_DIR}/coolparser.h"
         COMMAND ${FLEX_EXECUTABLE}
         ARGS    -o"cool_lexer.cpp"
                 "cool_lexer.ll"
         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
         )
 
     SET(parser_srcs ${CMAKE_CURRENT_SOURCE_DIR}/cool_lexer.cpp ${parser_srcs})
 
     SET_SOURCE_FILES_PROPERTIES(
         ${CMAKE_CURRENT_SOURCE_DIR}/cool_lexer.cpp
-        GENERATED
+        PROPERTIES
+            GENERATED TRUE
+            SKIP_AUTOMOC ON
         )
 ELSE(FLEX_EXECUTABLE)
     MESSAGE("--- Assuming existence of the generated lexer file cool_lexer.cpp")
     SET(parser_srcs ${CMAKE_CURRENT_SOURCE_DIR}/cool_lexer.cpp ${parser_srcs})
 ENDIF(FLEX_EXECUTABLE)
 
 
 SET(assembled_parser_srcs
     ${parser_srcs}
     decoder.cpp
     cool_io.cpp
 )
 
 
 # add definitions, compiler switches, etc.
 ADD_DEFINITIONS(-Wall -O2)
 
 # tell CMake to generate the executable
 ADD_EXECUTABLE(cool-parser ${assembled_parser_srcs} main.cpp)
 
 TARGET_LINK_LIBRARIES( cool-parser Qt5::Core)
diff --git a/kdev-pg/CMakeLists.txt b/kdev-pg/CMakeLists.txt
index b6c85ba..0c9249c 100644
--- a/kdev-pg/CMakeLists.txt
+++ b/kdev-pg/CMakeLists.txt
@@ -1,101 +1,105 @@
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 REMOVE_DEFINITIONS(-DQT_NO_STL)
 ADD_DEFINITIONS(-DQT_STL)
 
 QT5_ADD_RESOURCES(kdevpg_rcc_srcs ../unidata.qrc)
 kde_enable_exceptions()
 
 SET(kdevpg_srcs
     ASBeautifier.cpp
     ASFormatter.cpp
     ASResource.cpp
     ASEnhancer.cpp
     kdev-pg.cpp
     kdev-pg-visitor.cpp
     kdev-pg-default-visitor.cpp
     kdev-pg-pretty-printer.cpp
     kdev-pg-global.cpp
     kdev-pg-code-gen.cpp
     kdev-pg-ast-gen.cpp
     kdev-pg-visitor-gen.cpp
     kdev-pg-visitor-bits-gen.cpp
     kdev-pg-default-visitor-gen.cpp
     kdev-pg-default-visitor-bits-gen.cpp
     kdev-pg-serialize-visitor-gen.cpp
     kdev-pg-debug-visitor-gen.cpp
     kdev-pg-new-visitor-gen.cpp
     kdev-pg-new-visitor-bits-gen.cpp
     kdev-pg-token-type-gen.cpp
     kdev-pg-beautifier.cpp
     kdev-pg-checker.cpp
     kdev-pg-inline-checker.cpp
     kdev-pg-main.cpp
     kdev-pg-generate.cpp
     kdev-pg-first.cpp
     kdev-pg-follow.cpp
     kdev-pg-bnf-visitor.cpp
     kdev-pg-clone-tree.cpp
     kdev-pg-regexp.cpp
     kdev-pg-unicode-loader.cpp)
 
 
 # Custom support for flex/bison
 IF(BISON_EXECUTABLE)
     # Add command to run the parser.
     ADD_CUSTOM_COMMAND(
         OUTPUT  "${CMAKE_CURRENT_BINARY_DIR}/kdev-pg-parser.cc"
                 "${CMAKE_CURRENT_BINARY_DIR}/kdev-pg-parser.hh"
         DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/kdev-pg-parser.yy"
         COMMAND ${BISON_EXECUTABLE}
         ARGS    -o "${CMAKE_CURRENT_BINARY_DIR}/kdev-pg-parser.cc"
                 -d "${CMAKE_CURRENT_SOURCE_DIR}/kdev-pg-parser.yy"
         )
 
     SET(parser_src ${CMAKE_CURRENT_BINARY_DIR}/kdev-pg-parser.cc)
     SET_SOURCE_FILES_PROPERTIES(
         ${CMAKE_CURRENT_BINARY_DIR}/kdev-pg-parser.cc
         ${CMAKE_CURRENT_BINARY_DIR}/kdev-pg-parser.hh
-        GENERATED
+        PROPERTIES
+            GENERATED TRUE
+            SKIP_AUTOMOC ON
         )
     SET(OPTIONAL_PARSER_HEADER_DEPENDENCY "${CMAKE_CURRENT_BINARY_DIR}/kdev-pg-parser.hh")
 ELSE(BISON_EXECUTABLE)
     MESSAGE("'bison' was not found!")
     MESSAGE("Assuming existence of the generated parser files kdev-pg-parser.[hh,cc]")
     SET(parser_src ${CMAKE_CURRENT_SOURCE_DIR}/kdev-pg-parser.cc)
     SET(OPTIONAL_PARSER_HEADER_DEPENDENCY "")
 ENDIF(BISON_EXECUTABLE)
 
 IF(FLEX_EXECUTABLE)
     # Add command to run the lexer.
     ADD_CUSTOM_COMMAND(
         OUTPUT  "${CMAKE_CURRENT_BINARY_DIR}/kdev-pg-lexer.cc"
         DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/kdev-pg-lexer.ll"
                  ${OPTIONAL_PARSER_HEADER_DEPENDENCY}
         COMMAND ${FLEX_EXECUTABLE}
         ARGS    --yymore --nounistd -o "${CMAKE_CURRENT_BINARY_DIR}/kdev-pg-lexer.cc"
                 "${CMAKE_CURRENT_SOURCE_DIR}/kdev-pg-lexer.ll"
         )
 
     SET(lexer_src ${CMAKE_CURRENT_BINARY_DIR}/kdev-pg-lexer.cc)
     SET_SOURCE_FILES_PROPERTIES(
         ${CMAKE_CURRENT_BINARY_DIR}/kdev-pg-lexer.cc
-        GENERATED
+        PROPERTIES
+            GENERATED TRUE
+            SKIP_AUTOMOC ON
         )
 ELSE(FLEX_EXECUTABLE)
     MESSAGE("'flex' was not found!")
     MESSAGE("Assuming existence of the generated lexer file kdev-pg-lexer.cc")
     SET(lexer_src ${CMAKE_CURRENT_SOURCE_DIR}/kdev-pg-lexer.cc)
 ENDIF(FLEX_EXECUTABLE)
 set_source_files_properties(${lexer_src} PROPERTIES COMPILE_FLAGS "-DYY_NO_INPUT -DYY_NO_UNPUT")
 
 
 # tell CMake to generate the executable
 ADD_EXECUTABLE(kdev-pg-qt ${parser_src} ${lexer_src} ${kdevpg_srcs} ${kdevpg_rcc_srcs})
 ecm_mark_nongui_executable(kdev-pg-qt)
 TARGET_LINK_LIBRARIES( kdev-pg-qt Qt5::Core)
 INSTALL(TARGETS kdev-pg-qt DESTINATION bin )
 
 # in order to generate only the parser, call "make parser"
 ADD_CUSTOM_TARGET(parser echo "Generating the parser"
     DEPENDS ${parser_src} ${lexer_src}
     )