10 files changed, 248 insertions, 248 deletions
diff --git a/gr-howto-write-a-block-cmake/CMakeLists.txt b/gr-howto-write-a-block-cmake/CMakeLists.txt
index 9de0614144..b6d9f7bb5e 100644
--- a/gr-howto-write-a-block-cmake/CMakeLists.txt
+++ b/gr-howto-write-a-block-cmake/CMakeLists.txt
@@ -21,34 +21,34 @@
 ########################################################################
 # Project setup
 ########################################################################
-CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
-PROJECT(gr-howto-write-a-block CXX)
-ENABLE_TESTING()
+cmake_minimum_required(VERSION 2.6)
+project(gr-howto-write-a-block CXX)
+enable_testing()
 
 #select the release build type by default to get optimization flags
-IF(NOT CMAKE_BUILD_TYPE)
-   SET(CMAKE_BUILD_TYPE "Release")
-   MESSAGE(STATUS "Build type not specified: defaulting to release.")
-ENDIF(NOT CMAKE_BUILD_TYPE)
-SET(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "")
+if(NOT CMAKE_BUILD_TYPE)
+   set(CMAKE_BUILD_TYPE "Release")
+   message(STATUS "Build type not specified: defaulting to release.")
+endif(NOT CMAKE_BUILD_TYPE)
+set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "")
 
-LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/Modules)
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/Modules)
 
 ########################################################################
 # Compiler specific setup
 ########################################################################
-IF(CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32)
+if(CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32)
     #http://gcc.gnu.org/wiki/Visibility
-    ADD_DEFINITIONS(-fvisibility=hidden)
-ENDIF()
+    add_definitions(-fvisibility=hidden)
+endif()
 
 ########################################################################
 # Find boost
 ########################################################################
-IF(UNIX AND EXISTS "/usr/lib64")
-    LIST(APPEND BOOST_LIBRARYDIR "/usr/lib64") #fedora 64-bit fix
-ENDIF(UNIX AND EXISTS "/usr/lib64")
-SET(Boost_ADDITIONAL_VERSIONS
+if(UNIX AND EXISTS "/usr/lib64")
+    list(APPEND BOOST_LIBRARYDIR "/usr/lib64") #fedora 64-bit fix
+endif(UNIX AND EXISTS "/usr/lib64")
+set(Boost_ADDITIONAL_VERSIONS
     "1.35.0" "1.35" "1.36.0" "1.36" "1.37.0" "1.37" "1.38.0" "1.38" "1.39.0" "1.39"
     "1.40.0" "1.40" "1.41.0" "1.41" "1.42.0" "1.42" "1.43.0" "1.43" "1.44.0" "1.44"
     "1.45.0" "1.45" "1.46.0" "1.46" "1.47.0" "1.47" "1.48.0" "1.48" "1.49.0" "1.49"
@@ -57,37 +57,37 @@ SET(Boost_ADDITIONAL_VERSIONS
     "1.60.0" "1.60" "1.61.0" "1.61" "1.62.0" "1.62" "1.63.0" "1.63" "1.64.0" "1.64"
     "1.65.0" "1.65" "1.66.0" "1.66" "1.67.0" "1.67" "1.68.0" "1.68" "1.69.0" "1.69"
 )
-FIND_PACKAGE(Boost "1.35")
+find_package(Boost "1.35")
 
-IF(NOT Boost_FOUND)
-    MESSAGE(FATAL_ERROR "Boost required to compile howto")
-ENDIF()
+if(NOT Boost_FOUND)
+    message(FATAL_ERROR "Boost required to compile howto")
+endif()
 
 ########################################################################
 # Find gnuradio build dependencies
 ########################################################################
-FIND_PACKAGE(Gruel)
-FIND_PACKAGE(GnuradioCore)
+find_package(Gruel)
+find_package(GnuradioCore)
 
-IF(NOT GRUEL_FOUND)
-    MESSAGE(FATAL_ERROR "Gruel required to compile howto")
-ENDIF()
+if(NOT GRUEL_FOUND)
+    message(FATAL_ERROR "Gruel required to compile howto")
+endif()
 
-IF(NOT GNURADIO_CORE_FOUND)
-    MESSAGE(FATAL_ERROR "GnuRadio Core required to compile howto")
-ENDIF()
+if(NOT GNURADIO_CORE_FOUND)
+    message(FATAL_ERROR "GnuRadio Core required to compile howto")
+endif()
 
 ########################################################################
 # Setup the include and linker paths
 ########################################################################
-INCLUDE_DIRECTORIES(
+include_directories(
     ${CMAKE_SOURCE_DIR}/lib
     ${Boost_INCLUDE_DIRS}
     ${GRUEL_INCLUDE_DIRS}
     ${GNURADIO_CORE_INCLUDE_DIRS}
 )
 
-LINK_DIRECTORIES(
+link_directories(
     ${Boost_LIBRARY_DIRS}
     ${GRUEL_LIBRARY_DIRS}
     ${GNURADIO_CORE_LIBRARY_DIRS}
@@ -96,8 +96,8 @@ LINK_DIRECTORIES(
 ########################################################################
 # Add subdirectories
 ########################################################################
-ADD_SUBDIRECTORY(lib)
-ADD_SUBDIRECTORY(swig)
-ADD_SUBDIRECTORY(python)
-ADD_SUBDIRECTORY(grc)
-ADD_SUBDIRECTORY(apps)
+add_subdirectory(lib)
+add_subdirectory(swig)
+add_subdirectory(python)
+add_subdirectory(grc)
+add_subdirectory(apps)
diff --git a/gr-howto-write-a-block-cmake/apps/CMakeLists.txt b/gr-howto-write-a-block-cmake/apps/CMakeLists.txt
index e89cae26ba..a736fb2d06 100644
--- a/gr-howto-write-a-block-cmake/apps/CMakeLists.txt
+++ b/gr-howto-write-a-block-cmake/apps/CMakeLists.txt
@@ -17,7 +17,7 @@
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 
-INCLUDE(GrPython)
+include(GrPython)
 
 GR_PYTHON_INSTALL(
     PROGRAMS
diff --git a/gr-howto-write-a-block-cmake/cmake/Modules/GrPlatform.cmake b/gr-howto-write-a-block-cmake/cmake/Modules/GrPlatform.cmake
index 85f3186188..ce2e15fefb 100644
--- a/gr-howto-write-a-block-cmake/cmake/Modules/GrPlatform.cmake
+++ b/gr-howto-write-a-block-cmake/cmake/Modules/GrPlatform.cmake
@@ -17,30 +17,30 @@
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 
-IF(DEFINED __INCLUDED_GR_PLATFORM_CMAKE)
-    RETURN()
-ENDIF()
-SET(__INCLUDED_GR_PLATFORM_CMAKE TRUE)
+if(DEFINED __INCLUDED_GR_PLATFORM_CMAKE)
+    return()
+endif()
+set(__INCLUDED_GR_PLATFORM_CMAKE TRUE)
 
 ########################################################################
 # Setup additional defines for OS types
 ########################################################################
-IF(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    SET(LINUX TRUE)
-ENDIF()
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    set(LINUX TRUE)
+endif()
 
-IF(LINUX AND EXISTS "/etc/debian_version")
-    SET(DEBIAN TRUE)
-ENDIF()
+if(LINUX AND EXISTS "/etc/debian_version")
+    set(DEBIAN TRUE)
+endif()
 
-IF(LINUX AND EXISTS "/etc/redhat-release")
-    SET(REDHAT TRUE)
-ENDIF()
+if(LINUX AND EXISTS "/etc/redhat-release")
+    set(REDHAT TRUE)
+endif()
 
 ########################################################################
 # when the library suffix should be 64 (applies to redhat linux family)
 ########################################################################
-IF(NOT DEFINED LIB_SUFFIX AND REDHAT AND CMAKE_SYSTEM_PROCESSOR MATCHES "64$")
-    SET(LIB_SUFFIX 64)
-ENDIF()
-SET(LIB_SUFFIX ${LIB_SUFFIX} CACHE STRING "lib directory suffix")
+if(NOT DEFINED LIB_SUFFIX AND REDHAT AND CMAKE_SYSTEM_PROCESSOR MATCHES "64$")
+    set(LIB_SUFFIX 64)
+endif()
+set(LIB_SUFFIX ${LIB_SUFFIX} CACHE STRING "lib directory suffix")
diff --git a/gr-howto-write-a-block-cmake/cmake/Modules/GrPython.cmake b/gr-howto-write-a-block-cmake/cmake/Modules/GrPython.cmake
index f54dbc9ba7..da0590d42f 100644
--- a/gr-howto-write-a-block-cmake/cmake/Modules/GrPython.cmake
+++ b/gr-howto-write-a-block-cmake/cmake/Modules/GrPython.cmake
@@ -17,10 +17,10 @@
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 
-IF(DEFINED __INCLUDED_GR_PYTHON_CMAKE)
-    RETURN()
-ENDIF()
-SET(__INCLUDED_GR_PYTHON_CMAKE TRUE)
+if(DEFINED __INCLUDED_GR_PYTHON_CMAKE)
+    return()
+endif()
+set(__INCLUDED_GR_PYTHON_CMAKE TRUE)
 
 ########################################################################
 # Setup the python interpreter:
@@ -28,28 +28,28 @@ SET(__INCLUDED_GR_PYTHON_CMAKE TRUE)
 # or finds the interpreter via the built-in cmake module.
 ########################################################################
 #this allows the user to override PYTHON_EXECUTABLE
-IF(PYTHON_EXECUTABLE)
+if(PYTHON_EXECUTABLE)
 
-    SET(PYTHONINTERP_FOUND TRUE)
+    set(PYTHONINTERP_FOUND TRUE)
 
 #otherwise if not set, try to automatically find it
-ELSE(PYTHON_EXECUTABLE)
+else(PYTHON_EXECUTABLE)
 
     #use the built-in find script
-    FIND_PACKAGE(PythonInterp)
+    find_package(PythonInterp)
 
     #and if that fails use the find program routine
-    IF(NOT PYTHONINTERP_FOUND)
-        FIND_PROGRAM(PYTHON_EXECUTABLE NAMES python python2.7 python2.6 python2.5)
-        IF(PYTHON_EXECUTABLE)
-            SET(PYTHONINTERP_FOUND TRUE)
-        ENDIF(PYTHON_EXECUTABLE)
-    ENDIF(NOT PYTHONINTERP_FOUND)
+    if(NOT PYTHONINTERP_FOUND)
+        find_program(PYTHON_EXECUTABLE NAMES python python2.7 python2.6 python2.5)
+        if(PYTHON_EXECUTABLE)
+            set(PYTHONINTERP_FOUND TRUE)
+        endif(PYTHON_EXECUTABLE)
+    endif(NOT PYTHONINTERP_FOUND)
 
-ENDIF(PYTHON_EXECUTABLE)
+endif(PYTHON_EXECUTABLE)
 
 #make the path to the executable appear in the cmake gui
-SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE} CACHE FILEPATH "python interpreter")
+set(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE} CACHE FILEPATH "python interpreter")
 
 ########################################################################
 # Check for the existence of a python module:
@@ -58,10 +58,10 @@ SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE} CACHE FILEPATH "python interpreter")
 # - cmd an additional command to run
 # - have the result variable to set
 ########################################################################
-MACRO(GR_PYTHON_CHECK_MODULE desc mod cmd have)
-    MESSAGE(STATUS "")
-    MESSAGE(STATUS "Python checking for ${desc}")
-    EXECUTE_PROCESS(
+macro(GR_PYTHON_CHECK_MODULE desc mod cmd have)
+    message(STATUS "")
+    message(STATUS "Python checking for ${desc}")
+    execute_process(
         COMMAND ${PYTHON_EXECUTABLE} -c "
 #########################################
 try: import ${mod}
@@ -71,87 +71,87 @@ except: exit(-1)
 #########################################"
         RESULT_VARIABLE ${have}
     )
-    IF(${have} EQUAL 0)
-        MESSAGE(STATUS "Python checking for ${desc} - found")
-        SET(${have} TRUE)
-    ELSE(${have} EQUAL 0)
-        MESSAGE(STATUS "Python checking for ${desc} - not found")
-        SET(${have} FALSE)
-    ENDIF(${have} EQUAL 0)
-ENDMACRO(GR_PYTHON_CHECK_MODULE)
+    if(${have} EQUAL 0)
+        message(STATUS "Python checking for ${desc} - found")
+        set(${have} TRUE)
+    else(${have} EQUAL 0)
+        message(STATUS "Python checking for ${desc} - not found")
+        set(${have} FALSE)
+    endif(${have} EQUAL 0)
+endmacro(GR_PYTHON_CHECK_MODULE)
 
 ########################################################################
 # Sets the python installation directory GR_PYTHON_DIR
 ########################################################################
-EXECUTE_PROCESS(COMMAND ${PYTHON_EXECUTABLE} -c "
+execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "
 from distutils import sysconfig
 print sysconfig.get_python_lib(plat_specific=True, prefix='')
 " OUTPUT_VARIABLE GR_PYTHON_DIR OUTPUT_STRIP_TRAILING_WHITESPACE
 )
-FILE(TO_CMAKE_PATH ${GR_PYTHON_DIR} GR_PYTHON_DIR)
+file(TO_CMAKE_PATH ${GR_PYTHON_DIR} GR_PYTHON_DIR)
 
 ########################################################################
 # Create an always-built target with a unique name
 # Usage: GR_UNIQUE_TARGET(<description> <dependencies list>)
 ########################################################################
-FUNCTION(GR_UNIQUE_TARGET desc)
-    FILE(RELATIVE_PATH reldir ${CMAKE_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR})
-    EXECUTE_PROCESS(COMMAND ${PYTHON_EXECUTABLE} -c "import re, hashlib
+function(GR_UNIQUE_TARGET desc)
+    file(RELATIVE_PATH reldir ${CMAKE_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR})
+    execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import re, hashlib
 unique = hashlib.md5('${reldir}${ARGN}').hexdigest()[:5]
 print(re.sub('\\W', '_', '${desc} ${reldir} ' + unique))"
     OUTPUT_VARIABLE _target OUTPUT_STRIP_TRAILING_WHITESPACE)
-    ADD_CUSTOM_TARGET(${_target} ALL DEPENDS ${ARGN})
-ENDFUNCTION(GR_UNIQUE_TARGET)
+    add_custom_target(${_target} ALL DEPENDS ${ARGN})
+endfunction(GR_UNIQUE_TARGET)
 
 ########################################################################
 # Install python sources (also builds and installs byte-compiled python)
 ########################################################################
-FUNCTION(GR_PYTHON_INSTALL)
-    INCLUDE(CMakeParseArgumentsCopy)
+function(GR_PYTHON_INSTALL)
+    include(CMakeParseArgumentsCopy)
     CMAKE_PARSE_ARGUMENTS(GR_PYTHON_INSTALL "" "DESTINATION;COMPONENT" "FILES;PROGRAMS" ${ARGN})
 
     ####################################################################
-    IF(GR_PYTHON_INSTALL_FILES)
+    if(GR_PYTHON_INSTALL_FILES)
     ####################################################################
-        INSTALL(${ARGN}) #installs regular python files
+        install(${ARGN}) #installs regular python files
 
-        FOREACH(pyfile ${GR_PYTHON_INSTALL_FILES})
-            GET_FILENAME_COMPONENT(pyfile_name ${pyfile} NAME)
-            GET_FILENAME_COMPONENT(pyfile ${pyfile} ABSOLUTE)
-            STRING(REPLACE "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" pycfile "${pyfile}c")
-            LIST(APPEND python_install_gen_targets ${pycfile})
+        foreach(pyfile ${GR_PYTHON_INSTALL_FILES})
+            get_filename_component(pyfile_name ${pyfile} NAME)
+            get_filename_component(pyfile ${pyfile} ABSOLUTE)
+            string(REPLACE "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" pycfile "${pyfile}c")
+            list(APPEND python_install_gen_targets ${pycfile})
 
-            GET_FILENAME_COMPONENT(pycfile_path ${pycfile} PATH)
-            FILE(MAKE_DIRECTORY ${pycfile_path})
+            get_filename_component(pycfile_path ${pycfile} PATH)
+            file(MAKE_DIRECTORY ${pycfile_path})
 
             #create a command to generate the byte-compiled pyc file
-            ADD_CUSTOM_COMMAND(
+            add_custom_command(
                 OUTPUT ${pycfile} DEPENDS ${pyfile}
                 COMMAND ${PYTHON_EXECUTABLE} -c
                 \"import py_compile\; py_compile.compile(file='${pyfile}', cfile='${pycfile}', doraise=True)\"
                 COMMENT "Byte-compiling ${pyfile_name}"
             )
-            INSTALL(FILES ${pycfile}
+            install(FILES ${pycfile}
                 DESTINATION ${GR_PYTHON_INSTALL_DESTINATION}
                 COMPONENT ${GR_PYTHON_INSTALL_COMPONENT}
             )
-        ENDFOREACH(pyfile)
+        endforeach(pyfile)
 
     ####################################################################
-    ELSEIF(GR_PYTHON_INSTALL_PROGRAMS)
+    elseif(GR_PYTHON_INSTALL_PROGRAMS)
     ####################################################################
-        FILE(TO_NATIVE_PATH ${PYTHON_EXECUTABLE} pyexe_native)
+        file(TO_NATIVE_PATH ${PYTHON_EXECUTABLE} pyexe_native)
 
-        FOREACH(pyfile ${GR_PYTHON_INSTALL_PROGRAMS})
-            GET_FILENAME_COMPONENT(pyfile_name ${pyfile} NAME)
-            GET_FILENAME_COMPONENT(pyfile ${pyfile} ABSOLUTE)
-            STRING(REPLACE "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" pyexefile "${pyfile}.exe")
-            LIST(APPEND python_install_gen_targets ${pyexefile})
+        foreach(pyfile ${GR_PYTHON_INSTALL_PROGRAMS})
+            get_filename_component(pyfile_name ${pyfile} NAME)
+            get_filename_component(pyfile ${pyfile} ABSOLUTE)
+            string(REPLACE "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" pyexefile "${pyfile}.exe")
+            list(APPEND python_install_gen_targets ${pyexefile})
 
-            GET_FILENAME_COMPONENT(pyexefile_path ${pyexefile} PATH)
-            FILE(MAKE_DIRECTORY ${pyexefile_path})
+            get_filename_component(pyexefile_path ${pyexefile} PATH)
+            file(MAKE_DIRECTORY ${pyexefile_path})
 
-            ADD_CUSTOM_COMMAND(
+            add_custom_command(
                 OUTPUT ${pyexefile} DEPENDS ${pyfile}
                 COMMAND ${PYTHON_EXECUTABLE} -c
                 \"open('${pyexefile}', 'w').write('\#!${pyexe_native}\\n'+open('${pyfile}').read())\"
@@ -159,19 +159,19 @@ FUNCTION(GR_PYTHON_INSTALL)
             )
 
             #on windows, python files need an extension to execute
-            GET_FILENAME_COMPONENT(pyfile_ext ${pyfile} EXT)
-            IF(WIN32 AND NOT pyfile_ext)
-                SET(pyfile_name "${pyfile_name}.py")
-            ENDIF()
+            get_filename_component(pyfile_ext ${pyfile} EXT)
+            if(WIN32 AND NOT pyfile_ext)
+                set(pyfile_name "${pyfile_name}.py")
+            endif()
 
-            INSTALL(PROGRAMS ${pyexefile} RENAME ${pyfile_name}
+            install(PROGRAMS ${pyexefile} RENAME ${pyfile_name}
                 DESTINATION ${GR_PYTHON_INSTALL_DESTINATION}
                 COMPONENT ${GR_PYTHON_INSTALL_COMPONENT}
             )
-        ENDFOREACH(pyfile)
+        endforeach(pyfile)
 
-    ENDIF()
+    endif()
 
     GR_UNIQUE_TARGET("pygen" ${python_install_gen_targets})
 
-ENDFUNCTION(GR_PYTHON_INSTALL)
+endfunction(GR_PYTHON_INSTALL)
diff --git a/gr-howto-write-a-block-cmake/cmake/Modules/GrSwig.cmake b/gr-howto-write-a-block-cmake/cmake/Modules/GrSwig.cmake
index 0d4cce2b36..0fa1c7b770 100644
--- a/gr-howto-write-a-block-cmake/cmake/Modules/GrSwig.cmake
+++ b/gr-howto-write-a-block-cmake/cmake/Modules/GrSwig.cmake
@@ -17,12 +17,12 @@
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 
-IF(DEFINED __INCLUDED_GR_SWIG_CMAKE)
-    RETURN()
-ENDIF()
-SET(__INCLUDED_GR_SWIG_CMAKE TRUE)
+if(DEFINED __INCLUDED_GR_SWIG_CMAKE)
+    return()
+endif()
+set(__INCLUDED_GR_SWIG_CMAKE TRUE)
 
-INCLUDE(GrPython)
+include(GrPython)
 
 ########################################################################
 # Build a swig target for the common gnuradio use case. Usage:
@@ -35,11 +35,11 @@ INCLUDE(GrPython)
 #   - GR_SWIG_SOURCE_DEPS
 #   - GR_SWIG_TARGET_DEPS
 ########################################################################
-MACRO(GR_SWIG_MAKE name)
-    SET(ifiles ${ARGN})
+macro(GR_SWIG_MAKE name)
+    set(ifiles ${ARGN})
 
     #determine include dependencies for swig file
-    EXECUTE_PROCESS(
+    execute_process(
         COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_BINARY_DIR}/get_swig_deps.py
         "${ifiles}" "${GR_SWIG_INCLUDE_DIRS}"
         OUTPUT_STRIP_TRAILING_WHITESPACE
@@ -48,30 +48,30 @@ MACRO(GR_SWIG_MAKE name)
     )
 
     #append the specified include directories
-    INCLUDE_DIRECTORIES(${GR_SWIG_INCLUDE_DIRS})
-    LIST(APPEND SWIG_MODULE_${name}_EXTRA_DEPS ${GR_SWIG_SOURCE_DEPS})
+    include_directories(${GR_SWIG_INCLUDE_DIRS})
+    list(APPEND SWIG_MODULE_${name}_EXTRA_DEPS ${GR_SWIG_SOURCE_DEPS})
 
-    FIND_PACKAGE(PythonLibs)
-    INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_DIRS})
+    find_package(PythonLibs)
+    include_directories(${PYTHON_INCLUDE_DIRS})
 
     #setup the swig flags with flags and include directories
-    SET(CMAKE_SWIG_FLAGS -fvirtual -modern -keyword -w511 -module ${name} ${GR_SWIG_FLAGS})
-    FOREACH(dir ${GR_SWIG_INCLUDE_DIRS})
-        LIST(APPEND CMAKE_SWIG_FLAGS "-I${dir}")
-    ENDFOREACH(dir)
+    set(CMAKE_SWIG_FLAGS -fvirtual -modern -keyword -w511 -module ${name} ${GR_SWIG_FLAGS})
+    foreach(dir ${GR_SWIG_INCLUDE_DIRS})
+        list(APPEND CMAKE_SWIG_FLAGS "-I${dir}")
+    endforeach(dir)
 
     #set the C++ property on the swig .i file so it builds
-    SET_SOURCE_FILES_PROPERTIES(${ifiles} PROPERTIES CPLUSPLUS ON)
+    set_source_files_properties(${ifiles} PROPERTIES CPLUSPLUS ON)
 
     #setup the actual swig library target to be built
-    INCLUDE(UseSWIG)
+    include(UseSWIG)
     SWIG_ADD_MODULE(${name} python ${ifiles})
     SWIG_LINK_LIBRARIES(${name} ${PYTHON_LIBRARIES} ${GR_SWIG_LIBRARIES})
-    IF(GR_SWIG_TARGET_DEPS)
-        ADD_DEPENDENCIES(${SWIG_MODULE_${name}_REAL_NAME} ${GR_SWIG_TARGET_DEPS})
-    ENDIF(GR_SWIG_TARGET_DEPS)
+    if(GR_SWIG_TARGET_DEPS)
+        add_dependencies(${SWIG_MODULE_${name}_REAL_NAME} ${GR_SWIG_TARGET_DEPS})
+    endif(GR_SWIG_TARGET_DEPS)
 
-ENDMACRO(GR_SWIG_MAKE)
+endmacro(GR_SWIG_MAKE)
 
 ########################################################################
 # Install swig targets generated by GR_SWIG_MAKE. Usage:
@@ -81,25 +81,25 @@ ENDMACRO(GR_SWIG_MAKE)
 #   [COMPONENT component]
 # )
 ########################################################################
-MACRO(GR_SWIG_INSTALL)
+macro(GR_SWIG_INSTALL)
 
-    INCLUDE(CMakeParseArgumentsCopy)
+    include(CMakeParseArgumentsCopy)
     CMAKE_PARSE_ARGUMENTS(GR_SWIG_INSTALL "" "DESTINATION;COMPONENT" "TARGETS" ${ARGN})
 
-    FOREACH(name ${GR_SWIG_INSTALL_TARGETS})
-        INSTALL(TARGETS ${SWIG_MODULE_${name}_REAL_NAME}
+    foreach(name ${GR_SWIG_INSTALL_TARGETS})
+        install(TARGETS ${SWIG_MODULE_${name}_REAL_NAME}
             DESTINATION ${GR_SWIG_INSTALL_DESTINATION}
             COMPONENT ${GR_SWIG_INSTALL_COMPONENT}
         )
 
-        INCLUDE(GrPython)
+        include(GrPython)
         GR_PYTHON_INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name}.py
             DESTINATION ${GR_SWIG_INSTALL_DESTINATION}
             COMPONENT ${GR_SWIG_INSTALL_COMPONENT}
         )
-    ENDFOREACH(name)
+    endforeach(name)
 
-ENDMACRO(GR_SWIG_INSTALL)
+endmacro(GR_SWIG_INSTALL)
 
 ########################################################################
 # Generate a python file that can determine swig dependencies.
@@ -107,7 +107,7 @@ ENDMACRO(GR_SWIG_INSTALL)
 # When you build C++, CMake figures out the header dependencies.
 # This code essentially performs that logic for swig includes.
 ########################################################################
-FILE(WRITE ${CMAKE_BINARY_DIR}/get_swig_deps.py "
+file(WRITE ${CMAKE_BINARY_DIR}/get_swig_deps.py "
 
 import os, sys, re
 
diff --git a/gr-howto-write-a-block-cmake/cmake/Modules/GrTest.cmake b/gr-howto-write-a-block-cmake/cmake/Modules/GrTest.cmake
index e9e2a0c2e2..9ec3141f90 100644
--- a/gr-howto-write-a-block-cmake/cmake/Modules/GrTest.cmake
+++ b/gr-howto-write-a-block-cmake/cmake/Modules/GrTest.cmake
@@ -17,10 +17,10 @@
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 
-IF(DEFINED __INCLUDED_GR_TEST_CMAKE)
-    RETURN()
-ENDIF()
-SET(__INCLUDED_GR_TEST_CMAKE TRUE)
+if(DEFINED __INCLUDED_GR_TEST_CMAKE)
+    return()
+endif()
+set(__INCLUDED_GR_TEST_CMAKE TRUE)
 
 ########################################################################
 # Add a unit test and setup the environment for a unit test.
@@ -31,41 +31,41 @@ SET(__INCLUDED_GR_TEST_CMAKE TRUE)
 # GR_TEST_LIBRARY_DIRS - directories for the library path
 # GR_TEST_PYTHON_DIRS  - directories for the python path
 ########################################################################
-FUNCTION(GR_ADD_TEST test_name)
+function(GR_ADD_TEST test_name)
 
-    IF(WIN32)
+    if(WIN32)
         #Ensure that the build exe also appears in the PATH.
-        LIST(APPEND GR_TEST_TARGET_DEPS ${ARGN})
+        list(APPEND GR_TEST_TARGET_DEPS ${ARGN})
 
         #In the land of windows, all libraries must be in the PATH.
         #Since the dependent libraries are not yet installed,
         #we must manually set them in the PATH to run tests.
         #The following appends the path of a target dependency.
-        FOREACH(target ${GR_TEST_TARGET_DEPS})
-            GET_TARGET_PROPERTY(location ${target} LOCATION)
-            IF(location)
-                GET_FILENAME_COMPONENT(path ${location} PATH)
-                STRING(REGEX REPLACE "\\$\\(.*\\)" ${CMAKE_BUILD_TYPE} path ${path})
-                LIST(APPEND GR_TEST_LIBRARY_DIRS ${path})
-            ENDIF(location)
-        ENDFOREACH(target)
+        foreach(target ${GR_TEST_TARGET_DEPS})
+            get_target_property(location ${target} LOCATION)
+            if(location)
+                get_filename_component(path ${location} PATH)
+                string(REGEX REPLACE "\\$\\(.*\\)" ${CMAKE_BUILD_TYPE} path ${path})
+                list(APPEND GR_TEST_LIBRARY_DIRS ${path})
+            endif(location)
+        endforeach(target)
 
         #SWIG generates the python library files into a subdirectory.
         #Therefore, we must append this subdirectory into PYTHONPATH.
         #Only do this for the python directories matching the following:
-        FOREACH(pydir ${GR_TEST_PYTHON_DIRS})
-            GET_FILENAME_COMPONENT(name ${pydir} NAME)
-            IF(name MATCHES "^(swig|lib|src)$")
-                LIST(APPEND GR_TEST_PYTHON_DIRS ${pydir}/${CMAKE_BUILD_TYPE})
-            ENDIF()
-        ENDFOREACH(pydir)
-    ENDIF(WIN32)
+        foreach(pydir ${GR_TEST_PYTHON_DIRS})
+            get_filename_component(name ${pydir} NAME)
+            if(name MATCHES "^(swig|lib|src)$")
+                list(APPEND GR_TEST_PYTHON_DIRS ${pydir}/${CMAKE_BUILD_TYPE})
+            endif()
+        endforeach(pydir)
+    endif(WIN32)
 
-    FILE(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR} srcdir)
-    FILE(TO_NATIVE_PATH "${GR_TEST_LIBRARY_DIRS}" libpath) #ok to use on dir list?
-    FILE(TO_NATIVE_PATH "${GR_TEST_PYTHON_DIRS}" pypath) #ok to use on dir list?
+    file(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR} srcdir)
+    file(TO_NATIVE_PATH "${GR_TEST_LIBRARY_DIRS}" libpath) #ok to use on dir list?
+    file(TO_NATIVE_PATH "${GR_TEST_PYTHON_DIRS}" pypath) #ok to use on dir list?
 
-    SET(environs "GR_DONT_LOAD_PREFS=1" "srcdir=${srcdir}")
+    set(environs "GR_DONT_LOAD_PREFS=1" "srcdir=${srcdir}")
 
     #http://www.cmake.org/pipermail/cmake/2009-May/029464.html
     #Replaced this add test + set environs code with the shell script generation.
@@ -73,61 +73,61 @@ FUNCTION(GR_ADD_TEST test_name)
     #ADD_TEST(${ARGV})
     #SET_TESTS_PROPERTIES(${test_name} PROPERTIES ENVIRONMENT "${environs}")
 
-    IF(UNIX)
-        SET(binpath "${CMAKE_CURRENT_BINARY_DIR}:$PATH")
+    if(UNIX)
+        set(binpath "${CMAKE_CURRENT_BINARY_DIR}:$PATH")
         #set both LD and DYLD paths to cover multiple UNIX OS library paths
-        LIST(APPEND libpath "$LD_LIBRARY_PATH" "$DYLD_LIBRARY_PATH")
-        LIST(APPEND pypath "$PYTHONPATH")
+        list(APPEND libpath "$LD_LIBRARY_PATH" "$DYLD_LIBRARY_PATH")
+        list(APPEND pypath "$PYTHONPATH")
 
         #replace list separator with the path separator
-        STRING(REPLACE ";" ":" libpath "${libpath}")
-        STRING(REPLACE ";" ":" pypath "${pypath}")
-        LIST(APPEND environs "PATH=${binpath}" "LD_LIBRARY_PATH=${libpath}" "DYLD_LIBRARY_PATH=${libpath}" "PYTHONPATH=${pypath}")
+        string(REPLACE ";" ":" libpath "${libpath}")
+        string(REPLACE ";" ":" pypath "${pypath}")
+        list(APPEND environs "PATH=${binpath}" "LD_LIBRARY_PATH=${libpath}" "DYLD_LIBRARY_PATH=${libpath}" "PYTHONPATH=${pypath}")
 
         #generate a bat file that sets the environment and runs the test
-        FIND_PROGRAM(SHELL sh)
-        SET(sh_file ${CMAKE_CURRENT_BINARY_DIR}/${test_name}_test.sh)
-        FILE(WRITE ${sh_file} "#!${SHELL}\n")
+        find_program(SHELL sh)
+        set(sh_file ${CMAKE_CURRENT_BINARY_DIR}/${test_name}_test.sh)
+        file(WRITE ${sh_file} "#!${SHELL}\n")
         #each line sets an environment variable
-        FOREACH(environ ${environs})
-            FILE(APPEND ${sh_file} "export ${environ}\n")
-        ENDFOREACH(environ)
+        foreach(environ ${environs})
+            file(APPEND ${sh_file} "export ${environ}\n")
+        endforeach(environ)
         #load the command to run with its arguments
-        FOREACH(arg ${ARGN})
-            FILE(APPEND ${sh_file} "${arg} ")
-        ENDFOREACH(arg)
-        FILE(APPEND ${sh_file} "\n")
+        foreach(arg ${ARGN})
+            file(APPEND ${sh_file} "${arg} ")
+        endforeach(arg)
+        file(APPEND ${sh_file} "\n")
 
         #make the shell file executable
-        EXECUTE_PROCESS(COMMAND chmod +x ${sh_file})
+        execute_process(COMMAND chmod +x ${sh_file})
 
-        ADD_TEST(${test_name} ${SHELL} ${sh_file})
+        add_test(${test_name} ${SHELL} ${sh_file})
 
-    ENDIF(UNIX)
+    endif(UNIX)
 
-    IF(WIN32)
-        LIST(APPEND libpath ${DLL_PATHS} "%PATH%")
-        LIST(APPEND pypath "%PYTHONPATH%")
+    if(WIN32)
+        list(APPEND libpath ${DLL_PATHS} "%PATH%")
+        list(APPEND pypath "%PYTHONPATH%")
 
         #replace list separator with the path separator (escaped)
-        STRING(REPLACE ";" "\\;" libpath "${libpath}")
-        STRING(REPLACE ";" "\\;" pypath "${pypath}")
-        LIST(APPEND environs "PATH=${libpath}" "PYTHONPATH=${pypath}")
+        string(REPLACE ";" "\\;" libpath "${libpath}")
+        string(REPLACE ";" "\\;" pypath "${pypath}")
+        list(APPEND environs "PATH=${libpath}" "PYTHONPATH=${pypath}")
 
         #generate a bat file that sets the environment and runs the test
-        SET(bat_file ${CMAKE_CURRENT_BINARY_DIR}/${test_name}_test.bat)
-        FILE(WRITE ${bat_file} "@echo off\n")
+        set(bat_file ${CMAKE_CURRENT_BINARY_DIR}/${test_name}_test.bat)
+        file(WRITE ${bat_file} "@echo off\n")
         #each line sets an environment variable
-        FOREACH(environ ${environs})
-            FILE(APPEND ${bat_file} "SET ${environ}\n")
-        ENDFOREACH(environ)
+        foreach(environ ${environs})
+            file(APPEND ${bat_file} "SET ${environ}\n")
+        endforeach(environ)
         #load the command to run with its arguments
-        FOREACH(arg ${ARGN})
-            FILE(APPEND ${bat_file} "${arg} ")
-        ENDFOREACH(arg)
-        FILE(APPEND ${bat_file} "\n")
+        foreach(arg ${ARGN})
+            file(APPEND ${bat_file} "${arg} ")
+        endforeach(arg)
+        file(APPEND ${bat_file} "\n")
 
-        ADD_TEST(${test_name} ${bat_file})
-    ENDIF(WIN32)
+        add_test(${test_name} ${bat_file})
+    endif(WIN32)
 
-ENDFUNCTION(GR_ADD_TEST)
+endfunction(GR_ADD_TEST)
diff --git a/gr-howto-write-a-block-cmake/grc/CMakeLists.txt b/gr-howto-write-a-block-cmake/grc/CMakeLists.txt
index 2571130792..cc43db7bab 100644
--- a/gr-howto-write-a-block-cmake/grc/CMakeLists.txt
+++ b/gr-howto-write-a-block-cmake/grc/CMakeLists.txt
@@ -17,7 +17,7 @@
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 
-INSTALL(FILES
+install(FILES
     howto_square_ff.xml
     howto_square2_ff.xml
     DESTINATION share/gnuradio/grc/blocks
diff --git a/gr-howto-write-a-block-cmake/lib/CMakeLists.txt b/gr-howto-write-a-block-cmake/lib/CMakeLists.txt
index a2b6da9507..21eb280da9 100644
--- a/gr-howto-write-a-block-cmake/lib/CMakeLists.txt
+++ b/gr-howto-write-a-block-cmake/lib/CMakeLists.txt
@@ -20,16 +20,16 @@
 ########################################################################
 # Setup library
 ########################################################################
-INCLUDE(GrPlatform) #define LIB_SUFFIX
+include(GrPlatform) #define LIB_SUFFIX
 
-ADD_LIBRARY(gnuradio-howto SHARED howto_square_ff.cc howto_square2_ff.cc)
-TARGET_LINK_LIBRARIES(gnuradio-howto ${Boost_LIBRARIES} ${GRUEL_LIBRARIES} ${GNURADIO_CORE_LIBRARIES})
-SET_TARGET_PROPERTIES(gnuradio-howto PROPERTIES DEFINE_SYMBOL "gnuradio_howto_EXPORTS")
+add_library(gnuradio-howto SHARED howto_square_ff.cc howto_square2_ff.cc)
+target_link_libraries(gnuradio-howto ${Boost_LIBRARIES} ${GRUEL_LIBRARIES} ${GNURADIO_CORE_LIBRARIES})
+set_target_properties(gnuradio-howto PROPERTIES DEFINE_SYMBOL "gnuradio_howto_EXPORTS")
 
 ########################################################################
 # Install built library files
 ########################################################################
-INSTALL(TARGETS gnuradio-howto
+install(TARGETS gnuradio-howto
     LIBRARY DESTINATION lib${LIB_SUFFIX} # .so/.dylib file
     ARCHIVE DESTINATION lib${LIB_SUFFIX} # .lib file
     RUNTIME DESTINATION bin              # .dll file
@@ -38,7 +38,7 @@ INSTALL(TARGETS gnuradio-howto
 ########################################################################
 # Install public header files
 ########################################################################
-INSTALL(FILES
+install(FILES
     howto_api.h
     howto_square_ff.h
     howto_square2_ff.h
@@ -48,17 +48,17 @@ INSTALL(FILES
 ########################################################################
 # Build and register unit test
 ########################################################################
-FIND_PACKAGE(Boost COMPONENTS unit_test_framework)
+find_package(Boost COMPONENTS unit_test_framework)
 
-INCLUDE(GrTest)
-SET(GR_TEST_TARGET_DEPS gnuradio-howto)
+include(GrTest)
+set(GR_TEST_TARGET_DEPS gnuradio-howto)
 #turn each test cpp file into an executable with an int main() function
-ADD_DEFINITIONS(-DBOOST_TEST_DYN_LINK -DBOOST_TEST_MAIN)
+add_definitions(-DBOOST_TEST_DYN_LINK -DBOOST_TEST_MAIN)
 
-ADD_EXECUTABLE(qa_howto_square_ff qa_howto_square_ff.cc)
-TARGET_LINK_LIBRARIES(qa_howto_square_ff gnuradio-howto ${Boost_LIBRARIES})
+add_executable(qa_howto_square_ff qa_howto_square_ff.cc)
+target_link_libraries(qa_howto_square_ff gnuradio-howto ${Boost_LIBRARIES})
 GR_ADD_TEST(qa_howto_square_ff qa_howto_square_ff)
 
-ADD_EXECUTABLE(qa_howto_square2_ff qa_howto_square2_ff.cc)
-TARGET_LINK_LIBRARIES(qa_howto_square2_ff gnuradio-howto ${Boost_LIBRARIES})
+add_executable(qa_howto_square2_ff qa_howto_square2_ff.cc)
+target_link_libraries(qa_howto_square2_ff gnuradio-howto ${Boost_LIBRARIES})
 GR_ADD_TEST(qa_howto_square2_ff qa_howto_square2_ff)
diff --git a/gr-howto-write-a-block-cmake/python/CMakeLists.txt b/gr-howto-write-a-block-cmake/python/CMakeLists.txt
index 6208f8a870..5da80ef15c 100644
--- a/gr-howto-write-a-block-cmake/python/CMakeLists.txt
+++ b/gr-howto-write-a-block-cmake/python/CMakeLists.txt
@@ -20,10 +20,10 @@
 ########################################################################
 # Include python install macros
 ########################################################################
-INCLUDE(GrPython)
-IF(NOT PYTHONINTERP_FOUND)
-    RETURN()
-ENDIF()
+include(GrPython)
+if(NOT PYTHONINTERP_FOUND)
+    return()
+endif()
 
 ########################################################################
 # Install python sources
@@ -37,8 +37,8 @@ GR_PYTHON_INSTALL(
 ########################################################################
 # Handle the unit tests
 ########################################################################
-INCLUDE(GrTest)
+include(GrTest)
 
-SET(GR_TEST_TARGET_DEPS gnuradio-howto)
-SET(GR_TEST_PYTHON_DIRS ${CMAKE_BINARY_DIR}/swig)
+set(GR_TEST_TARGET_DEPS gnuradio-howto)
+set(GR_TEST_PYTHON_DIRS ${CMAKE_BINARY_DIR}/swig)
 GR_ADD_TEST(qa_howto ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/qa_howto.py)
diff --git a/gr-howto-write-a-block-cmake/swig/CMakeLists.txt b/gr-howto-write-a-block-cmake/swig/CMakeLists.txt
index fdf8d8c482..cd32536668 100644
--- a/gr-howto-write-a-block-cmake/swig/CMakeLists.txt
+++ b/gr-howto-write-a-block-cmake/swig/CMakeLists.txt
@@ -20,22 +20,22 @@
 ########################################################################
 # Include swig generation macros
 ########################################################################
-FIND_PACKAGE(SWIG)
-FIND_PACKAGE(PythonLibs)
-IF(NOT SWIG_FOUND OR NOT PYTHONLIBS_FOUND)
-    RETURN()
-ENDIF()
-INCLUDE(GrSwig)
-INCLUDE(GrPython)
+find_package(SWIG)
+find_package(PythonLibs)
+if(NOT SWIG_FOUND OR NOT PYTHONLIBS_FOUND)
+    return()
+endif()
+include(GrSwig)
+include(GrPython)
 
 ########################################################################
 # Setup swig generation
 ########################################################################
-FOREACH(incdir ${GNURADIO_CORE_INCLUDE_DIRS})
-    LIST(APPEND GR_SWIG_INCLUDE_DIRS ${incdir}/swig)
-ENDFOREACH(incdir)
+foreach(incdir ${GNURADIO_CORE_INCLUDE_DIRS})
+    list(APPEND GR_SWIG_INCLUDE_DIRS ${incdir}/swig)
+endforeach(incdir)
 
-SET(GR_SWIG_LIBRARIES gnuradio-howto)
+set(GR_SWIG_LIBRARIES gnuradio-howto)
 
 GR_SWIG_MAKE(howto_swig howto_swig.i)
 
@@ -47,7 +47,7 @@ GR_SWIG_INSTALL(TARGETS howto_swig DESTINATION ${GR_PYTHON_DIR}/howto)
 ########################################################################
 # Install swig .i files for development
 ########################################################################
-INSTALL(
+install(
     FILES
     howto_swig.i
     howto_square_ff.i