Nevermind, after discussion with Sean the idea is to baseline on C89 and then move forward, not continually maintain support for various standards. (svn branch delete)

svn:revision:58033
svn:branch:compiler-flags
svn:account:starseeker

misc/CMake/BRLCAD_CompilerFlags.cmake

@@ -40,23 +40,23 @@
 # -fast-math results in non-IEEE floating point math among a handful
 # of other optimizations that cause substantial error in ray tracing
 # and tessellation (and probably more).
-BRLCAD_CHECK_C_FLAG(O3 GROUPS OPTIMIZE_C_FLAGS)
-BRLCAD_CHECK_C_FLAG(fstrength-reduce GROUPS OPTIMIZE_C_FLAGS)
-BRLCAD_CHECK_C_FLAG(fexpensive-optimizations GROUPS OPTIMIZE_C_FLAGS)
-BRLCAD_CHECK_C_FLAG(finline-functions GROUPS OPTIMIZE_C_FLAGS)
-BRLCAD_CHECK_C_FLAG("finline-limit=10000 --param inline-unit-growth=300 --param large-function-growth=300" GROUPS OPTIMIZE_C_FLAGS)
-BRLCAD_CHECK_CXX_FLAG(O3 GROUPS OPTIMIZE_CXX_FLAGS)
-BRLCAD_CHECK_CXX_FLAG(fstrength-reduce GROUPS OPTIMIZE_CXX_FLAGS)
-BRLCAD_CHECK_CXX_FLAG(fexpensive-optimizations GROUPS OPTIMIZE_CXX_FLAGS)
-BRLCAD_CHECK_CXX_FLAG(finline-functions GROUPS OPTIMIZE_CXX_FLAGS)
-BRLCAD_CHECK_CXX_FLAG("finline-limit=10000 --param inline-unit-growth=300 --param large-function-growth=300" GROUPS OPTIMIZE_CXX_FLAGS)
+CHECK_C_FLAG(O3 GROUPS OPTIMIZE_C_FLAGS)
+CHECK_C_FLAG(fstrength-reduce GROUPS OPTIMIZE_C_FLAGS)
+CHECK_C_FLAG(fexpensive-optimizations GROUPS OPTIMIZE_C_FLAGS)
+CHECK_C_FLAG(finline-functions GROUPS OPTIMIZE_C_FLAGS)
+CHECK_C_FLAG("finline-limit=10000 --param inline-unit-growth=300 --param large-function-growth=300" GROUPS OPTIMIZE_C_FLAGS)
+CHECK_CXX_FLAG(O3 GROUPS OPTIMIZE_CXX_FLAGS)
+CHECK_CXX_FLAG(fstrength-reduce GROUPS OPTIMIZE_CXX_FLAGS)
+CHECK_CXX_FLAG(fexpensive-optimizations GROUPS OPTIMIZE_CXX_FLAGS)
+CHECK_CXX_FLAG(finline-functions GROUPS OPTIMIZE_CXX_FLAGS)
+CHECK_CXX_FLAG("finline-limit=10000 --param inline-unit-growth=300 --param large-function-growth=300" GROUPS OPTIMIZE_CXX_FLAGS)
 if(${BRLCAD_OPTIMIZED_BUILD} MATCHES "ON")
   if(NOT BRLCAD_ENABLE_PROFILING AND NOT BRLCAD_FLAGS_DEBUG)
-    BRLCAD_CHECK_C_FLAG(fomit-frame-pointer GROUPS OPTIMIZE_C_FLAGS)
-    BRLCAD_CHECK_CXX_FLAG(fomit-frame-pointer GROUPS OPTIMIZE_CXX_FLAGS)
+    CHECK_C_FLAG(fomit-frame-pointer GROUPS OPTIMIZE_C_FLAGS)
+    CHECK_CXX_FLAG(fomit-frame-pointer GROUPS OPTIMIZE_CXX_FLAGS)
   else(NOT BRLCAD_ENABLE_PROFILING AND NOT BRLCAD_FLAGS_DEBUG)
-    BRLCAD_CHECK_C_FLAG(fno-omit-frame-pointer GROUPS OPTIMIZE_C_FLAGS)
-    BRLCAD_CHECK_CXX_FLAG(fno-omit-frame-pointer GROUPS OPTIMIZE_CXX_FLAGS)
+    CHECK_C_FLAG(fno-omit-frame-pointer GROUPS OPTIMIZE_C_FLAGS)
+    CHECK_CXX_FLAG(fno-omit-frame-pointer GROUPS OPTIMIZE_CXX_FLAGS)
   endif(NOT BRLCAD_ENABLE_PROFILING AND NOT BRLCAD_FLAGS_DEBUG)
 endif(${BRLCAD_OPTIMIZED_BUILD} MATCHES "ON")
 
@@ -83,11 +83,11 @@ endif(opt_conf_list)
 # only when compiling unoptimized (because the extra barrier checks
 # can affect the memory footprint and runtime performance.
 if(${BRLCAD_OPTIMIZED_BUILD} MATCHES "OFF" AND BRLCAD_FLAGS_DEBUG)
-  BRLCAD_CHECK_C_FLAG(fstack-protector-all)
-  BRLCAD_CHECK_CXX_FLAG(fstack-protector-all)
+  CHECK_C_FLAG(fstack-protector-all)
+  CHECK_CXX_FLAG(fstack-protector-all)
   # checking both in case compiling c/c++ with different compilers
-  BRLCAD_CHECK_C_FLAG(qstackprotect)
-  BRLCAD_CHECK_CXX_FLAG(qstackprotect)
+  CHECK_C_FLAG(qstackprotect)
+  CHECK_CXX_FLAG(qstackprotect)
 endif(${BRLCAD_OPTIMIZED_BUILD} MATCHES "OFF" AND BRLCAD_FLAGS_DEBUG)
 
 # verbose warning flags.  we intentionally try to turn on as many as
@@ -97,57 +97,57 @@ if(BRLCAD_ENABLE_COMPILER_WARNINGS OR BRLCAD_ENABLE_STRICT)
   # also of interest:
   # -Wunreachable-code -Wmissing-declarations -Wmissing-prototypes -Wstrict-prototypes -ansi
   # -Wformat=2 (after bu_fopen_uniq() is obsolete) -Wdocumentation (for Doxygen comments)
-  BRLCAD_CHECK_C_FLAG(pedantic)
-  BRLCAD_CHECK_CXX_FLAG(pedantic)
+  CHECK_C_FLAG(pedantic)
+  CHECK_CXX_FLAG(pedantic)
 
   # FIXME: The Wall warnings are too verbose with Visual C++ (for
   # now).  we have a lot to clean up.
   if(NOT MSVC)
-    BRLCAD_CHECK_C_FLAG(Wall)
-    BRLCAD_CHECK_CXX_FLAG(Wall)
+    CHECK_C_FLAG(Wall)
+    CHECK_CXX_FLAG(Wall)
   else(NOT MSVC)
-    BRLCAD_CHECK_C_FLAG(W4)
-    BRLCAD_CHECK_CXX_FLAG(W4)
+    CHECK_C_FLAG(W4)
+    CHECK_CXX_FLAG(W4)
   endif(NOT MSVC)
 
-  BRLCAD_CHECK_C_FLAG(Wextra)
-  BRLCAD_CHECK_CXX_FLAG(Wextra)
+  CHECK_C_FLAG(Wextra)
+  CHECK_CXX_FLAG(Wextra)
 
-  BRLCAD_CHECK_C_FLAG(Wundef)
-  BRLCAD_CHECK_CXX_FLAG(Wundef)
+  CHECK_C_FLAG(Wundef)
+  CHECK_CXX_FLAG(Wundef)
 
-  BRLCAD_CHECK_C_FLAG(Wfloat-equal)
-  BRLCAD_CHECK_CXX_FLAG(Wfloat-equal)
+  CHECK_C_FLAG(Wfloat-equal)
+  CHECK_CXX_FLAG(Wfloat-equal)
 
-  BRLCAD_CHECK_C_FLAG(Wshadow)
-  BRLCAD_CHECK_CXX_FLAG(Wshadow)
+  CHECK_C_FLAG(Wshadow)
+  CHECK_CXX_FLAG(Wshadow)
 
 # report where we throw away const
-#  BRLCAD_CHECK_C_FLAG(Wcast-qual)
-#  BRLCAD_CHECK_CXX_FLAG(Wcast-qual)
+#  CHECK_C_FLAG(Wcast-qual)
+#  CHECK_CXX_FLAG(Wcast-qual)
 
 # check for redundant declarations
-#  BRLCAD_CHECK_C_FLAG(Wredundant-decls)
-#  BRLCAD_CHECK_CXX_FLAG(Wredundant-decls)
+#  CHECK_C_FLAG(Wredundant-decls)
+#  CHECK_CXX_FLAG(Wredundant-decls)
 
   # want C inline warnings, but versions of g++ (circa 4.7) spew
   # unquellable bogus warnings on default constructors that we don't
   # have access to (e.g., in opennurbs and boost), so turn them off
-  BRLCAD_CHECK_C_FLAG(Winline)
-  BRLCAD_CHECK_CXX_FLAG(Wno-inline)
+  CHECK_C_FLAG(Winline)
+  CHECK_CXX_FLAG(Wno-inline)
 
   # Need this for tcl.h
-  BRLCAD_CHECK_C_FLAG(Wno-long-long)
-  BRLCAD_CHECK_CXX_FLAG(Wno-long-long)
+  CHECK_C_FLAG(Wno-long-long)
+  CHECK_CXX_FLAG(Wno-long-long)
 
   # Need this for X11 headers using variadic macros
-  BRLCAD_CHECK_C_FLAG(Wno-variadic-macros)
-  BRLCAD_CHECK_CXX_FLAG(Wno-variadic-macros)
+  CHECK_C_FLAG(Wno-variadic-macros)
+  CHECK_CXX_FLAG(Wno-variadic-macros)
 endif(BRLCAD_ENABLE_COMPILER_WARNINGS OR BRLCAD_ENABLE_STRICT)
 
 if(BRLCAD_ENABLE_STRICT)
-  BRLCAD_CHECK_C_FLAG(Werror)
-  BRLCAD_CHECK_CXX_FLAG(Werror)
+  CHECK_C_FLAG(Werror)
+  CHECK_CXX_FLAG(Werror)
 endif(BRLCAD_ENABLE_STRICT)
 
 # End detection of flags intended for BRL-CAD use.  Make sure all variables have

misc/CMake/BRLCAD_Summary.cmake

@@ -237,8 +237,8 @@ set(BRLCAD_ARCH_BITSETTING_LABEL "Build 32/64-bit release ")
 set(BRLCAD_OPTIMIZED_BUILD_LABEL "Build optimized release ")
 set(BRLCAD_FLAGS_DEBUG_LABEL "Build debuggable release")
 set(BRLCAD_ENABLE_PROFILING_LABEL "Build profile release ")
-set(ENABLE_POSIX_COMPLIANCE_LABEL "Build with strict POSIX compliance checking ")
-set(ENABLE_C99_COMPLIANCE_LABEL "Build with strict C99 compliance checking ")
+set(C_COMPILER_STANDARD_LABEL "C compiler standard ")
+set(CXX_COMPILER_STANDARD_LABEL "C++ compiler standard")
 set(BRLCAD_ENABLE_SMP_LABEL "Build SMP-capable release ")
 set(BUILD_STATIC_LIBS_LABEL "Build static libraries ")
 set(BUILD_SHARED_LIBS_LABEL "Build dynamic libraries ")
@@ -262,7 +262,7 @@ set(OTHER_REPORT_ITEMS
     BRLCAD_ENABLE_SMP BUILD_STATIC_LIBS BUILD_SHARED_LIBS
     BRLCAD_ENABLE_COMPILER_WARNINGS BRLCAD_ENABLE_VERBOSE_PROGRESS
     BRLCAD_INSTALL_EXAMPLE_GEOMETRY BRLCAD_DOCBOOK_BUILD
-    ENABLE_POSIX_COMPLIANCE ENABLE_C99_COMPLIANCE)
+    C_COMPILER_STANDARD CXX_COMPILER_STANDARD)
 
 # Construct list of all items
 set(ALL_ITEMS)

misc/CMake/CompilerFlags.cmake

@@ -81,9 +81,9 @@ macro(CHECK_COMPILER_FLAG FLAG_LANG NEW_FLAG RESULTVAR)
 endmacro(CHECK_COMPILER_FLAG LANG NEW_FLAG RESULTVAR)
 
 
-# Synopsis:  BRLCAD_CHECK_FLAG(LANG flag [BUILD_TYPES type1 type2 ...] [GROUPS group1 group2 ...] [VARS var1 var2 ...] )
+# Synopsis:  CHECK_FLAG(LANG flag [BUILD_TYPES type1 type2 ...] [GROUPS group1 group2 ...] [VARS var1 var2 ...] )
 #
-# BRLCAD_CHECK_FLAG is BRL-CAD's core macro for C/C++ flag testing.
+# CHECK_FLAG is BRL-CAD's core macro for C/C++ flag testing.
 # The first value is the language to test (C or C++ currently).  The
 # second entry is the flag (without preliminary dash).
 #
@@ -102,21 +102,21 @@ endmacro(CHECK_COMPILER_FLAG LANG NEW_FLAG RESULTVAR)
 # For example, to test a flag and add it to the C Debug configuration
 # flags:
 #
-# BRLCAD_CHECK_FLAG(C ggdb3 BUILD_TYPES Debug)
+# CHECK_FLAG(C ggdb3 BUILD_TYPES Debug)
 #
 # To assign a C flag to a unique variable:
 #
-# BRLCAD_CHECK_FLAG(C c99 VARS C99_FLAG)
+# CHECK_FLAG(C c99 VARS C99_FLAG)
 #
 # To do all assignments at once, for multiple configs and vars:
 #
-# BRLCAD_CHECK_FLAG(C ggdb3
+# CHECK_FLAG(C ggdb3
 #                   BUILD_TYPES Debug Release
 #                   GROUPS DEBUG_FLAGS
 #                   VARS DEBUG1 DEBUG2)
 
 include (CMakeParseArguments)
-macro(BRLCAD_CHECK_FLAG)
+macro(CHECK_FLAG)
   # Set up some variables and names
   set(FLAG_LANG ${ARGV0})
   set(flag ${ARGV1})
@@ -172,16 +172,16 @@ macro(BRLCAD_CHECK_FLAG)
     endforeach(flag_var ${FLAG_VARS})
   endif(${ARGC} LESS 3)
 
-endmacro(BRLCAD_CHECK_FLAG)
+endmacro(CHECK_FLAG)
 
 # Convenience wrappers to call the primary checking function with a
 # default language.
-macro(BRLCAD_CHECK_C_FLAG)
-  BRLCAD_CHECK_FLAG(C ${ARGN})
-endmacro(BRLCAD_CHECK_C_FLAG)
-macro(BRLCAD_CHECK_CXX_FLAG)
-  BRLCAD_CHECK_FLAG(CXX ${ARGN})
-endmacro(BRLCAD_CHECK_CXX_FLAG)
+macro(CHECK_C_FLAG)
+  CHECK_FLAG(C ${ARGN})
+endmacro(CHECK_C_FLAG)
+macro(CHECK_CXX_FLAG)
+  CHECK_FLAG(CXX ${ARGN})
+endmacro(CHECK_CXX_FLAG)
 
 # Clear out most CMake-assigned defaults - We're managing
 # our own compile flags, and don't (for example) want NDEBUG
@@ -215,93 +215,101 @@ set(CMAKE_CXX_FLAGS "$ENV{CXXFLAGS}")
 set(CMAKE_SHARED_LINKER_FLAGS "$ENV{LDFLAGS}")
 #set(CMAKE_EXE_LINKER_FLAGS "")
 
+# Check for c90 support with gnu extensions if we're not building for
+# a release so we get more broad portability testing.  Since the
+# default is debug, it will be the more difficult to keep working
+# given it's the lesser feature-rich C standard.
+
+# If nothing has been specified, set a default
+set(USING_DEFAULT_C_STANDARD 0)
+set(USING_DEFAULT_CXX_STANDARD 0)
+if(NOT DEFINED C_COMPILER_STANDARD OR "${C_COMPILER_STANDARD}" STREQUAL "")
+  set(C_COMPILER_STANDARD "C89" CACHE STRING "Default C Standard" FORCE)
+  set(USING_DEFAULT_C_STANDARD 1)
+else(NOT DEFINED C_COMPILER_STANDARD OR "${C_COMPILER_STANDARD}" STREQUAL "")
+  string(TOUPPER "${C_COMPILER_STANDARD}" C_COMPILER_STANDARD)
+  set(C_COMPILER_STANDARD "${C_COMPILER_STANDARD" CACHE STRING "C Standard" FORCE)
+endif(NOT DEFINED C_COMPILER_STANDARD OR "${C_COMPILER_STANDARD}" STREQUAL "")
+if(NOT DEFINED CXX_COMPILER_STANDARD OR "${CXX_COMPILER_STANDARD}" STREQUAL "")
+  set(CXX_COMPILER_STANDARD "C++98" CACHE STRING "Default CXX Standard" FORCE)
+  set(USING_DEFAULT_CXX_STANDARD 1)
+else(NOT DEFINED CXX_COMPILER_STANDARD OR "${CXX_COMPILER_STANDARD}" STREQUAL "")
+  string(TOUPPER "${CXX_COMPILER_STANDARD}" CXX_COMPILER_STANDARD)
+  set(CXX_COMPILER_STANDARD "${CXX_COMPILER_STANDARD" CACHE STRING "CXX Standard" FORCE)
+endif(NOT DEFINED CXX_COMPILER_STANDARD OR "${CXX_COMPILER_STANDARD}" STREQUAL "")
+if("${CMAKE_BUILD_TYPE}" STREQUAL "Release" AND USING_DEFAULT_C_STANDARD)
+  set(C_COMPILER_STANDARD "C99" CACHE STRING "Default C Standard" FORCE)
+endif("${CMAKE_BUILD_TYPE}" STREQUAL "Release" AND USING_DEFAULT_C_STANDARD)
+set(C_STD_OPTS "C89" "C99" "C11")
+set(CXX_STD_OPTS "C++98" "C++03" "C++11")
+if(CMAKE_COMPILER_IS_GNUCC)
+  set(C_COMPILER_OPTS "GNU89" "GNU99" "GNU11")
+endif(CMAKE_COMPILER_IS_GNUCC)
+if(CMAKE_COMPILER_IS_GNUCXX)
+  set(CXX_COMPILER_OPTS "GNU++98" "GNU++11")
+endif(CMAKE_COMPILER_IS_GNUCXX)
+
+set_property(CACHE C_COMPILER_STANDARD PROPERTY STRINGS ${C_STD_OPTS} ${C_COMPILER_OPTS})
+set_property(CACHE CXX_COMPILER_STANDARD PROPERTY STRINGS ${CXX_STD_OPTS} ${CXX_COMPILER_OPTS})
+
+CHECK_C_FLAG("pedantic")
+string(TOLOWER "${C_COMPILER_STANDARD}" C_STD_FLAG_INPUT)
+CHECK_C_FLAG("std=${C_STD_FLAG_INPUT}" BUILD_TYPES Debug)
+CHECK_C_FLAG("std=gnu99" BUILD_TYPES Release VARS C99_FLAG)
+CHECK_C_FLAG("D_POSIX_C_SOURCE=200112L")
+
 # try to use -pipe to speed up the compiles
-BRLCAD_CHECK_C_FLAG(pipe)
-BRLCAD_CHECK_CXX_FLAG(pipe)
+CHECK_C_FLAG(pipe)
+CHECK_CXX_FLAG(pipe)
 
 # check for -fno-strict-aliasing
 # XXX - THIS FLAG IS REQUIRED if any level of optimization is
 # enabled with GCC as we do use aliasing and type-punning.
-BRLCAD_CHECK_C_FLAG(fno-strict-aliasing)
-BRLCAD_CHECK_CXX_FLAG(fno-strict-aliasing)
+CHECK_C_FLAG(fno-strict-aliasing)
+CHECK_CXX_FLAG(fno-strict-aliasing)
 
 # check for -fno-common (libtcl needs it on darwin)
-BRLCAD_CHECK_C_FLAG(fno-common)
-BRLCAD_CHECK_CXX_FLAG(fno-common)
+CHECK_C_FLAG(fno-common)
+CHECK_CXX_FLAG(fno-common)
 
 # check for -fexceptions
 # this is needed to resolve __Unwind_Resume when compiling and
 # linking against openNURBS in librt for some binaries, for
 # example rttherm (i.e. any -static binaries)
-BRLCAD_CHECK_C_FLAG(fexceptions)
-BRLCAD_CHECK_CXX_FLAG(fexceptions)
+CHECK_C_FLAG(fexceptions)
+CHECK_CXX_FLAG(fexceptions)
 
 # check for -ftemplate-depth-NN this is needed in libpc and
 # other code using boost where the template instantiation depth
 # needs to be increased from the default ANSI minimum of 17.
-BRLCAD_CHECK_CXX_FLAG(ftemplate-depth-128)
+CHECK_CXX_FLAG(ftemplate-depth-128)
 
 # dynamic SSE optimizations for NURBS processing
 #
 # XXX disable the SSE flags for now as they can cause illegal instructions.
 #     the test needs to also be tied to run-time functionality since gcc
 #     may still output SSE instructions (e.g., for cross-compiling).
-# BRLCAD_CHECK_C_FLAG(msse)
-# BRLCAD_CHECK_C_FLAG(msse2)
-BRLCAD_CHECK_C_FLAG(msse3 BUILD_TYPES Debug)
+# CHECK_C_FLAG(msse)
+# CHECK_C_FLAG(msse2)
+CHECK_C_FLAG(msse3 BUILD_TYPES Debug)
 
-# Check for c90 support with gnu extensions if we're not building for
-# a release so we get more broad portability testing.  Since the
-# default is debug, it will be the more difficult to keep working
-# given it's the lesser feature-rich C standard.
-if(NOT ENABLE_POSIX_COMPLIANCE AND
-   NOT ENABLE_C99_COMPLIANCE)
-  BRLCAD_CHECK_C_FLAG("std=gnu89" BUILD_TYPES Debug)
-elseif(ENABLE_POSIX_COMPLIANCE)
-  #=== strict POSIX (200112) and C99 support =======
-  BRLCAD_CHECK_C_FLAG("pedantic")
-  #== C99 ==
-  BRLCAD_CHECK_C_FLAG("std=c99")
-  BRLCAD_CHECK_C_FLAG("D_POSIX_C_SOURCE=200112L")
-  #BRLCAD_CHECK_C_FLAG("D_XOPEN_SOURCE=500")
-  #== CXX TBA
-  #== turn off others (not working in main CMakeLists.txt)
-  set(ENABLE_C99_COMPLIANCE OFF)
-elseif(ENABLE_C99_COMPLIANCE)
-  BRLCAD_CHECK_C_FLAG("pedantic")
-  BRLCAD_CHECK_C_FLAG("std=c99")
-  #BRLCAD_CHECK_C_FLAG("D_POSIX_C_SOURCE")
-  set(ENABLE_POSIX_COMPLIANCE OFF)
-endif()
-
-# Check for c99 support with gnu extensions when we are building for a
-# release so we get to leverage more system features where available.
-#
-# Also check for c99 conformance (with extensions) since some platform
-# environments require it due to c99-specific system headers (e.g.,
-# /System/Library/Frameworks/OpenGL.framework/Headers/gl.h on Mac OS X
-# having '//' comments embedded).
-if(NOT ENABLE_POSIX_COMPLIANCE AND
-   NOT ENABLE_C99_COMPLIANCE)
-  BRLCAD_CHECK_C_FLAG("std=gnu99" BUILD_TYPES Release VARS C99_FLAG)
-endif()
 
 # Silence check for unused arguments (used to silence clang warnings about
 # unused options on the command line). By default clang generates a lot of
 # warnings about such arguments, and we don't really care.
-BRLCAD_CHECK_C_FLAG(Qunused-arguments)
-BRLCAD_CHECK_CXX_FLAG(Qunused-arguments)
+CHECK_C_FLAG(Qunused-arguments)
+CHECK_CXX_FLAG(Qunused-arguments)
 
 # 64bit compilation flags
 if(${CMAKE_WORD_SIZE} MATCHES "64BIT")
-  BRLCAD_CHECK_C_FLAG(m64 VARS 64BIT_FLAG)
-  BRLCAD_CHECK_C_FLAG("arch x86_64" VARS 64BIT_FLAG)
-  BRLCAD_CHECK_C_FLAG(64 VARS 64BIT_FLAG)
-  BRLCAD_CHECK_C_FLAG("mabi=64" VARS  64BIT_FLAG)
+  CHECK_C_FLAG(m64 VARS 64BIT_FLAG)
+  CHECK_C_FLAG("arch x86_64" VARS 64BIT_FLAG)
+  CHECK_C_FLAG(64 VARS 64BIT_FLAG)
+  CHECK_C_FLAG("mabi=64" VARS  64BIT_FLAG)
   if(NOT 64BIT_FLAG AND ${CMAKE_WORD_SIZE} MATCHES "64BIT")
     message(FATAL_ERROR "Trying to compile 64BIT but all 64 bit compiler flag tests failed!")
   endif(NOT 64BIT_FLAG AND ${CMAKE_WORD_SIZE} MATCHES "64BIT")
-  BRLCAD_CHECK_C_FLAG(q64 VARS 64BIT_FLAG)
+  CHECK_C_FLAG(q64 VARS 64BIT_FLAG)
   ADD_NEW_FLAG(C 64BIT_FLAG ALL)
   ADD_NEW_FLAG(CXX 64BIT_FLAG ALL)
   ADD_NEW_FLAG(SHARED_LINKER 64BIT_FLAG ALL)
@@ -309,12 +317,12 @@ if(${CMAKE_WORD_SIZE} MATCHES "64BIT")
 endif(${CMAKE_WORD_SIZE} MATCHES "64BIT")
 
 # 32 bit compilation flags
-if(${CMAKE_WORD_SIZE} MATCHES "32BIT" AND NOT ${BRLCAD_WORD_SIZE} MATCHES "AUTO")
-  BRLCAD_CHECK_C_FLAG(m32 VARS 32BIT_FLAG)
-  BRLCAD_CHECK_C_FLAG("arch i686" VARS 32BIT_FLAG)
-  BRLCAD_CHECK_C_FLAG(32 VARS 32BIT_FLAG)
-  BRLCAD_CHECK_C_FLAG("mabi=32" VARS 32BIT_FLAG)
-  BRLCAD_CHECK_C_FLAG(q32 VARS 32BIT_FLAG)
+if(${CMAKE_WORD_SIZE} MATCHES "32BIT" AND NOT ${WORD_SIZE} MATCHES "AUTO")
+  CHECK_C_FLAG(m32 VARS 32BIT_FLAG)
+  CHECK_C_FLAG("arch i686" VARS 32BIT_FLAG)
+  CHECK_C_FLAG(32 VARS 32BIT_FLAG)
+  CHECK_C_FLAG("mabi=32" VARS 32BIT_FLAG)
+  CHECK_C_FLAG(q32 VARS 32BIT_FLAG)
   if(NOT 32BIT_FLAG AND ${CMAKE_WORD_SIZE} MATCHES "32BIT")
     message(FATAL_ERROR "Trying to compile 32BIT but all 32 bit compiler flag tests failed!")
   endif(NOT 32BIT_FLAG AND ${CMAKE_WORD_SIZE} MATCHES "32BIT")
@@ -322,30 +330,30 @@ if(${CMAKE_WORD_SIZE} MATCHES "32BIT" AND NOT ${BRLCAD_WORD_SIZE} MATCHES "AUTO"
   ADD_NEW_FLAG(CXX 32BIT_FLAG ALL)
   ADD_NEW_FLAG(SHARED_LINKER 32BIT_FLAG ALL)
   ADD_NEW_FLAG(EXE_LINKER 32BIT_FLAG ALL)
-endif(${CMAKE_WORD_SIZE} MATCHES "32BIT" AND NOT ${BRLCAD_WORD_SIZE} MATCHES "AUTO")
+endif(${CMAKE_WORD_SIZE} MATCHES "32BIT" AND NOT ${WORD_SIZE} MATCHES "AUTO")
 
-if(BRLCAD_ENABLE_PROFILING)
-  BRLCAD_CHECK_C_FLAG(pg VARS PROFILE_FLAG)
-  BRLCAD_CHECK_C_FLAG(p VARS PROFILE_FLAG)
-  BRLCAD_CHECK_C_FLAG(prof_gen VARS PROFILE_FLAG)
+if(ENABLE_PROFILING)
+  CHECK_C_FLAG(pg VARS PROFILE_FLAG)
+  CHECK_C_FLAG(p VARS PROFILE_FLAG)
+  CHECK_C_FLAG(prof_gen VARS PROFILE_FLAG)
   if(NOT PROFILE_FLAG)
     message("Warning - profiling requested, but don't know how to profile with this compiler - disabling.")
-    set(BRLCAD_ENABLE_PROFILING OFF)
+    set(ENABLE_PROFILING OFF)
   else(NOT PROFILE_FLAG)
     ADD_NEW_FLAG(C PROFILE_FLAG ALL)
     ADD_NEW_FLAG(CXX PROFILE_FLAG ALL)
   endif(NOT PROFILE_FLAG)
-endif(BRLCAD_ENABLE_PROFILING)
+endif(ENABLE_PROFILING)
 
 # Debugging flags
-if(BRLCAD_FLAGS_DEBUG)
-  BRLCAD_CHECK_C_FLAG(g GROUPS DEBUG_C_FLAGS)
-  BRLCAD_CHECK_CXX_FLAG(g GROUPS DEBUG_CXX_FLAGS)
+if(FLAGS_DEBUG)
+  CHECK_C_FLAG(g GROUPS DEBUG_C_FLAGS)
+  CHECK_CXX_FLAG(g GROUPS DEBUG_CXX_FLAGS)
   if(APPLE)
     EXEC_PROGRAM(sw_vers ARGS -productVersion OUTPUT_VARIABLE MACOSX_VERSION)
     if(${MACOSX_VERSION} VERSION_LESS "10.5")
-      BRLCAD_CHECK_C_FLAG(ggdb3 GROUPS DEBUG_C_FLAGS)
-      BRLCAD_CHECK_CXX_FLAG(ggdb3 GROUPS DEBUG_CXX_FLAGS)
+      CHECK_C_FLAG(ggdb3 GROUPS DEBUG_C_FLAGS)
+      CHECK_CXX_FLAG(ggdb3 GROUPS DEBUG_CXX_FLAGS)
     else(${MACOSX_VERSION} VERSION_LESS "10.5")
       # CHECK_C_COMPILER_FLAG silently eats gstabs+ - also, compiler
       # apparently doesn't like mixing stabs with another debug flag.
@@ -353,8 +361,8 @@ if(BRLCAD_FLAGS_DEBUG)
       set(DEBUG_CXX_FLAGS "-ggdb")
     endif(${MACOSX_VERSION} VERSION_LESS "10.5")
   else(APPLE)
-    BRLCAD_CHECK_C_FLAG(ggdb3 GROUPS DEBUG_C_FLAGS)
-    BRLCAD_CHECK_CXX_FLAG(ggdb3 GROUPS DEBUG_CXX_FLAGS)
+    CHECK_C_FLAG(ggdb3 GROUPS DEBUG_C_FLAGS)
+    CHECK_CXX_FLAG(ggdb3 GROUPS DEBUG_CXX_FLAGS)
   endif(APPLE)
   if(CMAKE_CONFIGURATION_TYPES)
     set(debug_config_list "${CMAKE_CONFIGURATION_TYPES}")
@@ -367,7 +375,7 @@ if(BRLCAD_FLAGS_DEBUG)
   ADD_NEW_FLAG(SHARED_LINKER DEBUG_C_FLAGS "${debug_config_list}")
   ADD_NEW_FLAG(EXE_LINKER DEBUG_C_FLAGS "${debug_config_list}")
   mark_as_advanced(DEBUG_FLAGS)
-endif(BRLCAD_FLAGS_DEBUG)
+endif(FLAGS_DEBUG)
 
 
 # Set the minimum compilation linkage for Mac systems if not already
@@ -379,16 +387,16 @@ if(APPLE)
   endif(NOT MACOSX_DEPLOYMENT_TARGET)
 
   if(MACOSX_DEPLOYMENT_TARGET STREQUAL "10.3")
-    BRLCAD_CHECK_C_FLAG("mmacosx-version-min=10.3 -isysroot /Developer/SDKs/MacOSX10.3.9.sdk" VARS SDK_FLAG)
+    CHECK_C_FLAG("mmacosx-version-min=10.3 -isysroot /Developer/SDKs/MacOSX10.3.9.sdk" VARS SDK_FLAG)
   endif(MACOSX_DEPLOYMENT_TARGET STREQUAL "10.3")
   if(MACOSX_DEPLOYMENT_TARGET STREQUAL "10.4")
-    BRLCAD_CHECK_C_FLAG("mmacosx-version-min=10.4 -isysroot /Developer/SDKs/MacOSX10.4u.sdk" VARS SDK_FLAG)
+    CHECK_C_FLAG("mmacosx-version-min=10.4 -isysroot /Developer/SDKs/MacOSX10.4u.sdk" VARS SDK_FLAG)
   endif(MACOSX_DEPLOYMENT_TARGET STREQUAL "10.4")
   if(MACOSX_DEPLOYMENT_TARGET STREQUAL "10.5")
-    BRLCAD_CHECK_C_FLAG("mmacosx-version-min=10.5 -isysroot /Developer/SDKs/MacOSX10.5.sdk" VARS SDK_FLAG)
+    CHECK_C_FLAG("mmacosx-version-min=10.5 -isysroot /Developer/SDKs/MacOSX10.5.sdk" VARS SDK_FLAG)
   endif(MACOSX_DEPLOYMENT_TARGET STREQUAL "10.5")
   if(MACOSX_DEPLOYMENT_TARGET STREQUAL "10.6")
-    BRLCAD_CHECK_C_FLAG("mmacosx-version-min=10.6 -isysroot /Developer/SDKs/MacOSX10.6.sdk" VARS SDK_FLAG)
+    CHECK_C_FLAG("mmacosx-version-min=10.6 -isysroot /Developer/SDKs/MacOSX10.6.sdk" VARS SDK_FLAG)
   endif(MACOSX_DEPLOYMENT_TARGET STREQUAL "10.6")
 
   ADD_NEW_FLAG(C SDK_FLAG ALL)