muntyan / moo / changeset / 1c0332776519

muntyan / moo (http://mooedit.sourceforget.net/)

Main medit repository

Clone this repository (size: 14.5 MB): HTTPS / SSH

$ hg clone http://bitbucket.org/muntyan/moo/

$ hg clone ssh://hg@bitbucket.org/muntyan/moo/

commit 3913:	1c0332776519
parent 3912:	0198cca85572
branch:	default

Fixed line endings

Yevgen Muntyan
8 weeks ago

Changed (Δ6.3 KB):

raw changeset »

CMakeLists.txt (64 lines added, 64 lines removed)

cmake/dist.cmake (101 lines added, 101 lines removed)

cmake/gtk.cmake (65 lines added, 65 lines removed)

cmake/modules/FindMooCmake.cmake (365 lines added, 365 lines removed)

cmake/modules/FindMooCmakeUtils.cmake (31 lines added, 31 lines removed)

cmake/modules/FindMooCompilers.cmake (328 lines added, 328 lines removed)

cmake/modules/FindMooI18n.cmake (29 lines added, 29 lines removed)

cmake/modules/FindMooLibXml2.cmake (11 lines added, 11 lines removed)

cmake/moo-libs.cmake (93 lines added, 93 lines removed)

cmake/moo.cmake (169 lines added, 169 lines removed)

config-dirs.h.in (11 lines added, 11 lines removed)

config.cmake (134 lines added, 134 lines removed)

doc/CMakeLists.txt (50 lines added, 50 lines removed)

doc/help-sections.h (33 lines added, 33 lines removed)

doc/help.html (1540 lines added, 1540 lines removed)

doc/help/regex-search.html (44 lines added, 44 lines removed)

doc/help/regex.html (43 lines added, 43 lines removed)

doc/makedocs.cmake (61 lines added, 61 lines removed)

doc/man-medit.t2t (107 lines added, 107 lines removed)

doc/medit.t2t (50 lines added, 50 lines removed)

doc/regex.t2t (16 lines added, 16 lines removed)

medit/CMakeLists.txt (27 lines added, 27 lines removed)

medit/data/encodings/GB2312 (1 lines added, 1 lines removed)

moo/CMakeLists.txt (98 lines added, 98 lines removed)

moo/gendef.py (324 lines added, 324 lines removed)

moo/gendummy.cmake (6 lines added, 6 lines removed)

moo/genenums.py (143 lines added, 143 lines removed)

moo/genmarshal.cmake (19 lines added, 19 lines removed)

moo/glade2c.cmake.in (16 lines added, 16 lines removed)

moo/marshals.list (60 lines added, 60 lines removed)

moo/moo-config.h (63 lines added, 63 lines removed)

moo/moo-dll.c (11 lines added, 11 lines removed)

moo/mooapp/CMakeLists.cmake (31 lines added, 31 lines removed)

moo/mooapp/smclient/CMakeLists.cmake (19 lines added, 19 lines removed)

moo/mooedit/CMakeLists.cmake (130 lines added, 130 lines removed)

moo/mooedit/gtksourceview/CMakeLists.cmake (50 lines added, 50 lines removed)

moo/mooedit/gtksourceview/mangle.py (77 lines added, 77 lines removed)

moo/mooedit/langs/CMakeLists.cmake (92 lines added, 92 lines removed)

moo/mooedit/mooedit-enums-in.py (73 lines added, 73 lines removed)

moo/moofileview/CMakeLists.cmake (46 lines added, 46 lines removed)

moo/moolua/CMakeLists.cmake (23 lines added, 23 lines removed)

moo/mooutils/CMakeLists.cmake (228 lines added, 228 lines removed)

moo/mooutils/genpixbufcsource.cmake.in (14 lines added, 14 lines removed)

moo/mooutils/moocpp-cont.h (633 lines added, 633 lines removed)

moo/mooutils/moocpp-exc.h (100 lines added, 100 lines removed)

moo/mooutils/moocpp-gobject.cpp (105 lines added, 105 lines removed)

moo/mooutils/moocpp-gobject.h (221 lines added, 221 lines removed)

moo/mooutils/moocpp-gtk.h (149 lines added, 149 lines removed)

moo/mooutils/moocpp-macros.h (98 lines added, 98 lines removed)

moo/mooutils/moocpp-refptr.h (240 lines added, 240 lines removed)

Up to file-list CMakeLists.txt:

 CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 PROJECT(MOO)
 SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)
 FIND_PACKAGE(MooCmake)
 SET(MOO_VERSION 0.9.5)
 SET(MOO_PACKAGE_NAME moo)
 SET(MOO_EMAIL "emuntyan@sourceforge.net")
 SET(MOO_COPYRIGHT "2004-2009 Yevgen Muntyan <${MOO_EMAIL}>")
 SET(PACKAGE_BUGREPORT ${MOO_EMAIL})
 SET(MOO_PACKAGE_VENDOR ${MOO_EMAIL})
 MOO_OPTION(MOO_BUILD_SHARED_LIB ${MOO_OS_WIN32} "Build shared library")
 MOO_OPTION(MOO_BUILD_CTAGS ${MOO_OS_UNIX} "Build Ctags plugin" HIDDEN ${MOO_OS_WIN32} HEADER TRUE)
 MOO_OPTION(MOO_ENABLE_PROJECT FALSE "Build project plugin" HIDDEN TRUE)
 MOO_OPTION(MOO_ENABLE_UNIT_TESTS FALSE "Build unit tests" DEFINE TRUE)
 MOO_OPTION(MOO_ENABLE_GENERATED_FILES ${MOO_OS_UNIX} "Run gtk-update-icon-cache on install")
 MOO_OPTION(MOO_BROKEN_GTK_THEME FALSE "Work around bugs in gtk theme" HEADER TRUE)
 INCLUDE(cmake/moo.cmake)
 INCLUDE(cmake/dist.cmake)
 INCLUDE(cmake/gtk.cmake)
 MOO_DEFINE_VERSIONS(MOO ${MOO_VERSION})
 SET(MOO_MODULE_MAJOR_VERSION 1)
 SET(MOO_MODULE_MINOR_VERSION 0)
 SET(MOO_MODULE_VERSION \"${MOO_MODULE_MAJOR_VERSION}.${MOO_MODULE_MINOR_VERSION}\")
 ADD_DEFINITIONS(-DHAVE_CONFIG_H)
 ADD_DEFINITIONS(-DGETTEXT_PACKAGE=\"moo\")
 ADD_DEFINITIONS(-DG_LOG_DOMAIN=\"Moo\")
 INCLUDE_DIRECTORIES(${MOO_BINARY_DIR} ${MOO_BINARY_DIR}/moo ${MOO_SOURCE_DIR}/moo)
 ADD_DEFINITIONS(${GTK_CFLAGS} ${GTK_CFLAGS_OTHER})
 INCLUDE(config.cmake)
 ADD_SUBDIRECTORY(doc)
 ADD_SUBDIRECTORY(moo)
 ADD_SUBDIRECTORY(plugins)
 ADD_SUBDIRECTORY(medit)
 MOO_ADD_MSG_CATALOG(moo po)
 MOO_ADD_MSG_CATALOG(moo-gsv po-gsv)
 MOO_WRITE_CONFIG_H(config.h.in config.h @ONLY)
 CONFIGURE_FILE(config-dirs.h.in config-dirs.h @ONLY)
 IF(WIN32)
   GET_FILENAME_COMPONENT(_MOO_SOURCE_DIR ${MOO_SOURCE_DIR} ABSOLUTE)
   # TO_NATIVE_PATH damn it! Cmake is such a wonderful piece of language...
   STRING(REPLACE "/" "\\" _MOO_SOURCE_DIR "${_MOO_SOURCE_DIR}")
   GET_FILENAME_COMPONENT(_MOO_BINARY_DIR ${MOO_BINARY_DIR} ABSOLUTE)
   STRING(REPLACE "/" "\\" _MOO_BINARY_DIR "${_MOO_BINARY_DIR}")
   SET(_MOO_RUN_HOW "@")
   CONFIGURE_FILE(plat/win32/run-medit.in run-medit.bat)
   SET(_MOO_RUN_HOW "gdb --args ")
   CONFIGURE_FILE(plat/win32/run-medit.in run-medit-in-gdb.bat)
 ENDIF(WIN32)
 IF(NOT WIN32)
   INSTALL(PROGRAMS plat/unix/xdg-open plat/unix/xdg-email plat/unix/moo-open-html-help DESTINATION ${MOO_DATA_DIR}/scripts)
 ENDIF(NOT WIN32)
 CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 PROJECT(MOO)
 SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)
 FIND_PACKAGE(MooCmake)
 SET(MOO_VERSION 0.9.5)
 SET(MOO_PACKAGE_NAME moo)
 SET(MOO_EMAIL "emuntyan@sourceforge.net")
 SET(MOO_COPYRIGHT "2004-2009 Yevgen Muntyan <${MOO_EMAIL}>")
 SET(PACKAGE_BUGREPORT ${MOO_EMAIL})
 SET(MOO_PACKAGE_VENDOR ${MOO_EMAIL})
 MOO_OPTION(MOO_BUILD_SHARED_LIB ${MOO_OS_WIN32} "Build shared library")
 MOO_OPTION(MOO_BUILD_CTAGS ${MOO_OS_UNIX} "Build Ctags plugin" HIDDEN ${MOO_OS_WIN32} HEADER TRUE)
 MOO_OPTION(MOO_ENABLE_PROJECT FALSE "Build project plugin" HIDDEN TRUE)
 MOO_OPTION(MOO_ENABLE_UNIT_TESTS FALSE "Build unit tests" DEFINE TRUE)
 MOO_OPTION(MOO_ENABLE_GENERATED_FILES ${MOO_OS_UNIX} "Run gtk-update-icon-cache on install")
 MOO_OPTION(MOO_BROKEN_GTK_THEME FALSE "Work around bugs in gtk theme" HEADER TRUE)
 INCLUDE(cmake/moo.cmake)
 INCLUDE(cmake/dist.cmake)
 INCLUDE(cmake/gtk.cmake)
 MOO_DEFINE_VERSIONS(MOO ${MOO_VERSION})
 SET(MOO_MODULE_MAJOR_VERSION 1)
 SET(MOO_MODULE_MINOR_VERSION 0)
 SET(MOO_MODULE_VERSION \"${MOO_MODULE_MAJOR_VERSION}.${MOO_MODULE_MINOR_VERSION}\")
 ADD_DEFINITIONS(-DHAVE_CONFIG_H)
 ADD_DEFINITIONS(-DGETTEXT_PACKAGE=\"moo\")
 ADD_DEFINITIONS(-DG_LOG_DOMAIN=\"Moo\")
 INCLUDE_DIRECTORIES(${MOO_BINARY_DIR} ${MOO_BINARY_DIR}/moo ${MOO_SOURCE_DIR}/moo)
 ADD_DEFINITIONS(${GTK_CFLAGS} ${GTK_CFLAGS_OTHER})
 INCLUDE(config.cmake)
 ADD_SUBDIRECTORY(doc)
 ADD_SUBDIRECTORY(moo)
 ADD_SUBDIRECTORY(plugins)
 ADD_SUBDIRECTORY(medit)
 MOO_ADD_MSG_CATALOG(moo po)
 MOO_ADD_MSG_CATALOG(moo-gsv po-gsv)
 MOO_WRITE_CONFIG_H(config.h.in config.h @ONLY)
 CONFIGURE_FILE(config-dirs.h.in config-dirs.h @ONLY)
 IF(WIN32)
   GET_FILENAME_COMPONENT(_MOO_SOURCE_DIR ${MOO_SOURCE_DIR} ABSOLUTE)
   # TO_NATIVE_PATH damn it! Cmake is such a wonderful piece of language...
   STRING(REPLACE "/" "\\" _MOO_SOURCE_DIR "${_MOO_SOURCE_DIR}")
   GET_FILENAME_COMPONENT(_MOO_BINARY_DIR ${MOO_BINARY_DIR} ABSOLUTE)
   STRING(REPLACE "/" "\\" _MOO_BINARY_DIR "${_MOO_BINARY_DIR}")
   SET(_MOO_RUN_HOW "@")
   CONFIGURE_FILE(plat/win32/run-medit.in run-medit.bat)
   SET(_MOO_RUN_HOW "gdb --args ")
   CONFIGURE_FILE(plat/win32/run-medit.in run-medit-in-gdb.bat)
 ENDIF(WIN32)
 IF(NOT WIN32)
   INSTALL(PROGRAMS plat/unix/xdg-open plat/unix/xdg-email plat/unix/moo-open-html-help DESTINATION ${MOO_DATA_DIR}/scripts)
 ENDIF(NOT WIN32)

Up to file-list cmake/dist.cmake:

 FILE(WRITE ${CMAKE_BINARY_DIR}/cmake_uninstall.cmake.in
+"
 IF(NOT EXISTS \"\@CMAKE_CURRENT_BINARY_DIR\@/install_manifest.txt\")
   MESSAGE(FATAL_ERROR \"Cannot find install manifest: \\\"\@CMAKE_CURRENT_BINARY_DIR\@/install_manifest.txt\\\"\")
 ENDIF(NOT EXISTS \"\@CMAKE_CURRENT_BINARY_DIR\@/install_manifest.txt\")
 FILE(READ \"\@CMAKE_CURRENT_BINARY_DIR\@/install_manifest.txt\" files)
 STRING(REGEX REPLACE \"\\n\" \";\" files \"\${files}\")
 FOREACH(file \${files})
   MESSAGE(STATUS \"Uninstalling \\\"\$ENV{DESTDIR}\${file}\\\"\")
   IF(EXISTS \"\$ENV{DESTDIR}\${file}\")
     EXECUTE_PROCESS(
       COMMAND \"\@CMAKE_COMMAND\@\" -E remove \"\$ENV{DESTDIR}\${file}\"
       RESULT_VARIABLE rm_retval
+    )
     IF(NOT rm_retval EQUAL 0)
       MESSAGE(FATAL_ERROR \"Problem when removing \\\"\$ENV{DESTDIR}\${file}\\\": \${rm_retval}\")
     ENDIF(NOT rm_retval EQUAL 0)
   ENDIF(EXISTS \"\$ENV{DESTDIR}\${file}\")
 ENDFOREACH(file)
 ")
 CONFIGURE_FILE("${CMAKE_BINARY_DIR}/cmake_uninstall.cmake.in" "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake" @ONLY)
 ADD_CUSTOM_TARGET(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake")
 #############################################################################
+#
 # Installation dirs
+#
 IF(WIN32)
   IF("${CMAKE_INSTALL_PREFIX}" STREQUAL "C:/Program Files/MOO")
     SET(CMAKE_INSTALL_PREFIX "C:/Program Files/medit")
   ENDIF("${CMAKE_INSTALL_PREFIX}" STREQUAL "C:/Program Files/MOO")
 ENDIF(WIN32)
 SET(MOO_DATA_DIR ${DATADIR}/moo CACHE PATH "Where data files go")
 SET(MOO_LIB_DIR ${LIBDIR}/moo CACHE PATH "Where lib files go")
 SET(MOO_PLUGINS_DIR ${MOO_LIB_DIR}/plugins CACHE PATH "Where plugins go")
 SET(MOO_TEXT_LANG_FILES_DIR ${MOO_DATA_DIR}/language-specs CACHE PATH "Where lang files go")
 SET(MOO_DOC_DIR ${DATADIR}/doc/medit CACHE PATH "Where docs go")
 SET(MOO_HELP_DIR ${MOO_DOC_DIR}/help CACHE PATH "Where html help files go")
 FOREACH(name BINDIR DATADIR LIBDIR MOO_DATA_DIR MOO_LIB_DIR MOO_PLUGINS_DIR
              MOO_TEXT_LANG_FILES_DIR LOCALEDIR MOO_DOC_DIR MOO_HELP_DIR)
   SET(${name}_ABS ${CMAKE_INSTALL_PREFIX}/${${name}})
   MARK_AS_ADVANCED(${name})
 ENDFOREACH(name)
 IF(WIN32)
   SET(_MEDIT_LIBRARIES_DFLT)
   FOREACH(_moo_gtk_dir ${CMAKE_SOURCE_DIR}/../medit-bin-dist)
     IF(IS_DIRECTORY ${_moo_gtk_dir})
       SET(_MEDIT_LIBRARIES_DFLT ${_moo_gtk_dir})
       BREAK()
     ENDIF(IS_DIRECTORY ${_moo_gtk_dir})
   ENDFOREACH(_moo_gtk_dir)
   SET(MEDIT_LIBRARIES ${_MEDIT_LIBRARIES_DFLT} CACHE PATH "Where Gtk libraries are located")
   IF(MEDIT_LIBRARIES)
     INSTALL(DIRECTORY ${MEDIT_LIBRARIES}/ DESTINATION ".")
   ENDIF(MEDIT_LIBRARIES)
 ENDIF(WIN32)
 #############################################################################
+#
 # CPack
+#
 SET(CPACK_PACKAGE_NAME "medit")
 SET(CPACK_PACKAGE_VENDOR ${MOO_PACKAGE_VENDOR})
 STRING(REGEX REPLACE "([0-9]+)[.]([0-9]+)[.]([0-9]+)" "\\1" CPACK_PACKAGE_VERSION_MAJOR ${MOO_VERSION})
 STRING(REGEX REPLACE "([0-9]+)[.]([0-9]+)[.]([0-9]+)" "\\2" CPACK_PACKAGE_VERSION_MINOR ${MOO_VERSION})
 STRING(REGEX REPLACE "([0-9]+)[.]([0-9]+)[.]([0-9]+)" "\\3" CPACK_PACKAGE_VERSION_PATCH ${MOO_VERSION})
 SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "medit a text editor")
 SET(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${MOO_VERSION})
 SET(CPACK_RESOURCE_FILE_LICENSE ${CMAKE_SOURCE_DIR}/COPYING.GPL)
 SET(CPACK_RESOURCE_FILE_README ${CMAKE_SOURCE_DIR}/README)
 # SET(CPACK_GENERATOR)
 SET(CPACK_PACKAGE_EXECUTABLES medit medit)
 SET(CPACK_SOURCE_PACKAGE_FILE_NAME "medit-${MOO_VERSION}")
 SET(CPACK_SOURCE_IGNORE_FILES "/build/;/[.]hg;/[.]git")
 SET(CPACK_PACKAGE_INSTALL_DIRECTORY "medit")
 SET(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "medit")
 # SET(CPACK_NSIS_MUI_ICON)
 # SET(CPACK_NSIS_MUI_UNIICON)
 # SET(CPACK_PACKAGE_ICON ${CMAKE_SOURCE_DIR}/moo/mooutils/pixmaps/medit.ico)
 # SET(CPACK_NSIS_EXTRA_INSTALL_COMMANDS)
 # SET(CPACK_NSIS_EXTRA_UNINSTALL_COMMANDS)
 # SET(CPACK_NSIS_COMPRESSOR)
 SET(CPACK_NSIS_DISPLAY_NAME "medit ${MOO_VERSION}")
 SET(CPACK_NSIS_PACKAGE_NAME "medit")
 # SET(CPACK_NSIS_INSTALLED_ICON_NAME)
 SET(CPACK_NSIS_HELP_LINK "http://mooedit.sourceforge.net/")
 SET(CPACK_NSIS_URL_INFO_ABOUT "http://mooedit.sourceforge.net/")
 SET(CPACK_NSIS_CONTACT ${MOO_PACKAGE_VENDOR})
 # SET(CPACK_NSIS_CREATE_ICONS_EXTRA)
 # SET(CPACK_NSIS_DELETE_ICONS_EXTRA)
 INCLUDE(CPack)
 FILE(WRITE ${CMAKE_BINARY_DIR}/cmake_uninstall.cmake.in
+"
 IF(NOT EXISTS \"\@CMAKE_CURRENT_BINARY_DIR\@/install_manifest.txt\")
   MESSAGE(FATAL_ERROR \"Cannot find install manifest: \\\"\@CMAKE_CURRENT_BINARY_DIR\@/install_manifest.txt\\\"\")
 ENDIF(NOT EXISTS \"\@CMAKE_CURRENT_BINARY_DIR\@/install_manifest.txt\")
 FILE(READ \"\@CMAKE_CURRENT_BINARY_DIR\@/install_manifest.txt\" files)
 STRING(REGEX REPLACE \"\\n\" \";\" files \"\${files}\")
 FOREACH(file \${files})
   MESSAGE(STATUS \"Uninstalling \\\"\$ENV{DESTDIR}\${file}\\\"\")
   IF(EXISTS \"\$ENV{DESTDIR}\${file}\")
     EXECUTE_PROCESS(
       COMMAND \"\@CMAKE_COMMAND\@\" -E remove \"\$ENV{DESTDIR}\${file}\"
       RESULT_VARIABLE rm_retval
+    )
     IF(NOT rm_retval EQUAL 0)
       MESSAGE(FATAL_ERROR \"Problem when removing \\\"\$ENV{DESTDIR}\${file}\\\": \${rm_retval}\")
     ENDIF(NOT rm_retval EQUAL 0)
   ENDIF(EXISTS \"\$ENV{DESTDIR}\${file}\")
 ENDFOREACH(file)
 ")
 CONFIGURE_FILE("${CMAKE_BINARY_DIR}/cmake_uninstall.cmake.in" "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake" @ONLY)
 ADD_CUSTOM_TARGET(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake")
 #############################################################################
+#
 # Installation dirs
+#
 IF(WIN32)
   IF("${CMAKE_INSTALL_PREFIX}" STREQUAL "C:/Program Files/MOO")
     SET(CMAKE_INSTALL_PREFIX "C:/Program Files/medit")
   ENDIF("${CMAKE_INSTALL_PREFIX}" STREQUAL "C:/Program Files/MOO")
 ENDIF(WIN32)
 SET(MOO_DATA_DIR ${DATADIR}/moo CACHE PATH "Where data files go")
 SET(MOO_LIB_DIR ${LIBDIR}/moo CACHE PATH "Where lib files go")
 SET(MOO_PLUGINS_DIR ${MOO_LIB_DIR}/plugins CACHE PATH "Where plugins go")
 SET(MOO_TEXT_LANG_FILES_DIR ${MOO_DATA_DIR}/language-specs CACHE PATH "Where lang files go")
 SET(MOO_DOC_DIR ${DATADIR}/doc/medit CACHE PATH "Where docs go")
 SET(MOO_HELP_DIR ${MOO_DOC_DIR}/help CACHE PATH "Where html help files go")
 FOREACH(name BINDIR DATADIR LIBDIR MOO_DATA_DIR MOO_LIB_DIR MOO_PLUGINS_DIR
              MOO_TEXT_LANG_FILES_DIR LOCALEDIR MOO_DOC_DIR MOO_HELP_DIR)
   SET(${name}_ABS ${CMAKE_INSTALL_PREFIX}/${${name}})
   MARK_AS_ADVANCED(${name})
 ENDFOREACH(name)
 IF(WIN32)
   SET(_MEDIT_LIBRARIES_DFLT)
   FOREACH(_moo_gtk_dir ${CMAKE_SOURCE_DIR}/../medit-bin-dist)
     IF(IS_DIRECTORY ${_moo_gtk_dir})
       SET(_MEDIT_LIBRARIES_DFLT ${_moo_gtk_dir})
       BREAK()
     ENDIF(IS_DIRECTORY ${_moo_gtk_dir})
   ENDFOREACH(_moo_gtk_dir)
   SET(MEDIT_LIBRARIES ${_MEDIT_LIBRARIES_DFLT} CACHE PATH "Where Gtk libraries are located")
   IF(MEDIT_LIBRARIES)
     INSTALL(DIRECTORY ${MEDIT_LIBRARIES}/ DESTINATION ".")
   ENDIF(MEDIT_LIBRARIES)
 ENDIF(WIN32)
 #############################################################################
+#
 # CPack
+#
 SET(CPACK_PACKAGE_NAME "medit")
 SET(CPACK_PACKAGE_VENDOR ${MOO_PACKAGE_VENDOR})
 STRING(REGEX REPLACE "([0-9]+)[.]([0-9]+)[.]([0-9]+)" "\\1" CPACK_PACKAGE_VERSION_MAJOR ${MOO_VERSION})
 STRING(REGEX REPLACE "([0-9]+)[.]([0-9]+)[.]([0-9]+)" "\\2" CPACK_PACKAGE_VERSION_MINOR ${MOO_VERSION})
 STRING(REGEX REPLACE "([0-9]+)[.]([0-9]+)[.]([0-9]+)" "\\3" CPACK_PACKAGE_VERSION_PATCH ${MOO_VERSION})
 SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "medit a text editor")
 SET(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${MOO_VERSION})
 SET(CPACK_RESOURCE_FILE_LICENSE ${CMAKE_SOURCE_DIR}/COPYING.GPL)
 SET(CPACK_RESOURCE_FILE_README ${CMAKE_SOURCE_DIR}/README)
 # SET(CPACK_GENERATOR)
 SET(CPACK_PACKAGE_EXECUTABLES medit medit)
 SET(CPACK_SOURCE_PACKAGE_FILE_NAME "medit-${MOO_VERSION}")
 SET(CPACK_SOURCE_IGNORE_FILES "/build/;/[.]hg;/[.]git")
 SET(CPACK_PACKAGE_INSTALL_DIRECTORY "medit")
 SET(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "medit")
 # SET(CPACK_NSIS_MUI_ICON)
 # SET(CPACK_NSIS_MUI_UNIICON)
 # SET(CPACK_PACKAGE_ICON ${CMAKE_SOURCE_DIR}/moo/mooutils/pixmaps/medit.ico)
 # SET(CPACK_NSIS_EXTRA_INSTALL_COMMANDS)
 # SET(CPACK_NSIS_EXTRA_UNINSTALL_COMMANDS)
 # SET(CPACK_NSIS_COMPRESSOR)
 SET(CPACK_NSIS_DISPLAY_NAME "medit ${MOO_VERSION}")
 SET(CPACK_NSIS_PACKAGE_NAME "medit")
 # SET(CPACK_NSIS_INSTALLED_ICON_NAME)
 SET(CPACK_NSIS_HELP_LINK "http://mooedit.sourceforge.net/")
 SET(CPACK_NSIS_URL_INFO_ABOUT "http://mooedit.sourceforge.net/")
 SET(CPACK_NSIS_CONTACT ${MOO_PACKAGE_VENDOR})
 # SET(CPACK_NSIS_CREATE_ICONS_EXTRA)
 # SET(CPACK_NSIS_DELETE_ICONS_EXTRA)
 INCLUDE(CPack)

Up to file-list cmake/gtk.cmake:

 FIND_PACKAGE(PkgConfig)
 MACRO(_MOO_GET_PKG_CONFIG_VARIABLE cmakevar pkgconfigvar pkgname)
   MOO_EXEC_OR_DIE("pkg-config --variable=${pkgconfigvar} ${pkgname}"
     COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=${pkgconfigvar} ${pkgname}
     OUTPUT_VARIABLE ${cmakevar})
   STRING(STRIP ${${cmakevar}} ${cmakevar})
 ENDMACRO(_MOO_GET_PKG_CONFIG_VARIABLE)
 PKG_CHECK_MODULES(GLIB REQUIRED glib-2.0>=2.14)
 PKG_CHECK_MODULES(GTK REQUIRED gtk+-2.0 glib-2.0 gmodule-2.0 gthread-2.0 gobject-2.0)
 PKG_CHECK_MODULES(GIO gio-2.0)
 LIST(APPEND MOO_DEP_LIBS ${GTK_LIBRARIES})
 IF(GIO_FOUND)
   LIST(APPEND MOO_DEP_LIBS ${GIO_LIBRARIES})
 ENDIF(GIO_FOUND)
 MOO_ADD_COMPILE_DEFINITIONS(RELEASE -DG_DISABLE_CAST_CHECKS -DG_DISABLE_ASSERT)
 MOO_ADD_COMPILER_FLAGS(GCC WIN32 -mms-bitfields)
 # Do not use pkg-config because the official win32 binary
 # is distributed without pc files
 FIND_PACKAGE(MooLibXml2)
 IF(NOT LIBXML2_FOUND)
   MOO_ERROR("Libxml2 not found")
 ENDIF(NOT LIBXML2_FOUND)
 SET(MOO_USE_XML TRUE)
 MOO_DEFINE_H(MOO_USE_XML)
 LIST(APPEND MOO_DEP_LIBS ${LIBXML2_LIBRARIES})
 LINK_DIRECTORIES(${GTK_LIBRARY_DIRS} ${XML_LIBRARY_DIRS})
 _MOO_GET_PKG_CONFIG_VARIABLE(_moo_gdk_target target gdk-2.0)
 SET(GDK_X11 FALSE)
 SET(GDK_WIN32 FALSE)
 SET(GDK_QUARTZ FALSE)
 IF("${_moo_gdk_target}" STREQUAL "x11")
   SET(GDK_X11 TRUE)
 ELSEIF("${_moo_gdk_target}" STREQUAL "quartz")
   SET(GDK_QUARTZ TRUE)
 ELSEIF("${_moo_gdk_target}" STREQUAL "win32")
   SET(GDK_WIN32 TRUE)
 ENDIF("${_moo_gdk_target}" STREQUAL "x11")
 MACRO(_MOO_FIND_PROGRAM_OR_DIE varname progname pkgvar pkgname)
   _MOO_GET_PKG_CONFIG_VARIABLE(_moo_pkg_exec_prefix exec_prefix ${pkgname})
   IF(pkgvar)
     _MOO_GET_PKG_CONFIG_VARIABLE(_moo_pkg_prog ${pkgvar} ${pkgname})
     SET(_moo_prg_names "${_moo_pkg_prog}" ${progname})
   ELSE(pkgvar)
     SET(_moo_prg_names ${progname})
   ENDIF(pkgvar)
   FIND_PROGRAM(${varname}
     NAMES ${_moo_prg_names}
     PATHS "${_moo_pkg_exec_prefix}/bin"
     DOC "Path to ${progname} executable")
   MARK_AS_ADVANCED(${varname})
   IF(NOT ${varname})
     MOO_ERROR("Could not find ${progname} executable")
   ENDIF(NOT ${varname})
 ENDMACRO(_MOO_FIND_PROGRAM_OR_DIE)
 _MOO_FIND_PROGRAM_OR_DIE(GLIB_GENMARSHAL_EXECUTABLE glib-genmarshal glib_genmarshal glib-2.0)
-_MOO_FIND_PROGRAM_OR_DIE(GDK_PIXBUF_CSOURCE_EXECUTABLE gdk-pixbuf-csource "" gtk+-2.0)
+FIND_PACKAGE(PkgConfig)
 MACRO(_MOO_GET_PKG_CONFIG_VARIABLE cmakevar pkgconfigvar pkgname)
   MOO_EXEC_OR_DIE("pkg-config --variable=${pkgconfigvar} ${pkgname}"
     COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=${pkgconfigvar} ${pkgname}
     OUTPUT_VARIABLE ${cmakevar})
   STRING(STRIP ${${cmakevar}} ${cmakevar})
 ENDMACRO(_MOO_GET_PKG_CONFIG_VARIABLE)
 PKG_CHECK_MODULES(GLIB REQUIRED glib-2.0>=2.14)
 PKG_CHECK_MODULES(GTK REQUIRED gtk+-2.0 glib-2.0 gmodule-2.0 gthread-2.0 gobject-2.0)
 PKG_CHECK_MODULES(GIO gio-2.0)
 LIST(APPEND MOO_DEP_LIBS ${GTK_LIBRARIES})
 IF(GIO_FOUND)
   LIST(APPEND MOO_DEP_LIBS ${GIO_LIBRARIES})
 ENDIF(GIO_FOUND)
 MOO_ADD_COMPILE_DEFINITIONS(RELEASE -DG_DISABLE_CAST_CHECKS -DG_DISABLE_ASSERT)
 MOO_ADD_COMPILER_FLAGS(GCC WIN32 -mms-bitfields)
 # Do not use pkg-config because the official win32 binary
 # is distributed without pc files
 FIND_PACKAGE(MooLibXml2)
 IF(NOT LIBXML2_FOUND)
   MOO_ERROR("Libxml2 not found")
 ENDIF(NOT LIBXML2_FOUND)
 SET(MOO_USE_XML TRUE)
 MOO_DEFINE_H(MOO_USE_XML)
 LIST(APPEND MOO_DEP_LIBS ${LIBXML2_LIBRARIES})
 LINK_DIRECTORIES(${GTK_LIBRARY_DIRS} ${XML_LIBRARY_DIRS})
 _MOO_GET_PKG_CONFIG_VARIABLE(_moo_gdk_target target gdk-2.0)
 SET(GDK_X11 FALSE)
 SET(GDK_WIN32 FALSE)
 SET(GDK_QUARTZ FALSE)
 IF("${_moo_gdk_target}" STREQUAL "x11")
   SET(GDK_X11 TRUE)
 ELSEIF("${_moo_gdk_target}" STREQUAL "quartz")
   SET(GDK_QUARTZ TRUE)
 ELSEIF("${_moo_gdk_target}" STREQUAL "win32")
   SET(GDK_WIN32 TRUE)
 ENDIF("${_moo_gdk_target}" STREQUAL "x11")
 MACRO(_MOO_FIND_PROGRAM_OR_DIE varname progname pkgvar pkgname)
   _MOO_GET_PKG_CONFIG_VARIABLE(_moo_pkg_exec_prefix exec_prefix ${pkgname})
   IF(pkgvar)
     _MOO_GET_PKG_CONFIG_VARIABLE(_moo_pkg_prog ${pkgvar} ${pkgname})
     SET(_moo_prg_names "${_moo_pkg_prog}" ${progname})
   ELSE(pkgvar)
     SET(_moo_prg_names ${progname})
   ENDIF(pkgvar)
   FIND_PROGRAM(${varname}
     NAMES ${_moo_prg_names}
     PATHS "${_moo_pkg_exec_prefix}/bin"
     DOC "Path to ${progname} executable")
   MARK_AS_ADVANCED(${varname})
   IF(NOT ${varname})
     MOO_ERROR("Could not find ${progname} executable")
   ENDIF(NOT ${varname})
 ENDMACRO(_MOO_FIND_PROGRAM_OR_DIE)
 _MOO_FIND_PROGRAM_OR_DIE(GLIB_GENMARSHAL_EXECUTABLE glib-genmarshal glib_genmarshal glib-2.0)
 _MOO_FIND_PROGRAM_OR_DIE(GDK_PIXBUF_CSOURCE_EXECUTABLE gdk-pixbuf-csource "" gtk+-2.0)

Up to file-list cmake/modules/FindMooCmake.cmake:

 OPTION(MOO_DEV_MODE_CMAKE "Enable developer mode for cmake - bunch of checks, warnings, etc." OFF)
 MARK_AS_ADVANCED(MOO_DEV_MODE_CMAKE)
 IF(MOO_DEV_MODE_CMAKE)
   MACRO(MOO_DEBUG)
     MESSAGE(${ARGN})
   ENDMACRO(MOO_DEBUG)
 ELSE(MOO_DEV_MODE_CMAKE)
   MACRO(MOO_DEBUG)
   ENDMACRO(MOO_DEBUG)
 ENDIF(MOO_DEV_MODE_CMAKE)
 MACRO(MOO_ERROR)
   MESSAGE(FATAL_ERROR ${ARGN})
 ENDMACRO(MOO_ERROR)
 ###########################################################################
+#
 # Build type
+#
 IF("${CMAKE_BUILD_TYPE}" STREQUAL "")
   SET(CMAKE_BUILD_TYPE Release)
 ENDIF("${CMAKE_BUILD_TYPE}" STREQUAL "")
 STRING(TOUPPER ${CMAKE_BUILD_TYPE} MOO_BUILD_TYPE)
 SET(MOO_BUILD_SUBTYPE ${MOO_BUILD_TYPE})
 IF("${MOO_BUILD_TYPE}" STREQUAL "RELWITHDEBINFO" OR "${MOO_BUILD_TYPE}" STREQUAL "MINSIZEREL")
   SET(MOO_BUILD_TYPE RELEASE)
 ELSEIF(NOT "${MOO_BUILD_TYPE}" STREQUAL "DEBUG" AND NOT "${MOO_BUILD_TYPE}" STREQUAL "RELEASE")
   MOO_ERROR("Unknown build type '${MOO_BUILD_TYPE}'")
 ENDIF("${MOO_BUILD_TYPE}" STREQUAL "RELWITHDEBINFO" OR "${MOO_BUILD_TYPE}" STREQUAL "MINSIZEREL")
 MOO_DEBUG(STATUS "MOO_BUILD_TYPE: ${MOO_BUILD_TYPE}")
 IF("${MOO_BUILD_TYPE}" STREQUAL "DEBUG")
   SET(MOO_DEBUG TRUE)
 ELSE("${MOO_BUILD_TYPE}" STREQUAL "DEBUG")
   SET(MOO_DEBUG FALSE)
 ENDIF("${MOO_BUILD_TYPE}" STREQUAL "DEBUG")
 ###########################################################################
+#
 # MOO_DEFINE_H
+#
 SET(__MOO_DEFINE_H_FILE__ ${CMAKE_BINARY_DIR}/moo-config.h.in)
 FILE(WRITE ${__MOO_DEFINE_H_FILE__} "")
 MACRO(MOO_DEFINE_H _moo_varname)
   SET(_moo_comment)
   FOREACH(_moo_arg ${ARGN})
     SET(_moo_comment ${_moo_arg})
   ENDFOREACH(_moo_arg)
   IF(_moo_comment)
     FILE(APPEND ${__MOO_DEFINE_H_FILE__} "/* ${_moo_comment} */\n")
   ENDIF(_moo_comment)
   FILE(APPEND ${__MOO_DEFINE_H_FILE__} "#moodefine ${_moo_varname}\n\n")
 ENDMACRO(MOO_DEFINE_H)
 MACRO(MOO_MAKE_ABSOLUTE_INPUT_FILE file out_var)
   SET(_moo_maif_abs_file "${file}")
   IF(NOT EXISTS "${_moo_maif_abs_file}")
     IF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_moo_maif_abs_file}")
       SET(_moo_maif_abs_file ${CMAKE_CURRENT_SOURCE_DIR}/${_moo_maif_abs_file})
     ENDIF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_moo_maif_abs_file}")
   ENDIF(NOT EXISTS "${_moo_maif_abs_file}")
   IF(NOT EXISTS "${_moo_maif_abs_file}")
     MOO_ERROR("File '${_moo_maif_abs_file}' does not exist")
   ENDIF(NOT EXISTS "${_moo_maif_abs_file}")
   SET(${out_var} "${_moo_maif_abs_file}")
 ENDMACRO(MOO_MAKE_ABSOLUTE_INPUT_FILE)
 MACRO(MOO_MAKE_ABSOLUTE_OUTPUT_FILE file out_var)
   SET(_moo_maof_abs_file "${file}")
   IF(NOT IS_ABSOLUTE "${_moo_maof_abs_file}")
     SET(_moo_maof_abs_file "${CMAKE_CURRENT_BINARY_DIR}/${_moo_maof_abs_file}")
   ENDIF(NOT IS_ABSOLUTE "${_moo_maof_abs_file}")
   SET(${out_var} "${_moo_maof_abs_file}")
 ENDMACRO(MOO_MAKE_ABSOLUTE_OUTPUT_FILE)
 MACRO(MOO_WRITE_CONFIG_H _moo_in_file _moo_out_file)
   MOO_MAKE_ABSOLUTE_INPUT_FILE("${_moo_in_file}" _moo_abs_in_file)
   MOO_MAKE_ABSOLUTE_OUTPUT_FILE("${_moo_out_file}" _moo_abs_out_file)
   FILE(WRITE ${_moo_abs_out_file}-in.moo "#ifndef __CONFIG_H__\n")
   FILE(APPEND ${_moo_abs_out_file}-in.moo "#define __CONFIG_H__\n\n")
   FILE(READ ${_moo_abs_in_file} _moo_contents)
   FILE(APPEND ${_moo_abs_out_file}-in.moo ${_moo_contents})
   FILE(APPEND ${_moo_abs_out_file}-in.moo "\n")
   FILE(STRINGS ${__MOO_DEFINE_H_FILE__} _moo_wch_lines)
   FOREACH(_moo_wch_l ${_moo_wch_lines})
     IF(_moo_wch_l MATCHES "^#moodefine (.*)$")
       STRING(REGEX REPLACE "^#moodefine (.*)$" "\\1" _moo_wch_var "${_moo_wch_l}")
       IF(${_moo_wch_var})
         FILE(APPEND ${_moo_abs_out_file}-in.moo "#define ${_moo_wch_var} 1\n\n")
       ELSE(${_moo_wch_var})
         FILE(APPEND ${_moo_abs_out_file}-in.moo "/* #undef ${_moo_wch_var} */\n\n")
       ENDIF(${_moo_wch_var})
     ELSE(_moo_wch_l MATCHES "^#moodefine (.*)$")
       FILE(APPEND ${_moo_abs_out_file}-in.moo "${_moo_wch_l}\n")
     ENDIF(_moo_wch_l MATCHES "^#moodefine (.*)$")
   ENDFOREACH(_moo_wch_l)
   FILE(APPEND ${_moo_abs_out_file}-in.moo "#endif /* __CONFIG_H__ */\n")
   CONFIGURE_FILE(${_moo_abs_out_file}-in.moo ${_moo_abs_out_file} ${ARGN})
 ENDMACRO(MOO_WRITE_CONFIG_H)
 ###########################################################################
+#
 # OS
+#
 SET(_MOO_KNOWN_PLATFORMS CYGWIN WIN32 DARWIN UNIX FREEBSD BSD LINUX FDO)
 FOREACH(_moo_os ${_MOO_KNOWN_PLATFORMS})
   SET(MOO_OS_${_moo_os} FALSE)
 ENDFOREACH(_moo_os)
 IF(APPLE)
   SET(MOO_OS_DARWIN TRUE)
 ENDIF(APPLE)
 IF(CYGWIN)
   SET(MOO_OS_CYGWIN TRUE)
 ENDIF(CYGWIN)
 IF(WIN32 OR CYGWIN)
   SET(MOO_OS_WIN32 TRUE)
 ENDIF(WIN32 OR CYGWIN)
 IF(UNIX)
   SET(MOO_OS_UNIX TRUE)
 ENDIF(UNIX)
 IF(UNIX AND NOT WIN32 AND NOT APPLE)
   SET(MOO_OS_FDO TRUE)
 ENDIF(UNIX AND NOT WIN32 AND NOT APPLE)
 IF(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
   SET(MOO_OS_FREEBSD TRUE)
 ENDIF(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
 IF(CMAKE_SYSTEM_NAME MATCHES "BSD")
   SET(MOO_OS_BSD TRUE)
 ENDIF(CMAKE_SYSTEM_NAME MATCHES "BSD")
 IF(CMAKE_SYSTEM_NAME MATCHES "Linux")
   SET(MOO_OS_LINUX TRUE)
 ENDIF(CMAKE_SYSTEM_NAME MATCHES "Linux")
 IF(MOO_OS_DARWIN OR MOO_OS_FREEBSD)
   SET(MOO_OS_BSD TRUE)
 ENDIF(MOO_OS_DARWIN OR MOO_OS_FREEBSD)
 IF(MOO_OS_BSD OR MOO_OS_LINUX)
   SET(MOO_OS_UNIX TRUE)
 ENDIF(MOO_OS_BSD OR MOO_OS_LINUX)
 ###########################################################################
+#
 # Installation dirs
+#
 SET(BINDIR bin CACHE PATH "bin")
 SET(DATADIR share CACHE PATH "share")
 SET(DESKTOPFILEDIR ${DATADIR}/applications CACHE PATH "share/applications")
 SET(LIBDIR lib CACHE PATH "lib")
 SET(LOCALEDIR ${DATADIR}/locale CACHE PATH "Where mo files go")
 ###########################################################################
+#
 # Aux macros
+#
 # MOO_COLLECT_ARGS(ARG FOO VAR foo ARG BAR VAR bar ARGN ...)
 # caller: SOME_MACRO(FOO foo1 foo2 foo3 BAR bar1)
 MACRO(MOO_COLLECT_ARGS)
   SET(_moo_args)
   SET(_moo_vars)
   SET(_moo_argn)
   SET(_moo_what)
   FOREACH(_moo_a ${ARGN})
     IF("${_moo_what}" STREQUAL "ARG")
       LIST(APPEND _moo_args ${_moo_a})
       SET(_moo_what VAR)
     ELSEIF("${_moo_what}" STREQUAL "VAR")
       LIST(APPEND _moo_vars ${_moo_a})
       SET(_moo_what)
     ELSEIF("${_moo_what}" STREQUAL "ARGN")
       LIST(APPEND _moo_argn ${_moo_a})
     ELSEIF("${_moo_a}" STREQUAL "ARG")
       SET(_moo_what ARG)
     ELSEIF("${_moo_a}" STREQUAL "ARGN")
       SET(_moo_what ARGN)
     ELSE("${_moo_what}" STREQUAL "ARG")
       MOO_ERROR("bad argument ${moo_a}")
     ENDIF("${_moo_what}" STREQUAL "ARG")
   ENDFOREACH(_moo_a)
 #   MESSAGE("args: ${_moo_args}")
 #   MESSAGE("vars: ${_moo_vars}")
 #   MESSAGE("argn: ${_moo_argn}")
   SET(_moo_what -1)
   FOREACH(_moo_arg ${_moo_argn})
     LIST(FIND _moo_args "${_moo_arg}" _moo_what2)
     IF(NOT _moo_what2 EQUAL -1)
       SET(_moo_what ${_moo_what2})
     ELSE(NOT _moo_what2 EQUAL -1)
       IF(_moo_what EQUAL -1)
         MOO_ERROR("Invalid argument ${_moo_arg}")
       ENDIF(_moo_what EQUAL -1)
       LIST(GET _moo_vars ${_moo_what} _moo_v)
       LIST(APPEND ${_moo_v} "${_moo_arg}")
     ENDIF(NOT _moo_what2 EQUAL -1)
   ENDFOREACH(_moo_arg)
   LIST(LENGTH _moo_args _moo_nargs)
   MATH(EXPR _moo_nargs "${_moo_nargs} - 1")
   FOREACH(_moo_what RANGE ${_moo_nargs})
     LIST(GET _moo_args ${_moo_what} _moo_a)
     LIST(GET _moo_vars ${_moo_what} _moo_v)
     #MOO_DEBUG("${_moo_what}. ${_moo_v}: ${${_moo_v}}")
   ENDFOREACH(_moo_what)
 ENDMACRO(MOO_COLLECT_ARGS)
 MACRO(__MOO_SET_SIMPLE_VAR var)
   SET(${var} ${ARGN})
 ENDMACRO(__MOO_SET_SIMPLE_VAR)
 # _MOO_COLLECT_ARGS_IMPL(FOO foo setfoo BAR bar setbar ARGN ...)
 MACRO(_MOO_COLLECT_ARGS_IMPL)
   SET(_moo__cai_args)
   SET(_moo__cai_vars)
   SET(_moo__cai_macros)
   SET(_moo__cai_argn)
   SET(_moo__cai_what)
   FOREACH(_moo__cai_a ${ARGN})
     IF("${_moo__cai_what}" STREQUAL "VAR")
       LIST(APPEND _moo__cai_vars ${_moo__cai_a})
       SET(_moo__cai_what SETVAR)
     ELSEIF("${_moo__cai_what}" STREQUAL "SETVAR")
       LIST(APPEND _moo__cai_macros ${_moo__cai_a})
       SET(_moo__cai_what)
     ELSEIF("${_moo__cai_what}" STREQUAL "ARGN")
       LIST(APPEND _moo__cai_argn ${_moo__cai_a})
     ELSEIF("${_moo__cai_a}" STREQUAL "ARGN")
       SET(_moo__cai_what ARGN)
     ELSE("${_moo__cai_what}" STREQUAL "VAR")
       LIST(APPEND _moo__cai_args ${_moo__cai_a})
       SET(_moo__cai_what VAR)
     ENDIF("${_moo__cai_what}" STREQUAL "VAR")
   ENDFOREACH(_moo__cai_a)
 #   MOO_DEBUG("args: ${_moo__cai_args}")
 #   MOO_DEBUG("vars: ${_moo__cai_vars}")
 #   MOO_DEBUG("macros: ${_moo__cai_macros}")
 #   MOO_DEBUG("argn: ${_moo__cai_argn}")
   SET(_moo__cai_what -1)
   FOREACH(_moo__cai_arg ${_moo__cai_argn})
     LIST(FIND _moo__cai_args "${_moo__cai_arg}" _moo__cai_what2)
     IF(NOT _moo__cai_what2 EQUAL -1)
       SET(_moo__cai_what ${_moo__cai_what2})
     ELSE(NOT _moo__cai_what2 EQUAL -1)
       IF(_moo__cai_what EQUAL -1)
         MOO_ERROR("Invalid argument ${_moo__cai_arg}")
       ENDIF(_moo__cai_what EQUAL -1)
       LIST(GET _moo__cai_vars ${_moo__cai_what} _moo__cai_v)
       LIST(GET _moo__cai_macros ${_moo__cai_what} _moo__cai_sv)
       IF("${_moo__cai_sv}" STREQUAL "__MOO_SET_SIMPLE_VAR")
 #         MOO_DEBUG("${_moo__cai_v} = ${_moo__cai_arg}")
         __MOO_SET_SIMPLE_VAR(${_moo__cai_v} ${_moo__cai_arg})
       ELSE("${_moo__cai_sv}" STREQUAL "__MOO_SET_SIMPLE_VAR")
         MOO_ERROR("Invalid argument ${_moo__cai_sv}")
       ENDIF("${_moo__cai_sv}" STREQUAL "__MOO_SET_SIMPLE_VAR")
     ENDIF(NOT _moo__cai_what2 EQUAL -1)
   ENDFOREACH(_moo__cai_arg)
   LIST(LENGTH _moo__cai_args _moo__cai_nargs)
   MATH(EXPR _moo__cai_nargs "${_moo__cai_nargs} - 1")
   FOREACH(_moo__cai_what RANGE ${_moo__cai_nargs})
     LIST(GET _moo__cai_args ${_moo__cai_what} _moo__cai_a)
     LIST(GET _moo__cai_vars ${_moo__cai_what} _moo__cai_v)
 #     MOO_DEBUG("${_moo__cai_what}. ${_moo__cai_v}: ${${_moo__cai_v}}")
   ENDFOREACH(_moo__cai_what)
 ENDMACRO(_MOO_COLLECT_ARGS_IMPL)
 # MOO_COLLECT_SIMPLE_ARGS(FOO foo BAR bar ARGN ...)
 MACRO(MOO_COLLECT_SIMPLE_ARGS)
   SET(_moo_csa_impl_argn)
   SET(_moo_csa_argn ${ARGN})
   SET(_moo_csa_i 0)
   LIST(LENGTH _moo_csa_argn _moo_csa_nargs)
   WHILE(_moo_csa_i LESS _moo_csa_nargs)
     LIST(GET _moo_csa_argn ${_moo_csa_i} _moo_csa_a)
     IF("${_moo_csa_a}" STREQUAL "ARGN")
       BREAK()
     ENDIF("${_moo_csa_a}" STREQUAL "ARGN")
     MATH(EXPR _moo_csa_i "${_moo_csa_i} + 1")
     LIST(GET _moo_csa_argn ${_moo_csa_i} _moo_csa_v)
     LIST(APPEND _moo_csa_impl_argn "${_moo_csa_a}")
     LIST(APPEND _moo_csa_impl_argn "${_moo_csa_v}")
     LIST(APPEND _moo_csa_impl_argn __MOO_SET_SIMPLE_VAR)
     MATH(EXPR _moo_csa_i "${_moo_csa_i} + 1")
   ENDWHILE(_moo_csa_i LESS _moo_csa_nargs)
   WHILE(_moo_csa_i LESS _moo_csa_nargs)
     LIST(GET _moo_csa_argn ${_moo_csa_i} _moo_csa_a)
     LIST(APPEND _moo_csa_impl_argn "${_moo_csa_a}")
     MATH(EXPR _moo_csa_i "${_moo_csa_i} + 1")
   ENDWHILE(_moo_csa_i LESS _moo_csa_nargs)
 #   MOO_DEBUG("MOO_COLLECT_SIMPLE_ARGS: ${_moo_csa_argn}")
 #   MOO_DEBUG("MOO_COLLECT_SIMPLE_ARGS: ${_moo_csa_impl_argn}")
   _MOO_COLLECT_ARGS_IMPL(${_moo_csa_impl_argn})
 ENDMACRO(MOO_COLLECT_SIMPLE_ARGS)
 ###########################################################################
+#
 # MOO_OPTION
+#
 MACRO(MOO_OPTION variable dfltval helpstring)
   IF(DEFINED __MOO_OPTION_SET_${variable})
     MOO_ERROR("Option ${variable} is already created")
   ENDIF(DEFINED __MOO_OPTION_SET_${variable})
   SET(_moo_option_hidden)
   SET(_moo_option_header)
   SET(_moo_option_define)
   MOO_COLLECT_SIMPLE_ARGS(HIDDEN _moo_option_hidden HEADER _moo_option_header DEFINE _moo_option_define ARGN ${ARGN})
   IF(NOT _moo_option_hidden)
     OPTION(${variable} "${helpstring}" "${dfltval}")
   ELSE(NOT _moo_option_hidden)
     SET(${variable} "${dfltval}" CACHE BOOL "${helpstring}")
     MARK_AS_ADVANCED(${variable})
   ENDIF(NOT _moo_option_hidden)
   IF(_moo_option_header)
 #     MOO_DEBUG(${variable})
     MOO_DEFINE_H(${variable} "${helpstring}")
   ENDIF(_moo_option_header)
   IF(_moo_option_define AND ${variable})
     ADD_DEFINITIONS(-D${variable}=1)
   ENDIF(_moo_option_define AND ${variable})
   SET(__MOO_OPTION_SET_${variable} 1)
 #   MOO_DEBUG(STATUS "Option ${variable}")
 ENDMACRO(MOO_OPTION)
 MACRO(MOO_CHECK_OPTION variable)
   IF(NOT DEFINED __MOO_OPTION_SET_${variable})
     MOO_ERROR("Option ${variable} is not set")
   ENDIF(NOT DEFINED __MOO_OPTION_SET_${variable})
 ENDMACRO(MOO_CHECK_OPTION)
 MOO_OPTION(MOO_DEV_MODE FALSE "Enable developer mode - bunch of checks, warnings, etc." DEFINE 1)
 FIND_PACKAGE(MooCompilers)
 FIND_PACKAGE(MooCmakeUtils)
-FIND_PACKAGE(MooI18n)
+OPTION(MOO_DEV_MODE_CMAKE "Enable developer mode for cmake - bunch of checks, warnings, etc." OFF)
 MARK_AS_ADVANCED(MOO_DEV_MODE_CMAKE)
 IF(MOO_DEV_MODE_CMAKE)
   MACRO(MOO_DEBUG)
     MESSAGE(${ARGN})
   ENDMACRO(MOO_DEBUG)
 ELSE(MOO_DEV_MODE_CMAKE)
   MACRO(MOO_DEBUG)
   ENDMACRO(MOO_DEBUG)
 ENDIF(MOO_DEV_MODE_CMAKE)
 MACRO(MOO_ERROR)
   MESSAGE(FATAL_ERROR ${ARGN})
 ENDMACRO(MOO_ERROR)
 ###########################################################################
+#
 # Build type
+#
 IF("${CMAKE_BUILD_TYPE}" STREQUAL "")
   SET(CMAKE_BUILD_TYPE Release)
 ENDIF("${CMAKE_BUILD_TYPE}" STREQUAL "")
 STRING(TOUPPER ${CMAKE_BUILD_TYPE} MOO_BUILD_TYPE)
 SET(MOO_BUILD_SUBTYPE ${MOO_BUILD_TYPE})
 IF("${MOO_BUILD_TYPE}" STREQUAL "RELWITHDEBINFO" OR "${MOO_BUILD_TYPE}" STREQUAL "MINSIZEREL")
   SET(MOO_BUILD_TYPE RELEASE)
 ELSEIF(NOT "${MOO_BUILD_TYPE}" STREQUAL "DEBUG" AND NOT "${MOO_BUILD_TYPE}" STREQUAL "RELEASE")
   MOO_ERROR("Unknown build type '${MOO_BUILD_TYPE}'")
 ENDIF("${MOO_BUILD_TYPE}" STREQUAL "RELWITHDEBINFO" OR "${MOO_BUILD_TYPE}" STREQUAL "MINSIZEREL")
 MOO_DEBUG(STATUS "MOO_BUILD_TYPE: ${MOO_BUILD_TYPE}")
 IF("${MOO_BUILD_TYPE}" STREQUAL "DEBUG")
   SET(MOO_DEBUG TRUE)
 ELSE("${MOO_BUILD_TYPE}" STREQUAL "DEBUG")
   SET(MOO_DEBUG FALSE)
 ENDIF("${MOO_BUILD_TYPE}" STREQUAL "DEBUG")
 ###########################################################################
+#
 # MOO_DEFINE_H
+#
 SET(__MOO_DEFINE_H_FILE__ ${CMAKE_BINARY_DIR}/moo-config.h.in)
 FILE(WRITE ${__MOO_DEFINE_H_FILE__} "")
 MACRO(MOO_DEFINE_H _moo_varname)
   SET(_moo_comment)
   FOREACH(_moo_arg ${ARGN})
     SET(_moo_comment ${_moo_arg})
   ENDFOREACH(_moo_arg)
   IF(_moo_comment)
     FILE(APPEND ${__MOO_DEFINE_H_FILE__} "/* ${_moo_comment} */\n")
   ENDIF(_moo_comment)
   FILE(APPEND ${__MOO_DEFINE_H_FILE__} "#moodefine ${_moo_varname}\n\n")
 ENDMACRO(MOO_DEFINE_H)
 MACRO(MOO_MAKE_ABSOLUTE_INPUT_FILE file out_var)
   SET(_moo_maif_abs_file "${file}")
   IF(NOT EXISTS "${_moo_maif_abs_file}")
     IF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_moo_maif_abs_file}")
       SET(_moo_maif_abs_file ${CMAKE_CURRENT_SOURCE_DIR}/${_moo_maif_abs_file})
     ENDIF(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_moo_maif_abs_file}")
   ENDIF(NOT EXISTS "${_moo_maif_abs_file}")
   IF(NOT EXISTS "${_moo_maif_abs_file}")
     MOO_ERROR("File '${_moo_maif_abs_file}' does not exist")
   ENDIF(NOT EXISTS "${_moo_maif_abs_file}")
   SET(${out_var} "${_moo_maif_abs_file}")
 ENDMACRO(MOO_MAKE_ABSOLUTE_INPUT_FILE)
 MACRO(MOO_MAKE_ABSOLUTE_OUTPUT_FILE file out_var)
   SET(_moo_maof_abs_file "${file}")
   IF(NOT IS_ABSOLUTE "${_moo_maof_abs_file}")
     SET(_moo_maof_abs_file "${CMAKE_CURRENT_BINARY_DIR}/${_moo_maof_abs_file}")
   ENDIF(NOT IS_ABSOLUTE "${_moo_maof_abs_file}")
   SET(${out_var} "${_moo_maof_abs_file}")
 ENDMACRO(MOO_MAKE_ABSOLUTE_OUTPUT_FILE)
 MACRO(MOO_WRITE_CONFIG_H _moo_in_file _moo_out_file)
   MOO_MAKE_ABSOLUTE_INPUT_FILE("${_moo_in_file}" _moo_abs_in_file)
   MOO_MAKE_ABSOLUTE_OUTPUT_FILE("${_moo_out_file}" _moo_abs_out_file)
   FILE(WRITE ${_moo_abs_out_file}-in.moo "#ifndef __CONFIG_H__\n")
   FILE(APPEND ${_moo_abs_out_file}-in.moo "#define __CONFIG_H__\n\n")
   FILE(READ ${_moo_abs_in_file} _moo_contents)
   FILE(APPEND ${_moo_abs_out_file}-in.moo ${_moo_contents})
   FILE(APPEND ${_moo_abs_out_file}-in.moo "\n")
   FILE(STRINGS ${__MOO_DEFINE_H_FILE__} _moo_wch_lines)
   FOREACH(_moo_wch_l ${_moo_wch_lines})
     IF(_moo_wch_l MATCHES "^#moodefine (.*)$")
       STRING(REGEX REPLACE "^#moodefine (.*)$" "\\1" _moo_wch_var "${_moo_wch_l}")
       IF(${_moo_wch_var})
         FILE(APPEND ${_moo_abs_out_file}-in.moo "#define ${_moo_wch_var} 1\n\n")
       ELSE(${_moo_wch_var})
         FILE(APPEND ${_moo_abs_out_file}-in.moo "/* #undef ${_moo_wch_var} */\n\n")
       ENDIF(${_moo_wch_var})
     ELSE(_moo_wch_l MATCHES "^#moodefine (.*)$")
       FILE(APPEND ${_moo_abs_out_file}-in.moo "${_moo_wch_l}\n")
     ENDIF(_moo_wch_l MATCHES "^#moodefine (.*)$")
   ENDFOREACH(_moo_wch_l)
   FILE(APPEND ${_moo_abs_out_file}-in.moo "#endif /* __CONFIG_H__ */\n")
   CONFIGURE_FILE(${_moo_abs_out_file}-in.moo ${_moo_abs_out_file} ${ARGN})
 ENDMACRO(MOO_WRITE_CONFIG_H)
 ###########################################################################
+#
 # OS
+#
 SET(_MOO_KNOWN_PLATFORMS CYGWIN WIN32 DARWIN UNIX FREEBSD BSD LINUX FDO)
 FOREACH(_moo_os ${_MOO_KNOWN_PLATFORMS})
   SET(MOO_OS_${_moo_os} FALSE)
 ENDFOREACH(_moo_os)
 IF(APPLE)
   SET(MOO_OS_DARWIN TRUE)
 ENDIF(APPLE)
 IF(CYGWIN)
   SET(MOO_OS_CYGWIN TRUE)
 ENDIF(CYGWIN)
 IF(WIN32 OR CYGWIN)
   SET(MOO_OS_WIN32 TRUE)
 ENDIF(WIN32 OR CYGWIN)
 IF(UNIX)
   SET(MOO_OS_UNIX TRUE)
 ENDIF(UNIX)
 IF(UNIX AND NOT WIN32 AND NOT APPLE)
   SET(MOO_OS_FDO TRUE)
 ENDIF(UNIX AND NOT WIN32 AND NOT APPLE)
 IF(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
   SET(MOO_OS_FREEBSD TRUE)
 ENDIF(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
 IF(CMAKE_SYSTEM_NAME MATCHES "BSD")
   SET(MOO_OS_BSD TRUE)
 ENDIF(CMAKE_SYSTEM_NAME MATCHES "BSD")
 IF(CMAKE_SYSTEM_NAME MATCHES "Linux")
   SET(MOO_OS_LINUX TRUE)
 ENDIF(CMAKE_SYSTEM_NAME MATCHES "Linux")
 IF(MOO_OS_DARWIN OR MOO_OS_FREEBSD)
   SET(MOO_OS_BSD TRUE)
 ENDIF(MOO_OS_DARWIN OR MOO_OS_FREEBSD)
 IF(MOO_OS_BSD OR MOO_OS_LINUX)
   SET(MOO_OS_UNIX TRUE)
 ENDIF(MOO_OS_BSD OR MOO_OS_LINUX)
 ###########################################################################
+#
 # Installation dirs
+#
 SET(BINDIR bin CACHE PATH "bin")
 SET(DATADIR share CACHE PATH "share")
 SET(DESKTOPFILEDIR ${DATADIR}/applications CACHE PATH "share/applications")
 SET(LIBDIR lib CACHE PATH "lib")
 SET(LOCALEDIR ${DATADIR}/locale CACHE PATH "Where mo files go")
 ###########################################################################
+#
 # Aux macros
+#
 # MOO_COLLECT_ARGS(ARG FOO VAR foo ARG BAR VAR bar ARGN ...)
 # caller: SOME_MACRO(FOO foo1 foo2 foo3 BAR bar1)
 MACRO(MOO_COLLECT_ARGS)
   SET(_moo_args)
   SET(_moo_vars)
   SET(_moo_argn)
   SET(_moo_what)
   FOREACH(_moo_a ${ARGN})
     IF("${_moo_what}" STREQUAL "ARG")
       LIST(APPEND _moo_args ${_moo_a})
       SET(_moo_what VAR)
     ELSEIF("${_moo_what}" STREQUAL "VAR")
       LIST(APPEND _moo_vars ${_moo_a})
       SET(_moo_what)
     ELSEIF("${_moo_what}" STREQUAL "ARGN")
       LIST(APPEND _moo_argn ${_moo_a})
     ELSEIF("${_moo_a}" STREQUAL "ARG")
       SET(_moo_what ARG)
     ELSEIF("${_moo_a}" STREQUAL "ARGN")
       SET(_moo_what ARGN)
     ELSE("${_moo_what}" STREQUAL "ARG")
       MOO_ERROR("bad argument ${moo_a}")
     ENDIF("${_moo_what}" STREQUAL "ARG")
   ENDFOREACH(_moo_a)
 #   MESSAGE("args: ${_moo_args}")
 #   MESSAGE("vars: ${_moo_vars}")
 #   MESSAGE("argn: ${_moo_argn}")
   SET(_moo_what -1)
   FOREACH(_moo_arg ${_moo_argn})
     LIST(FIND _moo_args "${_moo_arg}" _moo_what2)
     IF(NOT _moo_what2 EQUAL -1)
       SET(_moo_what ${_moo_what2})
     ELSE(NOT _moo_what2 EQUAL -1)
       IF(_moo_what EQUAL -1)
         MOO_ERROR("Invalid argument ${_moo_arg}")
       ENDIF(_moo_what EQUAL -1)
       LIST(GET _moo_vars ${_moo_what} _moo_v)
       LIST(APPEND ${_moo_v} "${_moo_arg}")
     ENDIF(NOT _moo_what2 EQUAL -1)
   ENDFOREACH(_moo_arg)
   LIST(LENGTH _moo_args _moo_nargs)
   MATH(EXPR _moo_nargs "${_moo_nargs} - 1")
   FOREACH(_moo_what RANGE ${_moo_nargs})
     LIST(GET _moo_args ${_moo_what} _moo_a)
     LIST(GET _moo_vars ${_moo_what} _moo_v)
     #MOO_DEBUG("${_moo_what}. ${_moo_v}: ${${_moo_v}}")
   ENDFOREACH(_moo_what)
 ENDMACRO(MOO_COLLECT_ARGS)
 MACRO(__MOO_SET_SIMPLE_VAR var)
   SET(${var} ${ARGN})
 ENDMACRO(__MOO_SET_SIMPLE_VAR)
 # _MOO_COLLECT_ARGS_IMPL(FOO foo setfoo BAR bar setbar ARGN ...)
 MACRO(_MOO_COLLECT_ARGS_IMPL)
   SET(_moo__cai_args)
   SET(_moo__cai_vars)
   SET(_moo__cai_macros)
   SET(_moo__cai_argn)
   SET(_moo__cai_what)
   FOREACH(_moo__cai_a ${ARGN})
     IF("${_moo__cai_what}" STREQUAL "VAR")
       LIST(APPEND _moo__cai_vars ${_moo__cai_a})
       SET(_moo__cai_what SETVAR)
     ELSEIF("${_moo__cai_what}" STREQUAL "SETVAR")
       LIST(APPEND _moo__cai_macros ${_moo__cai_a})
       SET(_moo__cai_what)
     ELSEIF("${_moo__cai_what}" STREQUAL "ARGN")
       LIST(APPEND _moo__cai_argn ${_moo__cai_a})
     ELSEIF("${_moo__cai_a}" STREQUAL "ARGN")
       SET(_moo__cai_what ARGN)
     ELSE("${_moo__cai_what}" STREQUAL "VAR")
       LIST(APPEND _moo__cai_args ${_moo__cai_a})
       SET(_moo__cai_what VAR)
     ENDIF("${_moo__cai_what}" STREQUAL "VAR")
   ENDFOREACH(_moo__cai_a)
 #   MOO_DEBUG("args: ${_moo__cai_args}")
 #   MOO_DEBUG("vars: ${_moo__cai_vars}")
 #   MOO_DEBUG("macros: ${_moo__cai_macros}")
 #   MOO_DEBUG("argn: ${_moo__cai_argn}")
   SET(_moo__cai_what -1)
   FOREACH(_moo__cai_arg ${_moo__cai_argn})
     LIST(FIND _moo__cai_args "${_moo__cai_arg}" _moo__cai_what2)
     IF(NOT _moo__cai_what2 EQUAL -1)
       SET(_moo__cai_what ${_moo__cai_what2})
     ELSE(NOT _moo__cai_what2 EQUAL -1)
       IF(_moo__cai_what EQUAL -1)
         MOO_ERROR("Invalid argument ${_moo__cai_arg}")
       ENDIF(_moo__cai_what EQUAL -1)
       LIST(GET _moo__cai_vars ${_moo__cai_what} _moo__cai_v)
       LIST(GET _moo__cai_macros ${_moo__cai_what} _moo__cai_sv)
       IF("${_moo__cai_sv}" STREQUAL "__MOO_SET_SIMPLE_VAR")
 #         MOO_DEBUG("${_moo__cai_v} = ${_moo__cai_arg}")
         __MOO_SET_SIMPLE_VAR(${_moo__cai_v} ${_moo__cai_arg})
       ELSE("${_moo__cai_sv}" STREQUAL "__MOO_SET_SIMPLE_VAR")
         MOO_ERROR("Invalid argument ${_moo__cai_sv}")
       ENDIF("${_moo__cai_sv}" STREQUAL "__MOO_SET_SIMPLE_VAR")
     ENDIF(NOT _moo__cai_what2 EQUAL -1)
   ENDFOREACH(_moo__cai_arg)
   LIST(LENGTH _moo__cai_args _moo__cai_nargs)
   MATH(EXPR _moo__cai_nargs "${_moo__cai_nargs} - 1")
   FOREACH(_moo__cai_what RANGE ${_moo__cai_nargs})
     LIST(GET _moo__cai_args ${_moo__cai_what} _moo__cai_a)
     LIST(GET _moo__cai_vars ${_moo__cai_what} _moo__cai_v)
 #     MOO_DEBUG("${_moo__cai_what}. ${_moo__cai_v}: ${${_moo__cai_v}}")
   ENDFOREACH(_moo__cai_what)
 ENDMACRO(_MOO_COLLECT_ARGS_IMPL)
 # MOO_COLLECT_SIMPLE_ARGS(FOO foo BAR bar ARGN ...)
 MACRO(MOO_COLLECT_SIMPLE_ARGS)
   SET(_moo_csa_impl_argn)
   SET(_moo_csa_argn ${ARGN})
   SET(_moo_csa_i 0)
   LIST(LENGTH _moo_csa_argn _moo_csa_nargs)
   WHILE(_moo_csa_i LESS _moo_csa_nargs)
     LIST(GET _moo_csa_argn ${_moo_csa_i} _moo_csa_a)
     IF("${_moo_csa_a}" STREQUAL "ARGN")
       BREAK()
     ENDIF("${_moo_csa_a}" STREQUAL "ARGN")
     MATH(EXPR _moo_csa_i "${_moo_csa_i} + 1")
     LIST(GET _moo_csa_argn ${_moo_csa_i} _moo_csa_v)
     LIST(APPEND _moo_csa_impl_argn "${_moo_csa_a}")
     LIST(APPEND _moo_csa_impl_argn "${_moo_csa_v}")
     LIST(APPEND _moo_csa_impl_argn __MOO_SET_SIMPLE_VAR)
     MATH(EXPR _moo_csa_i "${_moo_csa_i} + 1")
   ENDWHILE(_moo_csa_i LESS _moo_csa_nargs)
   WHILE(_moo_csa_i LESS _moo_csa_nargs)
     LIST(GET _moo_csa_argn ${_moo_csa_i} _moo_csa_a)
     LIST(APPEND _moo_csa_impl_argn "${_moo_csa_a}")
     MATH(EXPR _moo_csa_i "${_moo_csa_i} + 1")
   ENDWHILE(_moo_csa_i LESS _moo_csa_nargs)
 #   MOO_DEBUG("MOO_COLLECT_SIMPLE_ARGS: ${_moo_csa_argn}")
 #   MOO_DEBUG("MOO_COLLECT_SIMPLE_ARGS: ${_moo_csa_impl_argn}")
   _MOO_COLLECT_ARGS_IMPL(${_moo_csa_impl_argn})
 ENDMACRO(MOO_COLLECT_SIMPLE_ARGS)
 ###########################################################################
+#
 # MOO_OPTION
+#
 MACRO(MOO_OPTION variable dfltval helpstring)
   IF(DEFINED __MOO_OPTION_SET_${variable})
     MOO_ERROR("Option ${variable} is already created")
   ENDIF(DEFINED __MOO_OPTION_SET_${variable})
   SET(_moo_option_hidden)
   SET(_moo_option_header)
   SET(_moo_option_define)
   MOO_COLLECT_SIMPLE_ARGS(HIDDEN _moo_option_hidden HEADER _moo_option_header DEFINE _moo_option_define ARGN ${ARGN})
   IF(NOT _moo_option_hidden)
     OPTION(${variable} "${helpstring}" "${dfltval}")
   ELSE(NOT _moo_option_hidden)
     SET(${variable} "${dfltval}" CACHE BOOL "${helpstring}")
     MARK_AS_ADVANCED(${variable})
   ENDIF(NOT _moo_option_hidden)
   IF(_moo_option_header)
 #     MOO_DEBUG(${variable})
     MOO_DEFINE_H(${variable} "${helpstring}")
   ENDIF(_moo_option_header)
   IF(_moo_option_define AND ${variable})
     ADD_DEFINITIONS(-D${variable}=1)
   ENDIF(_moo_option_define AND ${variable})
   SET(__MOO_OPTION_SET_${variable} 1)
 #   MOO_DEBUG(STATUS "Option ${variable}")
 ENDMACRO(MOO_OPTION)
 MACRO(MOO_CHECK_OPTION variable)
   IF(NOT DEFINED __MOO_OPTION_SET_${variable})
     MOO_ERROR("Option ${variable} is not set")
   ENDIF(NOT DEFINED __MOO_OPTION_SET_${variable})
 ENDMACRO(MOO_CHECK_OPTION)
 MOO_OPTION(MOO_DEV_MODE FALSE "Enable developer mode - bunch of checks, warnings, etc." DEFINE 1)
 FIND_PACKAGE(MooCompilers)
 FIND_PACKAGE(MooCmakeUtils)
 FIND_PACKAGE(MooI18n)

Up to file-list cmake/modules/FindMooCmakeUtils.cmake:

 MACRO(MOO_EXEC_OR_DIE command)
   EXECUTE_PROCESS(${ARGN}
                   RESULT_VARIABLE __moo_command_result
                   ERROR_VARIABLE __moo_command_error
+  )
   IF(NOT __moo_command_result EQUAL 0)
     MESSAGE(FATAL_ERROR "Command ${command} failed: ${__moo_command_error}")
   ENDIF(NOT __moo_command_result EQUAL 0)
 ENDMACRO(MOO_EXEC_OR_DIE)
 MACRO(MOO_COPY_FILE file1 file2)
   MOO_EXEC_OR_DIE("copy ${file1} ${file2}"
     COMMAND ${CMAKE_COMMAND} -E copy ${file1} ${file2}
+  )
 ENDMACRO(MOO_COPY_FILE)
 MACRO(MOO_COPY_IF_CHANGED file1 file2)
   SET(__moo_do_copy)
   IF(NOT EXISTS ${file2})
     SET(__moo_do_copy 1)
   ELSE(NOT EXISTS ${file2})
     FILE(READ ${file1} __moo_contents1)
     FILE(READ ${file2} __moo_contents2)
     IF(NOT "${__moo_contents1}" STREQUAL "${__moo_contents2}")
       SET(__moo_do_copy 1)
     ENDIF(NOT "${__moo_contents1}" STREQUAL "${__moo_contents2}")
   ENDIF(NOT EXISTS ${file2})
   IF(__moo_do_copy)
     MOO_COPY_FILE(${file1} ${file2})
   ENDIF(__moo_do_copy)
-ENDMACRO(MOO_COPY_IF_CHANGED)
+MACRO(MOO_EXEC_OR_DIE command)
   EXECUTE_PROCESS(${ARGN}
                   RESULT_VARIABLE __moo_command_result
                   ERROR_VARIABLE __moo_command_error
+  )
   IF(NOT __moo_command_result EQUAL 0)
     MESSAGE(FATAL_ERROR "Command ${command} failed: ${__moo_command_error}")
   ENDIF(NOT __moo_command_result EQUAL 0)
 ENDMACRO(MOO_EXEC_OR_DIE)
 MACRO(MOO_COPY_FILE file1 file2)
   MOO_EXEC_OR_DIE("copy ${file1} ${file2}"
     COMMAND ${CMAKE_COMMAND} -E copy ${file1} ${file2}
+  )
 ENDMACRO(MOO_COPY_FILE)
 MACRO(MOO_COPY_IF_CHANGED file1 file2)
   SET(__moo_do_copy)
   IF(NOT EXISTS ${file2})
     SET(__moo_do_copy 1)
   ELSE(NOT EXISTS ${file2})
     FILE(READ ${file1} __moo_contents1)
     FILE(READ ${file2} __moo_contents2)
     IF(NOT "${__moo_contents1}" STREQUAL "${__moo_contents2}")
       SET(__moo_do_copy 1)
     ENDIF(NOT "${__moo_contents1}" STREQUAL "${__moo_contents2}")
   ENDIF(NOT EXISTS ${file2})
   IF(__moo_do_copy)
     MOO_COPY_FILE(${file1} ${file2})
   ENDIF(__moo_do_copy)
 ENDMACRO(MOO_COPY_IF_CHANGED)

Up to file-list cmake/modules/FindMooCompilers.cmake:

 MACRO(_MOO_JOIN_STRING_LIST outvar sep)
   SET(_moo__jsl_result)
   SET(_moo__jsl_first TRUE)
   FOREACH(_moo__jsl_arg ${ARGN})
     IF(_moo__jsl_first)
       SET(_moo__jsl_result "${_moo__jsl_arg}")
       SET(_moo__jsl_first FALSE)
     ELSE(_moo__jsl_first)
       SET(_moo__jsl_result "${_moo__jsl_result}${sep}${_moo__jsl_arg}")
     ENDIF(_moo__jsl_first)
   ENDFOREACH(_moo__jsl_arg)
   SET(${outvar} "${_moo__jsl_result}")
 ENDMACRO(_MOO_JOIN_STRING_LIST)
 MACRO(_MOO_CHECK_COMPILER_LANG lang var)
   STRING(TOUPPER ${lang} _moo__ccl_lang)
   IF("${_moo__ccl_lang}" STREQUAL "ALL")
     SET(_moo__ccl_langs C CXX)
   ELSEIF("${_moo__ccl_lang}" STREQUAL "C" OR "${_moo__ccl_lang}" STREQUAL "CXX")
     SET(_moo__ccl_langs ${_moo__ccl_lang})
   ELSE("${_moo__ccl_lang}" STREQUAL "ALL")
     MOO_ERROR("Invalid lang '${lang}'")
   ENDIF("${_moo__ccl_lang}" STREQUAL "ALL")
   SET(${var} ${_moo__ccl_langs})
 ENDMACRO(_MOO_CHECK_COMPILER_LANG)
 MACRO(_MOO_CHECK_BUILD_TYPE build prefix var)
   STRING(TOUPPER ${build} _moo__cbt_build)
   IF("${_moo__cbt_build}" STREQUAL "ALL")
     SET(_moo__cbt_vars ${prefix})
   ELSEIF("${_moo__cbt_build}" STREQUAL "RELEASE")
     SET(_moo__cbt_vars ${prefix}_RELEASE ${prefix}_RELWITHDEBINFO ${prefix}_MINSIZEREL)
   ELSEIF("${_moo__cbt_build}" STREQUAL "RELEASEONLY")
     SET(_moo__cbt_vars ${prefix}_RELEASE)
   ELSEIF("${_moo__cbt_build}" STREQUAL "DEBUG" OR "${_moo__cbt_build}" STREQUAL "RELWITHDEBINFO" OR "${_moo__cbt_build}" STREQUAL "MINSIZEREL")
     SET(_moo__cbt_vars ${prefix}_${_moo__cbt_build})
   ELSE("${_moo__cbt_build}" STREQUAL "ALL")
     MOO_ERROR("Invalid build type '${build}'")
   ENDIF("${_moo__cbt_build}" STREQUAL "ALL")
   SET(${var} ${_moo__cbt_vars})
 ENDMACRO(_MOO_CHECK_BUILD_TYPE)
 MACRO(_MOO_GET_COMPILER_CONFIG_ARGS var_lang var_build_prefix var_build_vars var_args)
   SET(_moo__gcca_langs C CXX)
   SET(_moo__gcca_args)
   SET(_moo__gcca_do TRUE)
   _MOO_CHECK_BUILD_TYPE("ALL" ${var_build_prefix} _moo__gcca_bvars)
   FOREACH(_moo__gcca_arg ${ARGN})
     IF("${_moo__gcca_arg}" STREQUAL "GCC" OR "${_moo__gcca_arg}" STREQUAL "GNUCC")
       IF(NOT CMAKE_COMPILER_IS_GNUCC)
         SET(_moo__gcca_do FALSE)
       ENDIF(NOT CMAKE_COMPILER_IS_GNUCC)
     ELSEIF("${_moo__gcca_arg}" STREQUAL "MSVC")
       IF(NOT MSVC)
         SET(_moo__gcca_do FALSE)
       ENDIF(NOT MSVC)
     ELSEIF("${_moo__gcca_arg}" STREQUAL "DEBUG" OR "${_moo__gcca_arg}" STREQUAL "RELEASE" OR
            "${_moo__gcca_arg}" STREQUAL "RELEASEONLY" OR "${_moo__gcca_arg}" STREQUAL "RELWITHDEBINFO" OR
            "${_moo__gcca_arg}" STREQUAL "MINSIZEREL")
       _MOO_CHECK_BUILD_TYPE(${_moo__gcca_arg} ${var_build_prefix} _moo__gcca_bvars)
     ELSEIF("${_moo__gcca_arg}" STREQUAL "C" OR "${_moo__gcca_arg}" STREQUAL "CXX")
       SET(_moo__gcca_langs ${_moo__gcca_arg})
     ELSEIF("${_moo__gcca_arg}" STREQUAL "WIN32" OR "${_moo__gcca_arg}" STREQUAL "UNIX")
       IF("${_moo__gcca_arg}" STREQUAL "WIN32" AND NOT WIN32)
 	SET(_moo__gcca_do FALSE)
       ELSEIF("${_moo__gcca_arg}" STREQUAL "UNIX" AND WIN32)
 	SET(_moo__gcca_do FALSE)
       ENDIF("${_moo__gcca_arg}" STREQUAL "WIN32" AND NOT WIN32)
     ELSE("${_moo__gcca_arg}" STREQUAL "GCC" OR "${_moo__gcca_arg}" STREQUAL "GNUCC")
       LIST(APPEND _moo__gcca_args ${_moo__gcca_arg})
     ENDIF("${_moo__gcca_arg}" STREQUAL "GCC" OR "${_moo__gcca_arg}" STREQUAL "GNUCC")
   ENDFOREACH(_moo__gcca_arg)
   #MESSAGE("_MOO_GET_COMPILER_CONFIG_ARGS(var_lang=${var_lang}, var_build_prefix=${var_build_prefix}, var_build_vars=${var_build_vars}, var_args=${var_args}, args=${ARGN})")
   IF(_moo__gcca_do)
     SET(${var_lang} ${_moo__gcca_langs})
     SET(${var_build_vars} ${_moo__gcca_bvars})
     SET(${var_args} ${_moo__gcca_args})
     #MESSAGE("    var_lang=${_moo__gcca_langs}, var_build_vars=${_moo__gcca_bsfxs}, var_args=${_moo__gcca_args}")
   ELSE(_moo__gcca_do)
     SET(${var_lang})
     SET(${var_build_vars})
     SET(${var_args})
     #MESSAGE("    DISABLED")
   ENDIF(_moo__gcca_do)
 ENDMACRO(_MOO_GET_COMPILER_CONFIG_ARGS)
 MACRO(MOO_ADD_COMPILER_FLAGS)
   _MOO_GET_COMPILER_CONFIG_ARGS(_moo_acf_langs "FLAGS" _moo_acf_bvars _moo_acf_args ${ARGN})
   IF(_moo_acf_args)
     _MOO_JOIN_STRING_LIST(_moo_acf_flags " " ${_moo_acf_args})
     FOREACH(_moo_acf_lang ${_moo_acf_langs})
       FOREACH(_moo_acf_bvar ${_moo_acf_bvars})
         SET(_moo__acf_var CMAKE_${_moo_acf_lang}_${_moo_acf_bvar})
         SET(${_moo__acf_var} "${${_moo__acf_var}} ${_moo_acf_flags}")
         MOO_DEBUG(STATUS "${_moo__acf_var} += ${_moo_acf_flags}")
       ENDFOREACH(_moo_acf_bvar)
     ENDFOREACH(_moo_acf_lang)
   ENDIF(_moo_acf_args)
 ENDMACRO(MOO_ADD_COMPILER_FLAGS)
 INCLUDE(CheckCCompilerFlag)
 INCLUDE(CheckCXXCompilerFlag)
 MACRO(MOO_COMPILER_FLAG_VAR_NAME flag lang var)
   STRING(REGEX REPLACE "[-=]" "_" _moo_cfvn_name MOO_${lang}FLAG${flag})
   STRING(REPLACE "+" "x" _moo_cfvn_name ${_moo_cfvn_name})
   SET(${var} ${_moo_cfvn_name})
 ENDMACRO(MOO_COMPILER_FLAG_VAR_NAME)
 MACRO(MOO_CHECK_COMPILER_FLAGS)
   _MOO_GET_COMPILER_CONFIG_ARGS(_moo_ccf_langs "FLAGS" _moo_ccf_bvars _moo_ccf_args ${ARGN})
   FOREACH(_moo_ccf_lang ${_moo_ccf_langs})
     SET(_moo_ccf_good_flags)
     FOREACH(_moo_ccf_flag ${_moo_ccf_args})
       MOO_COMPILER_FLAG_VAR_NAME(${_moo_ccf_flag} ${_moo_ccf_lang} _moo_ccf_flag_name)
       IF("${_moo_ccf_lang}" STREQUAL "C")
         CHECK_C_COMPILER_FLAG("${_moo_ccf_flag}" ${_moo_ccf_flag_name})
       ELSEIF("${_moo_ccf_lang}" STREQUAL "CXX")
         CHECK_CXX_COMPILER_FLAG("${_moo_ccf_flag}" ${_moo_ccf_flag_name})
       ELSE("${_moo_ccf_lang}" STREQUAL "C")
         MOO_ERROR("Unknown lang '${lang}'")
       ENDIF("${_moo_ccf_lang}" STREQUAL "C")
       IF(${_moo_ccf_flag_name})
         LIST(APPEND _moo_ccf_good_flags "${_moo_ccf_flag}")
       ENDIF(${_moo_ccf_flag_name})
     ENDFOREACH(_moo_ccf_flag)
     IF(_moo_ccf_good_flags)
       _MOO_JOIN_STRING_LIST(_moo_ccf_good_flags " " ${_moo_ccf_good_flags})
       FOREACH(_moo_ccf_bvar ${_moo_ccf_bvars})
         SET(_moo_ccf_flags_var CMAKE_${_moo_ccf_lang}_${_moo_ccf_bvar})
         SET(${_moo_ccf_flags_var} "${${_moo_ccf_flags_var}} ${_moo_ccf_good_flags}")
         MOO_DEBUG(STATUS "${_moo_ccf_flags_var} += ${_moo_ccf_good_flags}")
       ENDFOREACH(_moo_ccf_bvar)
     ENDIF(_moo_ccf_good_flags)
   ENDFOREACH(_moo_ccf_lang)
 ENDMACRO(MOO_CHECK_COMPILER_FLAGS)
 MACRO(MOO_ADD_COMPILE_DEFINITIONS)
   _MOO_GET_COMPILER_CONFIG_ARGS(_moo_acd_langs "COMPILE_DEFINITIONS" _moo_acd_bvars _moo_acd_args ${ARGN})
   SET(_moo_acd_defs)
   FOREACH(_moo_acd_a ${_moo_acd_args})
     STRING(REGEX REPLACE "^(-D|/D)" "" _moo_acd_a "${_moo_acd_a}")
     LIST(APPEND _moo_acd_defs "${_moo_acd_a}")
   ENDFOREACH(_moo_acd_a)
   #MESSAGE("MOO_ADD_COMPILE_DEFINITIONS(${ARGN}) => ${_moo_acd_langs}, ${_moo_acd_bvars}, ${_moo_acd_args}")
   FOREACH(_moo_acd_bvar ${_moo_acd_bvars})
     SET_PROPERTY(DIRECTORY APPEND PROPERTY ${_moo_acd_bvar} ${_moo_acd_defs})
     _MOO_JOIN_STRING_LIST(_moo_acd_defs_string " " ${_moo_acd_defs})
     MOO_DEBUG(STATUS "${_moo_acd_bvar} += ${_moo_acd_defs_string}")
   ENDFOREACH(_moo_acd_bvar)
 ENDMACRO(MOO_ADD_COMPILE_DEFINITIONS)
 ###########################################################################
+#
 # DEBUG
+#
 MOO_ADD_COMPILE_DEFINITIONS(DEBUG -DMOO_DEBUG -DDEBUG -D_DEBUG)
 ###########################################################################
+#
 # GCC
+#
 # Set this first because it may affect checks below
 IF(MOO_DEV_MODE)
   MOO_ADD_COMPILER_FLAGS(GCC -Werror)
 ENDIF(MOO_DEV_MODE)
 MOO_ADD_COMPILER_FLAGS(GCC -Wall -Wextra)
 MOO_CHECK_COMPILER_FLAGS(GCC -fexceptions -fno-strict-aliasing -fno-strict-overflow)
 MOO_CHECK_COMPILER_FLAGS(GCC -Wno-missing-field-initializers -Wno-overlength-strings  -Wno-missing-declarations)
 MOO_CHECK_COMPILER_FLAGS(GCC DEBUG -ftrapv)
 MOO_ADD_COMPILER_FLAGS(GCC CXX -std=c++98 -pedantic)
 MOO_CHECK_COMPILER_FLAGS(GCC CXX -fno-rtti)
 MOO_CHECK_COMPILER_FLAGS(GCC CXX RELEASE -fno-enforce-eh-specs)
 IF(MOO_DEV_MODE)
   MOO_CHECK_COMPILER_FLAGS(GCC
     -Wcast-align -Wlogical-op
     -Wmissing-format-attribute -Wnested-externs -Wlong-long -Wvla
     -Wuninitialized -Winit-self)
   MOO_CHECK_COMPILER_FLAGS(GCC CXX -fno-nonansi-builtins -fno-gnu-keywords)
   MOO_CHECK_COMPILER_FLAGS(GCC CXX
     -Wctor-dtor-privacy -Wnon-virtual-dtor -Wabi
     -Wstrict-null-sentinel -Woverloaded-virtual -Wsign-promo
+  )
 ENDIF(MOO_DEV_MODE)
 ###############################################################################
+#
 # Windows
+#
 MOO_ADD_COMPILE_DEFINITIONS(WIN32 -D__WIN32__ -DWIN32_LEAN_AND_MEAN -DUNICODE -D_UNICODE -DSTRICT)
 MOO_ADD_COMPILER_FLAGS(MSVC /W4 /GS)
 MOO_ADD_COMPILER_FLAGS(MSVC CXX /Zc:wchar_t,forScope /GR /EHc /EHsc)
 MOO_ADD_COMPILER_FLAGS(MSVC
   /wd4221 /wd4204 /wd4996 /wd4244 /wd4055 /wd4127 /wd4100
   /wd4054 /wd4152 /wd4706 /wd4125 /wd4389 /wd4132 /wd4018
+)
 IF(MOO_DEV_MODE)
   MOO_ADD_COMPILER_FLAGS(MSVC /WX)
   MOO_ADD_COMPILER_FLAGS(MSVC DEBUG /RTCsu /RTCc)
 ENDIF(MOO_DEV_MODE)
 ###############################################################################
+#
 # Mac OS X
+#
 IF(APPLE)
   MOO_OPTION(MOO_ENABLE_UNIVERSAL FALSE "Build a universal binary on Mac OS X" HIDDEN !${MOO_OS_DARWIN})
 ENDIF(APPLE)
 IF(APPLE AND MOO_ENABLE_UNIVERSAL)
   SET(CMAKE_OSX_ARCHITECTURES "ppc;i386")
   SET(CMAKE_OSX_SYSROOT "/Developer/SDKs/MacOSX10.4u.sdk")
 ENDIF(APPLE AND MOO_ENABLE_UNIVERSAL)
 ###############################################################################
+#
 # Precompiled headers
+#
 MOO_OPTION(MOO_ENABLE_PCH FALSE "Enable precompiled headers. May be broken.")
 MACRO(__MOO_PCH_GNUCXX_GET_COMPILE_FLAGS outvar target)
   STRING(TOUPPER "CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}" _moo_varname)
   LIST(APPEND ${outvar} ${${_moo_varname}})
   GET_TARGET_PROPERTY(target_type ${target} TYPE)
   IF("${target_type}" STREQUAL "SHARED_LIBRARY")
     LIST(APPEND ${outvar} -fPIC)
   ENDIF("${target_type}" STREQUAL "SHARED_LIBRARY")
   GET_DIRECTORY_PROPERTY(includes INCLUDE_DIRECTORIES)
   FOREACH(item ${includes})
     LIST(APPEND ${outvar} "-I${item}")
   ENDFOREACH(item)
   STRING(TOUPPER "COMPILE_DEFINITIONS_${CMAKE_BUILD_TYPE}" _moo_varname)
   GET_DIRECTORY_PROPERTY(flags ${_moo_varname})
   FOREACH(item ${flags})
     LIST(APPEND ${outvar} "-D${item}")
   ENDFOREACH(item)
   GET_DIRECTORY_PROPERTY(flags COMPILE_DEFINITIONS)
   FOREACH(item ${flags})
     LIST(APPEND ${outvar} "-D${item}")
   ENDFOREACH(item)
   GET_DIRECTORY_PROPERTY(flags DEFINITIONS)
   LIST(APPEND ${outvar} ${flags})
   LIST(APPEND ${outvar} ${CMAKE_CXX_FLAGS} )
   SEPARATE_ARGUMENTS(${outvar})
 ENDMACRO(__MOO_PCH_GNUCXX_GET_COMPILE_FLAGS)
 MACRO(__MOO_PCH_GNUCXX_GET_COMMAND outvar target input output)
   __MOO_PCH_GNUCXX_GET_COMPILE_FLAGS(_moo_compile_flags target)
   SET(_moo_pch_compile_command
     ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} ${_moo_compile_flags} -x c++-header -o ${output} ${input}
+  )
 ENDMACRO(__MOO_PCH_GNUCXX_GET_COMMAND)
 MACRO(__MOO_PRECOMPILE_HEADER_GNUCXX header target)
   SET(_moo_pch_output_dir ${CMAKE_CURRENT_BINARY_DIR}/${header}.gch)
   SET(_moo_pch_output ${_moo_pch_output_dir}/c++)
   SET(_moo_pch_input_s ${CMAKE_CURRENT_SOURCE_DIR}/${header})
   SET(_moo_pch_input_b ${CMAKE_CURRENT_BINARY_DIR}/${header})
   SET(_moo_pch_lib ${target}_pchlib)
   SET_SOURCE_FILES_PROPERTIES(${_moo_pch_input_b} PROPERTIES GENERATED 1)
   MOO_SUBDIR_NAME(_moo_subdir)
   ADD_CUSTOM_COMMAND(OUTPUT ${_moo_pch_input_b}
     COMMAND ${CMAKE_COMMAND} -E copy ${_moo_pch_input_s} ${_moo_pch_input_b}
     DEPENDS ${_moo_pch_input_s}
     COMMENT "Generating ${_moo_subdir}/${header}"
+  )
   ADD_CUSTOM_TARGET(${target}_pch DEPENDS ${_moo_pch_output})
   ADD_DEPENDENCIES(${target} ${target}_pch)
   __MOO_PCH_GNUCXX_GET_COMMAND(_moo_pch_compile_command ${target} ${_moo_pch_input_b} ${_moo_pch_output})
   ADD_CUSTOM_COMMAND(OUTPUT ${_moo_pch_output}
     COMMAND ${CMAKE_COMMAND} -E make_directory ${_moo_pch_output_dir}
     COMMAND ${_moo_pch_compile_command}
     DEPENDS ${_moo_pch_input_s} ${_moo_pch_input_b} # ${_moo_pch_lib}
     COMMENT "Generating ${_moo_subdir}/${header}.gch/c++"
+  )
   GET_TARGET_PROPERTY(_moo_old_flags ${target} COMPILE_FLAGS)
   IF(NOT _moo_old_flags)
     SET(_moo_old_flags)
   ENDIF(NOT _moo_old_flags)
   SET_TARGET_PROPERTIES(${target} PROPERTIES COMPILE_FLAGS
     "-include ${_moo_pch_input_b} -Winvalid-pch ${_moo_old_flags}"
+  )
 ENDMACRO(__MOO_PRECOMPILE_HEADER_GNUCXX)
 MACRO(MOO_PRECOMPILE_HEADER header target)
   IF(MOO_ENABLE_PCH)
     IF(CMAKE_COMPILER_IS_GNUCXX)
       __MOO_PRECOMPILE_HEADER_GNUCXX(${header} ${target})
     ELSE(CMAKE_COMPILER_IS_GNUCXX)
       MESSAGE(STATUS "*** IMPLEMENT ME: precompiled headers for this compiler")
     ENDIF(CMAKE_COMPILER_IS_GNUCXX)
   ENDIF(MOO_ENABLE_PCH)
 ENDMACRO(MOO_PRECOMPILE_HEADER)
 MACRO(_MOO_JOIN_STRING_LIST outvar sep)
   SET(_moo__jsl_result)
   SET(_moo__jsl_first TRUE)
   FOREACH(_moo__jsl_arg ${ARGN})
     IF(_moo__jsl_first)
       SET(_moo__jsl_result "${_moo__jsl_arg}")
       SET(_moo__jsl_first FALSE)
     ELSE(_moo__jsl_first)
       SET(_moo__jsl_result "${_moo__jsl_result}${sep}${_moo__jsl_arg}")
     ENDIF(_moo__jsl_first)
   ENDFOREACH(_moo__jsl_arg)
   SET(${outvar} "${_moo__jsl_result}")
 ENDMACRO(_MOO_JOIN_STRING_LIST)
 MACRO(_MOO_CHECK_COMPILER_LANG lang var)
   STRING(TOUPPER ${lang} _moo__ccl_lang)
   IF("${_moo__ccl_lang}" STREQUAL "ALL")
     SET(_moo__ccl_langs C CXX)
   ELSEIF("${_moo__ccl_lang}" STREQUAL "C" OR "${_moo__ccl_lang}" STREQUAL "CXX")
     SET(_moo__ccl_langs ${_moo__ccl_lang})
   ELSE("${_moo__ccl_lang}" STREQUAL "ALL")
     MOO_ERROR("Invalid lang '${lang}'")
   ENDIF("${_moo__ccl_lang}" STREQUAL "ALL")
   SET(${var} ${_moo__ccl_langs})
 ENDMACRO(_MOO_CHECK_COMPILER_LANG)
 MACRO(_MOO_CHECK_BUILD_TYPE build prefix var)
   STRING(TOUPPER ${build} _moo__cbt_build)
   IF("${_moo__cbt_build}" STREQUAL "ALL")
     SET(_moo__cbt_vars ${prefix})
   ELSEIF("${_moo__cbt_build}" STREQUAL "RELEASE")
     SET(_moo__cbt_vars ${prefix}_RELEASE ${prefix}_RELWITHDEBINFO ${prefix}_MINSIZEREL)
   ELSEIF("${_moo__cbt_build}" STREQUAL "RELEASEONLY")
     SET(_moo__cbt_vars ${prefix}_RELEASE)
   ELSEIF("${_moo__cbt_build}" STREQUAL "DEBUG" OR "${_moo__cbt_build}" STREQUAL "RELWITHDEBINFO" OR "${_moo__cbt_build}" STREQUAL "MINSIZEREL")
     SET(_moo__cbt_vars ${prefix}_${_moo__cbt_build})
   ELSE("${_moo__cbt_build}" STREQUAL "ALL")
     MOO_ERROR("Invalid build type '${build}'")
   ENDIF("${_moo__cbt_build}" STREQUAL "ALL")
   SET(${var} ${_moo__cbt_vars})
 ENDMACRO(_MOO_CHECK_BUILD_TYPE)
 MACRO(_MOO_GET_COMPILER_CONFIG_ARGS var_lang var_build_prefix var_build_vars var_args)
   SET(_moo__gcca_langs C CXX)
   SET(_moo__gcca_args)
   SET(_moo__gcca_do TRUE)
   _MOO_CHECK_BUILD_TYPE("ALL" ${var_build_prefix} _moo__gcca_bvars)
   FOREACH(_moo__gcca_arg ${ARGN})
     IF("${_moo__gcca_arg}" STREQUAL "GCC" OR "${_moo__gcca_arg}" STREQUAL "GNUCC")
       IF(NOT CMAKE_COMPILER_IS_GNUCC)
         SET(_moo__gcca_do FALSE)
       ENDIF(NOT CMAKE_COMPILER_IS_GNUCC)
     ELSEIF("${_moo__gcca_arg}" STREQUAL "MSVC")
       IF(NOT MSVC)
         SET(_moo__gcca_do FALSE)
       ENDIF(NOT MSVC)
     ELSEIF("${_moo__gcca_arg}" STREQUAL "DEBUG" OR "${_moo__gcca_arg}" STREQUAL "RELEASE" OR
            "${_moo__gcca_arg}" STREQUAL "RELEASEONLY" OR "${_moo__gcca_arg}" STREQUAL "RELWITHDEBINFO" OR
            "${_moo__gcca_arg}" STREQUAL "MINSIZEREL")
       _MOO_CHECK_BUILD_TYPE(${_moo__gcca_arg} ${var_build_prefix} _moo__gcca_bvars)
     ELSEIF("${_moo__gcca_arg}" STREQUAL "C" OR "${_moo__gcca_arg}" STREQUAL "CXX")
       SET(_moo__gcca_langs ${_moo__gcca_arg})
     ELSEIF("${_moo__gcca_arg}" STREQUAL "WIN32" OR "${_moo__gcca_arg}" STREQUAL "UNIX")
       IF("${_moo__gcca_arg}" STREQUAL "WIN32" AND NOT WIN32)
 	SET(_moo__gcca_do FALSE)
       ELSEIF("${_moo__gcca_arg}" STREQUAL "UNIX" AND WIN32)
 	SET(_moo__gcca_do FALSE)
       ENDIF("${_moo__gcca_arg}" STREQUAL "WIN32" AND NOT WIN32)
     ELSE("${_moo__gcca_arg}" STREQUAL "GCC" OR "${_moo__gcca_arg}" STREQUAL "GNUCC")
       LIST(APPEND _moo__gcca_args ${_moo__gcca_arg})
     ENDIF("${_moo__gcca_arg}" STREQUAL "GCC" OR "${_moo__gcca_arg}" STREQUAL "GNUCC")
   ENDFOREACH(_moo__gcca_arg)
   #MESSAGE("_MOO_GET_COMPILER_CONFIG_ARGS(var_lang=${var_lang}, var_build_prefix=${var_build_prefix}, var_build_vars=${var_build_vars}, var_args=${var_args}, args=${ARGN})")
   IF(_moo__gcca_do)
     SET(${var_lang} ${_moo__gcca_langs})
     SET(${var_build_vars} ${_moo__gcca_bvars})
     SET(${var_args} ${_moo__gcca_args})
     #MESSAGE("    var_lang=${_moo__gcca_langs}, var_build_vars=${_moo__gcca_bsfxs}, var_args=${_moo__gcca_args}")
   ELSE(_moo__gcca_do)
     SET(${var_lang})
     SET(${var_build_vars})
     SET(${var_args})
     #MESSAGE("    DISABLED")
   ENDIF(_moo__gcca_do)
 ENDMACRO(_MOO_GET_COMPILER_CONFIG_ARGS)
 MACRO(MOO_ADD_COMPILER_FLAGS)
   _MOO_GET_COMPILER_CONFIG_ARGS(_moo_acf_langs "FLAGS" _moo_acf_bvars _moo_acf_args ${ARGN})
   IF(_moo_acf_args)
     _MOO_JOIN_STRING_LIST(_moo_acf_flags " " ${_moo_acf_args})
     FOREACH(_moo_acf_lang ${_moo_acf_langs})
       FOREACH(_moo_acf_bvar ${_moo_acf_bvars})
         SET(_moo__acf_var CMAKE_${_moo_acf_lang}_${_moo_acf_bvar})
         SET(${_moo__acf_var} "${${_moo__acf_var}} ${_moo_acf_flags}")
         MOO_DEBUG(STATUS "${_moo__acf_var} += ${_moo_acf_flags}")
       ENDFOREACH(_moo_acf_bvar)
     ENDFOREACH(_moo_acf_lang)
   ENDIF(_moo_acf_args)
 ENDMACRO(MOO_ADD_COMPILER_FLAGS)
 INCLUDE(CheckCCompilerFlag)
 INCLUDE(CheckCXXCompilerFlag)
 MACRO(MOO_COMPILER_FLAG_VAR_NAME flag lang var)
   STRING(REGEX REPLACE "[-=]" "_" _moo_cfvn_name MOO_${lang}FLAG${flag})
   STRING(REPLACE "+" "x" _moo_cfvn_name ${_moo_cfvn_name})
   SET(${var} ${_moo_cfvn_name})
 ENDMACRO(MOO_COMPILER_FLAG_VAR_NAME)
 MACRO(MOO_CHECK_COMPILER_FLAGS)
   _MOO_GET_COMPILER_CONFIG_ARGS(_moo_ccf_langs "FLAGS" _moo_ccf_bvars _moo_ccf_args ${ARGN})
   FOREACH(_moo_ccf_lang ${_moo_ccf_langs})
     SET(_moo_ccf_good_flags)
     FOREACH(_moo_ccf_flag ${_moo_ccf_args})
       MOO_COMPILER_FLAG_VAR_NAME(${_moo_ccf_flag} ${_moo_ccf_lang} _moo_ccf_flag_name)
       IF("${_moo_ccf_lang}" STREQUAL "C")
         CHECK_C_COMPILER_FLAG("${_moo_ccf_flag}" ${_moo_ccf_flag_name})
       ELSEIF("${_moo_ccf_lang}" STREQUAL "CXX")
         CHECK_CXX_COMPILER_FLAG("${_moo_ccf_flag}" ${_moo_ccf_flag_name})
       ELSE("${_moo_ccf_lang}" STREQUAL "C")
         MOO_ERROR("Unknown lang '${lang}'")
       ENDIF("${_moo_ccf_lang}" STREQUAL "C")
       IF(${_moo_ccf_flag_name})
         LIST(APPEND _moo_ccf_good_flags "${_moo_ccf_flag}")
       ENDIF(${_moo_ccf_flag_name})
     ENDFOREACH(_moo_ccf_flag)
     IF(_moo_ccf_good_flags)
       _MOO_JOIN_STRING_LIST(_moo_ccf_good_flags " " ${_moo_ccf_good_flags})
       FOREACH(_moo_ccf_bvar ${_moo_ccf_bvars})
         SET(_moo_ccf_flags_var CMAKE_${_moo_ccf_lang}_${_moo_ccf_bvar})
         SET(${_moo_ccf_flags_var} "${${_moo_ccf_flags_var}} ${_moo_ccf_good_flags}")
         MOO_DEBUG(STATUS "${_moo_ccf_flags_var} += ${_moo_ccf_good_flags}")
       ENDFOREACH(_moo_ccf_bvar)
     ENDIF(_moo_ccf_good_flags)
   ENDFOREACH(_moo_ccf_lang)
 ENDMACRO(MOO_CHECK_COMPILER_FLAGS)
 MACRO(MOO_ADD_COMPILE_DEFINITIONS)
   _MOO_GET_COMPILER_CONFIG_ARGS(_moo_acd_langs "COMPILE_DEFINITIONS" _moo_acd_bvars _moo_acd_args ${ARGN})
   SET(_moo_acd_defs)
   FOREACH(_moo_acd_a ${_moo_acd_args})
     STRING(REGEX REPLACE "^(-D|/D)" "" _moo_acd_a "${_moo_acd_a}")
     LIST(APPEND _moo_acd_defs "${_moo_acd_a}")
   ENDFOREACH(_moo_acd_a)
   #MESSAGE("MOO_ADD_COMPILE_DEFINITIONS(${ARGN}) => ${_moo_acd_langs}, ${_moo_acd_bvars}, ${_moo_acd_args}")
   FOREACH(_moo_acd_bvar ${_moo_acd_bvars})
     SET_PROPERTY(DIRECTORY APPEND PROPERTY ${_moo_acd_bvar} ${_moo_acd_defs})
     _MOO_JOIN_STRING_LIST(_moo_acd_defs_string " " ${_moo_acd_defs})
     MOO_DEBUG(STATUS "${_moo_acd_bvar} += ${_moo_acd_defs_string}")
   ENDFOREACH(_moo_acd_bvar)
 ENDMACRO(MOO_ADD_COMPILE_DEFINITIONS)
 ###########################################################################
+#
 # DEBUG
+#
 MOO_ADD_COMPILE_DEFINITIONS(DEBUG -DMOO_DEBUG -DDEBUG -D_DEBUG)
 ###########################################################################
+#
 # GCC
+#
 # Set this first because it may affect checks below
 IF(MOO_DEV_MODE)
   MOO_ADD_COMPILER_FLAGS(GCC -Werror)
 ENDIF(MOO_DEV_MODE)
 MOO_ADD_COMPILER_FLAGS(GCC -Wall -Wextra)
 MOO_CHECK_COMPILER_FLAGS(GCC -fexceptions -fno-strict-aliasing -fno-strict-overflow)
 MOO_CHECK_COMPILER_FLAGS(GCC -Wno-missing-field-initializers -Wno-overlength-strings  -Wno-missing-declarations)
 MOO_CHECK_COMPILER_FLAGS(GCC DEBUG -ftrapv)
 MOO_ADD_COMPILER_FLAGS(GCC CXX -std=c++98 -pedantic)
 MOO_CHECK_COMPILER_FLAGS(GCC CXX -fno-rtti)
 MOO_CHECK_COMPILER_FLAGS(GCC CXX RELEASE -fno-enforce-eh-specs)
 IF(MOO_DEV_MODE)
   MOO_CHECK_COMPILER_FLAGS(GCC
     -Wcast-align -Wlogical-op
     -Wmissing-format-attribute -Wnested-externs -Wlong-long -Wvla
     -Wuninitialized -Winit-self)
   MOO_CHECK_COMPILER_FLAGS(GCC CXX -fno-nonansi-builtins -fno-gnu-keywords)
   MOO_CHECK_COMPILER_FLAGS(GCC CXX
     -Wctor-dtor-privacy -Wnon-virtual-dtor -Wabi
     -Wstrict-null-sentinel -Woverloaded-virtual -Wsign-promo
+  )
 ENDIF(MOO_DEV_MODE)
 ###############################################################################
+#
 # Windows
+#
 MOO_ADD_COMPILE_DEFINITIONS(WIN32 -D__WIN32__ -DWIN32_LEAN_AND_MEAN -DUNICODE -D_UNICODE -DSTRICT)
 MOO_ADD_COMPILER_FLAGS(MSVC /W4 /GS)
 MOO_ADD_COMPILER_FLAGS(MSVC CXX /Zc:wchar_t,forScope /GR /EHc /EHsc)
 MOO_ADD_COMPILER_FLAGS(MSVC
   /wd4221 /wd4204 /wd4996 /wd4244 /wd4055 /wd4127 /wd4100
   /wd4054 /wd4152 /wd4706 /wd4125 /wd4389 /wd4132 /wd4018
+)
 IF(MOO_DEV_MODE)
   MOO_ADD_COMPILER_FLAGS(MSVC /WX)
   MOO_ADD_COMPILER_FLAGS(MSVC DEBUG /RTCsu /RTCc)
 ENDIF(MOO_DEV_MODE)
 ###############################################################################
+#
 # Mac OS X
+#
 IF(APPLE)
   MOO_OPTION(MOO_ENABLE_UNIVERSAL FALSE "Build a universal binary on Mac OS X" HIDDEN !${MOO_OS_DARWIN})
 ENDIF(APPLE)
 IF(APPLE AND MOO_ENABLE_UNIVERSAL)
   SET(CMAKE_OSX_ARCHITECTURES "ppc;i386")
   SET(CMAKE_OSX_SYSROOT "/Developer/SDKs/MacOSX10.4u.sdk")
 ENDIF(APPLE AND MOO_ENABLE_UNIVERSAL)
 ###############################################################################
+#
 # Precompiled headers
+#
 MOO_OPTION(MOO_ENABLE_PCH FALSE "Enable precompiled headers. May be broken.")
 MACRO(__MOO_PCH_GNUCXX_GET_COMPILE_FLAGS outvar target)
   STRING(TOUPPER "CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}" _moo_varname)
   LIST(APPEND ${outvar} ${${_moo_varname}})
   GET_TARGET_PROPERTY(target_type ${target} TYPE)
   IF("${target_type}" STREQUAL "SHARED_LIBRARY")
     LIST(APPEND ${outvar} -fPIC)
   ENDIF("${target_type}" STREQUAL "SHARED_LIBRARY")
   GET_DIRECTORY_PROPERTY(includes INCLUDE_DIRECTORIES)
   FOREACH(item ${includes})
     LIST(APPEND ${outvar} "-I${item}")
   ENDFOREACH(item)
   STRING(TOUPPER "COMPILE_DEFINITIONS_${CMAKE_BUILD_TYPE}" _moo_varname)
   GET_DIRECTORY_PROPERTY(flags ${_moo_varname})
   FOREACH(item ${flags})
     LIST(APPEND ${outvar} "-D${item}")
   ENDFOREACH(item)
   GET_DIRECTORY_PROPERTY(flags COMPILE_DEFINITIONS)
   FOREACH(item ${flags})
     LIST(APPEND ${outvar} "-D${item}")
   ENDFOREACH(item)
   GET_DIRECTORY_PROPERTY(flags DEFINITIONS)
   LIST(APPEND ${outvar} ${flags})
   LIST(APPEND ${outvar} ${CMAKE_CXX_FLAGS} )
   SEPARATE_ARGUMENTS(${outvar})
 ENDMACRO(__MOO_PCH_GNUCXX_GET_COMPILE_FLAGS)
 MACRO(__MOO_PCH_GNUCXX_GET_COMMAND outvar target input output)
   __MOO_PCH_GNUCXX_GET_COMPILE_FLAGS(_moo_compile_flags target)
   SET(_moo_pch_compile_command
     ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} ${_moo_compile_flags} -x c++-header -o ${output} ${input}
+  )
 ENDMACRO(__MOO_PCH_GNUCXX_GET_COMMAND)
 MACRO(__MOO_PRECOMPILE_HEADER_GNUCXX header target)
   SET(_moo_pch_output_dir ${CMAKE_CURRENT_BINARY_DIR}/${header}.gch)
   SET(_moo_pch_output ${_moo_pch_output_dir}/c++)
   SET(_moo_pch_input_s ${CMAKE_CURRENT_SOURCE_DIR}/${header})
   SET(_moo_pch_input_b ${CMAKE_CURRENT_BINARY_DIR}/${header})
   SET(_moo_pch_lib ${target}_pchlib)
   SET_SOURCE_FILES_PROPERTIES(${_moo_pch_input_b} PROPERTIES GENERATED 1)
   MOO_SUBDIR_NAME(_moo_subdir)
   ADD_CUSTOM_COMMAND(OUTPUT ${_moo_pch_input_b}
     COMMAND ${CMAKE_COMMAND} -E copy ${_moo_pch_input_s} ${_moo_pch_input_b}
     DEPENDS ${_moo_pch_input_s}
     COMMENT "Generating ${_moo_subdir}/${header}"
+  )
   ADD_CUSTOM_TARGET(${target}_pch DEPENDS ${_moo_pch_output})
   ADD_DEPENDENCIES(${target} ${target}_pch)
   __MOO_PCH_GNUCXX_GET_COMMAND(_moo_pch_compile_command ${target} ${_moo_pch_input_b} ${_moo_pch_output})
   ADD_CUSTOM_COMMAND(OUTPUT ${_moo_pch_output}
     COMMAND ${CMAKE_COMMAND} -E make_directory ${_moo_pch_output_dir}
     COMMAND ${_moo_pch_compile_command}
     DEPENDS ${_moo_pch_input_s} ${_moo_pch_input_b} # ${_moo_pch_lib}
     COMMENT "Generating ${_moo_subdir}/${header}.gch/c++"
+  )
   GET_TARGET_PROPERTY(_moo_old_flags ${target} COMPILE_FLAGS)
   IF(NOT _moo_old_flags)
     SET(_moo_old_flags)
   ENDIF(NOT _moo_old_flags)
   SET_TARGET_PROPERTIES(${target} PROPERTIES COMPILE_FLAGS
     "-include ${_moo_pch_input_b} -Winvalid-pch ${_moo_old_flags}"
+  )
 ENDMACRO(__MOO_PRECOMPILE_HEADER_GNUCXX)
 MACRO(MOO_PRECOMPILE_HEADER header target)
   IF(MOO_ENABLE_PCH)
     IF(CMAKE_COMPILER_IS_GNUCXX)
       __MOO_PRECOMPILE_HEADER_GNUCXX(${header} ${target})
     ELSE(CMAKE_COMPILER_IS_GNUCXX)
       MESSAGE(STATUS "*** IMPLEMENT ME: precompiled headers for this compiler")
     ENDIF(CMAKE_COMPILER_IS_GNUCXX)
   ENDIF(MOO_ENABLE_PCH)
 ENDMACRO(MOO_PRECOMPILE_HEADER)

Up to file-list cmake/modules/FindMooI18n.cmake:

 MOO_OPTION(ENABLE_NLS TRUE "Enable i18n" HEADER TRUE)
 IF(ENABLE_NLS)
   FIND_PACKAGE(Gettext)
   IF(NOT GETTEXT_FOUND)
     MOO_ERROR("Gettext has not been found, translations will not be enabled")
   ENDIF(NOT GETTEXT_FOUND)
 ENDIF(ENABLE_NLS)
 MACRO(MOO_ADD_MSG_CATALOG catalogname dir)
   IF(ENABLE_NLS)
     FILE(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/${dir})
     FILE(GLOB _moo_po_files ${dir}/*.po)
     SET(_moo_langs)
     SET(_moo_gmo_files)
     FOREACH(_moo_po_file ${_moo_po_files})
       GET_FILENAME_COMPONENT(_moo_lang_code ${_moo_po_file} NAME_WE)
       LIST(APPEND _moo_langs ${_moo_lang_code})
       SET(_moo_gmo_file ${CMAKE_BINARY_DIR}/${dir}/${_moo_lang_code}.gmo)
       LIST(APPEND _moo_gmo_files ${_moo_gmo_file})
       ADD_CUSTOM_COMMAND(OUTPUT ${_moo_gmo_file}
                          COMMAND ${GETTEXT_MSGFMT_EXECUTABLE} --check -o ${_moo_gmo_file} ${_moo_po_file}
                          DEPENDS ${_moo_po_file})
       INSTALL(FILES ${_moo_gmo_file} DESTINATION ${LOCALEDIR}/${_moo_lang_code}/LC_MESSAGES/ RENAME ${catalogname}.mo)
     ENDFOREACH(_moo_po_file)
     SET_SOURCE_FILES_PROPERTIES(${_moo_gmo_files} PROPERTIES GENERATED 1 EXTERNAL_OBJECT 1)
     ADD_CUSTOM_TARGET(translations-${catalogname} ALL SOURCES ${_moo_gmo_files})
   ENDIF(ENABLE_NLS)
-ENDMACRO(MOO_ADD_MSG_CATALOG)
+MOO_OPTION(ENABLE_NLS TRUE "Enable i18n" HEADER TRUE)
 IF(ENABLE_NLS)
   FIND_PACKAGE(Gettext)
   IF(NOT GETTEXT_FOUND)
     MOO_ERROR("Gettext has not been found, translations will not be enabled")
   ENDIF(NOT GETTEXT_FOUND)
 ENDIF(ENABLE_NLS)
 MACRO(MOO_ADD_MSG_CATALOG catalogname dir)
   IF(ENABLE_NLS)
     FILE(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/${dir})
     FILE(GLOB _moo_po_files ${dir}/*.po)
     SET(_moo_langs)
     SET(_moo_gmo_files)
     FOREACH(_moo_po_file ${_moo_po_files})
       GET_FILENAME_COMPONENT(_moo_lang_code ${_moo_po_file} NAME_WE)
       LIST(APPEND _moo_langs ${_moo_lang_code})
       SET(_moo_gmo_file ${CMAKE_BINARY_DIR}/${dir}/${_moo_lang_code}.gmo)
       LIST(APPEND _moo_gmo_files ${_moo_gmo_file})
       ADD_CUSTOM_COMMAND(OUTPUT ${_moo_gmo_file}
                          COMMAND ${GETTEXT_MSGFMT_EXECUTABLE} --check -o ${_moo_gmo_file} ${_moo_po_file}
                          DEPENDS ${_moo_po_file})
       INSTALL(FILES ${_moo_gmo_file} DESTINATION ${LOCALEDIR}/${_moo_lang_code}/LC_MESSAGES/ RENAME ${catalogname}.mo)
     ENDFOREACH(_moo_po_file)
     SET_SOURCE_FILES_PROPERTIES(${_moo_gmo_files} PROPERTIES GENERATED 1 EXTERNAL_OBJECT 1)
     ADD_CUSTOM_TARGET(translations-${catalogname} ALL SOURCES ${_moo_gmo_files})
   ENDIF(ENABLE_NLS)
 ENDMACRO(MOO_ADD_MSG_CATALOG)

Up to file-list cmake/modules/FindMooLibXml2.cmake:

 FIND_PACKAGE(LibXml2)
 IF(NOT LIBXML2_FOUND AND WIN32)
   IF(LIBXML2_XMLLINT_EXECUTABLE AND LIBXML2_LIBRARIES)
     GET_FILENAME_COMPONENT(_mpkg_libxml2_path ${LIBXML2_XMLLINT_EXECUTABLE} ABSOLUTE)
     GET_FILENAME_COMPONENT(_mpkg_libxml2_path ${_mpkg_libxml2_path} PATH)
     FIND_PATH(LIBXML2_INCLUDE_DIR libxml/xpath.h HINTS ${_mpkg_libxml2_path}/../include PATH_SUFFIXES libxml2)
     IF(LIBXML2_INCLUDE_DIR)
       SET(LIBXML2_FOUND 1)
     ENDIF(LIBXML2_INCLUDE_DIR)
   ENDIF(LIBXML2_XMLLINT_EXECUTABLE AND LIBXML2_LIBRARIES)
-ENDIF(NOT LIBXML2_FOUND AND WIN32)
+FIND_PACKAGE(LibXml2)
 IF(NOT LIBXML2_FOUND AND WIN32)
   IF(LIBXML2_XMLLINT_EXECUTABLE AND LIBXML2_LIBRARIES)
     GET_FILENAME_COMPONENT(_mpkg_libxml2_path ${LIBXML2_XMLLINT_EXECUTABLE} ABSOLUTE)
     GET_FILENAME_COMPONENT(_mpkg_libxml2_path ${_mpkg_libxml2_path} PATH)
     FIND_PATH(LIBXML2_INCLUDE_DIR libxml/xpath.h HINTS ${_mpkg_libxml2_path}/../include PATH_SUFFIXES libxml2)
     IF(LIBXML2_INCLUDE_DIR)
       SET(LIBXML2_FOUND 1)
     ENDIF(LIBXML2_INCLUDE_DIR)
   ENDIF(LIBXML2_XMLLINT_EXECUTABLE AND LIBXML2_LIBRARIES)
 ENDIF(NOT LIBXML2_FOUND AND WIN32)

Up to file-list cmake/moo-libs.cmake:

 MACRO(MOO_ADD_COMPILE_FLAGS target flags)
   GET_TARGET_PROPERTY(__moo_prop_value ${target} COMPILE_FLAGS)
   IF(__moo_prop_value)
     SET_TARGET_PROPERTIES(${target} PROPERTIES COMPILE_FLAGS "${flags}")
   ELSE(__moo_prop_value)
     SET_TARGET_PROPERTIES(${target} PROPERTIES COMPILE_FLAGS "${__moo_prop_value} ${flags}")
   ENDIF(__moo_prop_value)
 ENDMACRO(MOO_ADD_COMPILE_FLAGS)
 MACRO(MOO_ADD_DEFINITIONS target defs)
   GET_TARGET_PROPERTY(__moo_prop_value ${target} COMPILE_DEFINITIONS)
   IF(__moo_prop_value)
     LIST(APPEND __moo_prop_value ${defs})
   ELSE(__moo_prop_value)
     SET(__moo_prop_value ${defs})
   ENDIF(__moo_prop_value)
   SET_TARGET_PROPERTIES(${target} PROPERTIES COMPILE_DEFINITIONS "${__moo_prop_value}")
 ENDMACRO(MOO_ADD_DEFINITIONS)
 MACRO(MOO_ADD_SOURCE_FILE_SET name subdir)
   _MOO_MODULE_SOURCES_VAR_NAMES(${name} _moo_s _moo_bs _moo_st)
   IF(_moo_code_module_created_${name})
     MESSAGE(FATAL_ERROR "MOO_ADD_SOURCE_FILE_SET(${name}) called twice")
   ENDIF(_moo_code_module_created_${name})
   SET(_moo_code_module_created_${name} 1)
   SET(_moo_source_file_prefix "")
   IF(NOT "" STREQUAL "${subdir}")
     SET(_moo_source_file_prefix "${subdir}/")
   ENDIF(NOT "" STREQUAL "${subdir}")
 #   SET(${name}_cmake_dummy ${CMAKE_CURRENT_BINARY_DIR}/${name}-cmake-dummy.c)
 #   ADD_CUSTOM_COMMAND(OUTPUT ${${name}_cmake_dummy}
 #                      COMMAND ${CMAKE_COMMAND} -D LIBNAME=${name} -D OUTPUT=${${name}_cmake_dummy} -P ${CMAKE_SOURCE_DIR}/moo/gendummy.cmake
 #                      DEPENDS ${${name}_stamps} ${CMAKE_SOURCE_DIR}/moo/gendummy.cmake)
 #   SET_SOURCE_FILES_PROPERTIES(${${name}_cmake_dummy} PROPERTIES GENERATED 1)
   IF(_moo_source_file_prefix)
     SET(_moo_sources_set_tmp ${${_moo_s}})
     SET(${_moo_s})
     FOREACH(_moo_source_file ${_moo_sources_set_tmp})
       LIST(APPEND ${_moo_s} "${_moo_source_file_prefix}${_moo_source_file}")
     ENDFOREACH(_moo_source_file)
   ENDIF(_moo_source_file_prefix)
   LIST(APPEND moo_all_sources ${${_moo_s}} ${${_moo_bs}} ${${_moo_st}})
 ENDMACRO(MOO_ADD_SOURCE_FILE_SET)
 MACRO(MOO_ADD_MOO_CODE_MODULE name)
   SET(_moo_code_module_subdir ${name})
   SET(_moo_arg_next_subdir)
   FOREACH(_moo_arg ${ARGN})
     IF(_moo_arg_next_subdir)
       SET(_moo_code_module_subdir ${_moo_arg})
       SET(_moo_arg_next_subdir)
     ELSEIF("${_moo_arg}" STREQUAL "SUBDIR")
       SET(_moo_arg_next_subdir 1)
     ELSE(_moo_arg_next_subdir)
       MESSAGE(FATAL_ERROR " Invalid argument `${_moo_arg}' to macro MOO_ADD_CODE_MODULE")
     ENDIF(_moo_arg_next_subdir)
   ENDFOREACH(_moo_arg)
   MOO_ADD_SOURCE_FILE_SET(${name} ${_moo_code_module_subdir})
   INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/moo/${_moo_code_module_subdir} ${CMAKE_CURRENT_BINARY_DIR}/${_moo_code_module_subdir})
 ENDMACRO(MOO_ADD_MOO_CODE_MODULE)
 MACRO(MOO_WIN32_RESOURCE rc_in module)
   IF(WIN32)
     SET(_moo_rc_file ${CMAKE_CURRENT_BINARY_DIR}/${module}.rc)
     SET_SOURCE_FILES_PROPERTIES(${_moo_rc_file} PROPERTIES GENERATED 1)
     SET(_moo_res_file ${CMAKE_CURRENT_BINARY_DIR}/${module}.res)
     CONFIGURE_FILE(${rc_in} ${_moo_rc_file} @ONLY)
     _MOO_MODULE_SOURCES_VAR_NAMES(${module} _moo_s _moo_bs _moo_st)
     IF(MSVC)
       LIST(APPEND ${_moo_s} ${_moo_rc_file})
     ELSE(MSVC)
       ADD_CUSTOM_COMMAND(OUTPUT ${_moo_res_file}
         COMMAND ${WINDRES_EXECUTABLE} -i ${_moo_rc_file} --input-format=rc -o ${_moo_res_file} -O coff
         DEPENDS ${_moo_rc_file}
+      )
       SET_SOURCE_FILES_PROPERTIES(${_moo_res_file} PROPERTIES EXTERNAL_OBJECT 1 GENERATED 1)
       LIST(APPEND ${_moo_s} ${_moo_res_file})
       LIST(APPEND ${module}_libs ${_moo_res_file})
       # FIXME rebuilding just doesn't work
     ENDIF(MSVC)
   ENDIF(WIN32)
-ENDMACRO(MOO_WIN32_RESOURCE)
+MACRO(MOO_ADD_COMPILE_FLAGS target flags)
   GET_TARGET_PROPERTY(__moo_prop_value ${target} COMPILE_FLAGS)
   IF(__moo_prop_value)
     SET_TARGET_PROPERTIES(${target} PROPERTIES COMPILE_FLAGS "${flags}")
   ELSE(__moo_prop_value)
     SET_TARGET_PROPERTIES(${target} PROPERTIES COMPILE_FLAGS "${__moo_prop_value} ${flags}")
   ENDIF(__moo_prop_value)
 ENDMACRO(MOO_ADD_COMPILE_FLAGS)
 MACRO(MOO_ADD_DEFINITIONS target defs)
   GET_TARGET_PROPERTY(__moo_prop_value ${target} COMPILE_DEFINITIONS)
   IF(__moo_prop_value)
     LIST(APPEND __moo_prop_value ${defs})
   ELSE(__moo_prop_value)
     SET(__moo_prop_value ${defs})
   ENDIF(__moo_prop_value)
   SET_TARGET_PROPERTIES(${target} PROPERTIES COMPILE_DEFINITIONS "${__moo_prop_value}")
 ENDMACRO(MOO_ADD_DEFINITIONS)
 MACRO(MOO_ADD_SOURCE_FILE_SET name subdir)
   _MOO_MODULE_SOURCES_VAR_NAMES(${name} _moo_s _moo_bs _moo_st)
   IF(_moo_code_module_created_${name})
     MESSAGE(FATAL_ERROR "MOO_ADD_SOURCE_FILE_SET(${name}) called twice")
   ENDIF(_moo_code_module_created_${name})
   SET(_moo_code_module_created_${name} 1)
   SET(_moo_source_file_prefix "")
   IF(NOT "" STREQUAL "${subdir}")
     SET(_moo_source_file_prefix "${subdir}/")
   ENDIF(NOT "" STREQUAL "${subdir}")
 #   SET(${name}_cmake_dummy ${CMAKE_CURRENT_BINARY_DIR}/${name}-cmake-dummy.c)
 #   ADD_CUSTOM_COMMAND(OUTPUT ${${name}_cmake_dummy}
 #                      COMMAND ${CMAKE_COMMAND} -D LIBNAME=${name} -D OUTPUT=${${name}_cmake_dummy} -P ${CMAKE_SOURCE_DIR}/moo/gendummy.cmake
 #                      DEPENDS ${${name}_stamps} ${CMAKE_SOURCE_DIR}/moo/gendummy.cmake)
 #   SET_SOURCE_FILES_PROPERTIES(${${name}_cmake_dummy} PROPERTIES GENERATED 1)
   IF(_moo_source_file_prefix)
     SET(_moo_sources_set_tmp ${${_moo_s}})
     SET(${_moo_s})
     FOREACH(_moo_source_file ${_moo_sources_set_tmp})
       LIST(APPEND ${_moo_s} "${_moo_source_file_prefix}${_moo_source_file}")
     ENDFOREACH(_moo_source_file)
   ENDIF(_moo_source_file_prefix)
   LIST(APPEND moo_all_sources ${${_moo_s}} ${${_moo_bs}} ${${_moo_st}})
 ENDMACRO(MOO_ADD_SOURCE_FILE_SET)
 MACRO(MOO_ADD_MOO_CODE_MODULE name)
   SET(_moo_code_module_subdir ${name})
   SET(_moo_arg_next_subdir)
   FOREACH(_moo_arg ${ARGN})
     IF(_moo_arg_next_subdir)
       SET(_moo_code_module_subdir ${_moo_arg})
       SET(_moo_arg_next_subdir)
     ELSEIF("${_moo_arg}" STREQUAL "SUBDIR")
       SET(_moo_arg_next_subdir 1)
     ELSE(_moo_arg_next_subdir)
       MESSAGE(FATAL_ERROR " Invalid argument `${_moo_arg}' to macro MOO_ADD_CODE_MODULE")
     ENDIF(_moo_arg_next_subdir)
   ENDFOREACH(_moo_arg)
   MOO_ADD_SOURCE_FILE_SET(${name} ${_moo_code_module_subdir})
   INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/moo/${_moo_code_module_subdir} ${CMAKE_CURRENT_BINARY_DIR}/${_moo_code_module_subdir})
 ENDMACRO(MOO_ADD_MOO_CODE_MODULE)
 MACRO(MOO_WIN32_RESOURCE rc_in module)
   IF(WIN32)
     SET(_moo_rc_file ${CMAKE_CURRENT_BINARY_DIR}/${module}.rc)
     SET_SOURCE_FILES_PROPERTIES(${_moo_rc_file} PROPERTIES GENERATED 1)
     SET(_moo_res_file ${CMAKE_CURRENT_BINARY_DIR}/${module}.res)
     CONFIGURE_FILE(${rc_in} ${_moo_rc_file} @ONLY)
     _MOO_MODULE_SOURCES_VAR_NAMES(${module} _moo_s _moo_bs _moo_st)
     IF(MSVC)
       LIST(APPEND ${_moo_s} ${_moo_rc_file})
     ELSE(MSVC)
       ADD_CUSTOM_COMMAND(OUTPUT ${_moo_res_file}
         COMMAND ${WINDRES_EXECUTABLE} -i ${_moo_rc_file} --input-format=rc -o ${_moo_res_file} -O coff
         DEPENDS ${_moo_rc_file}
+      )
       SET_SOURCE_FILES_PROPERTIES(${_moo_res_file} PROPERTIES EXTERNAL_OBJECT 1 GENERATED 1)
       LIST(APPEND ${_moo_s} ${_moo_res_file})
       LIST(APPEND ${module}_libs ${_moo_res_file})
       # FIXME rebuilding just doesn't work
     ENDIF(MSVC)
   ENDIF(WIN32)
 ENDMACRO(MOO_WIN32_RESOURCE)

Up to file-list cmake/moo.cmake:

 MACRO(MOO_DEFINE_VERSIONS name version)
   STRING(REGEX REPLACE "([^.]+)[.].*" "\\1" ${name}_MAJOR_VERSION ${version})
   STRING(REGEX REPLACE "[^.]+[.]([^.]+).*" "\\1" ${name}_MINOR_VERSION ${version})
   STRING(REGEX REPLACE "[^.]+[.][^.]+[.]([^.]+)" "\\1" ${name}_MICRO_VERSION ${version})
   SET(${name}_VERSION "\"${version}\"")
   SET(${name}_VERSION_UNQUOTED "${version}")
 ENDMACRO(MOO_DEFINE_VERSIONS)
 SET(MOO_CMAKE_COMMAND "${CMAKE_COMMAND}"
   -D "MOO_SOURCE_DIR=${MOO_SOURCE_DIR}"
   -D "MOO_BINARY_DIR=${MOO_BINARY_DIR}"
   -D "GLIB_GENMARSHAL_EXECUTABLE=${GLIB_GENMARSHAL_EXECUTABLE}"
   -D "GDK_PIXBUF_CSOURCE_EXECUTABLE=${GDK_PIXBUF_CSOURCE_EXECUTABLE}"
   -D "PKG_CONFIG_EXECUTABLE=${PKG_CONFIG_EXECUTABLE}"
   -D "PYTHON_EXECUTABLE=${PYTHON_EXECUTABLE}"
+)
 ##########################################################################
+#
 # Code modules, automake-style
+#
 MACRO(_MOO_MODULE_SOURCES_VAR_NAMES module out_sources_var out_builtsources_var out_stamps_var)
   STRING(TOUPPER ${module} _moo_module_cap)
   SET(${out_sources_var} ${_moo_module_cap}_SOURCES)
   SET(${out_builtsources_var} ${_moo_module_cap}_BUILT_SOURCES)
   SET(${out_stamps_var} ${_moo_module_cap}_STAMPS)
 ENDMACRO(_MOO_MODULE_SOURCES_VAR_NAMES)
 MACRO(_MOO_ALL_MODULE_SOURCES module outvar)
   _MOO_MODULE_SOURCES_VAR_NAMES(${module} _moo_s _moo_bs _moo_st)
   SET(${outvar} ${${_moo_s}} ${${_moo_bs}} ${${_moo_st}})
 ENDMACRO(_MOO_ALL_MODULE_SOURCES)
 MACRO(MOO_ADD_CLEAN_FILES)
   GET_DIRECTORY_PROPERTY(_moo_clean_files ADDITIONAL_MAKE_CLEAN_FILES)
   FOREACH(_moo_f ${ARGN})
     LIST(APPEND _moo_clean_files ${_moo_f})
   ENDFOREACH(_moo_f)
   SET_DIRECTORY_PROPERTIES(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${_moo_clean_files}")
 ENDMACRO(MOO_ADD_CLEAN_FILES)
 MACRO(MOO_ADD_GENERATED_FILE module stampfile outputfiles)
   FOREACH(_moo_f ${stampfile} ${outputfiles})
     GET_FILENAME_COMPONENT(_moo_d ${_moo_f} ABSOLUTE)
     GET_FILENAME_COMPONENT(_moo_d ${_moo_d} PATH)
     FILE(MAKE_DIRECTORY ${_moo_d})
   ENDFOREACH(_moo_f)
   ADD_CUSTOM_COMMAND(OUTPUT ${stampfile} ${ARGN})
   _MOO_MODULE_SOURCES_VAR_NAMES(${module} _moo_s _moo_bs _moo_st)
   LIST(APPEND ${_moo_st} ${stampfile})
   SET_SOURCE_FILES_PROPERTIES(${stampfile} PROPERTIES EXTERNAL_OBJECT 1 GENERATED 1)
   LIST(APPEND ${_moo_bs} ${outputfiles})
   SET_SOURCE_FILES_PROPERTIES(${outputfiles} PROPERTIES GENERATED 1)
   MOO_ADD_CLEAN_FILES(${stampfile} ${outputfiles})
 ENDMACRO(MOO_ADD_GENERATED_FILE)
 # MACRO(MOO_GENERATE_SOURCE_FILE module)
 #   MOO_COLLECT_ARGS(ARG OUTPUT _moo_output
 #                    ARG COMMAND _moo_command
 #                    ARG WORKING_DIRECTORY _moo_working_directory
 #                    ARG DEPENDS _moo_depends
 #                    ARGN ${ARGN})
+#
 #   SET(_moo_output_tmp ${_moo_output})
 #   FOREACH(_moo_f IN LISTS _moo_output_tmp)
 #   ENDFOREACH(_moo_f)
 #   GET_FILENAME_COMPONENT(VarName FileName
 #                          PATH|ABSOLUTE|NAME|EXT|NAME_WE|REALPATH
 #                          [CACHE])
+#
 # #   FOREACH(_moo_arg ${ARGN})
 # #     IF("${_moo_arg}" STREQUAL "OUTPUT")
 # #       SET(_moo_what OUTPUT)
 # #     ELSEIF("${_moo_arg}" STREQUAL "COMMAND")
 # #       SET(_moo_what COMMAND)
 # #     ELSEIF("${_moo_arg}" STREQUAL "COMMAND")
 # #
 # #     IF(_moo_what EQUAL 0)