[CMake] ARG prefix for cmake_parse_arguments (#278)

Instead of using `SDK_BUILD_IR`, `SDK_ADD_SYCL`, or `SDK_ADD_SAMPLE`
just use `ARG` since local variables are created anyway.
This should reduce the verbosity a bit.

Author: ProGTX

cmake/Modules/FindComputeCpp.cmake

@@ -318,33 +318,33 @@ function(__build_ir)
     COUNTER
   )
   set(multi_value_args)
-  cmake_parse_arguments(SDK_BUILD_IR
+  cmake_parse_arguments(ARG
     "${options}"
     "${one_value_args}"
     "${multi_value_args}"
     ${ARGN}
   )
-  get_filename_component(sourceFileName ${SDK_BUILD_IR_SOURCE} NAME)
+  get_filename_component(sourceFileName ${ARG_SOURCE} NAME)
 
   # Set the path to the integration header.
   # The .sycl filename must depend on the target so that different targets
   # using the same source file will be generated with a different rule.
-  set(baseSyclName ${CMAKE_CURRENT_BINARY_DIR}/${SDK_BUILD_IR_TARGET}_${sourceFileName})
+  set(baseSyclName ${CMAKE_CURRENT_BINARY_DIR}/${ARG_TARGET}_${sourceFileName})
   set(outputSyclFile ${baseSyclName}.sycl)
   get_sycl_target_extension(targetExtension)
   set(outputDeviceFile ${baseSyclName}.${targetExtension})
   set(depFileName ${baseSyclName}.sycl.d)
 
-  set(include_directories "$<TARGET_PROPERTY:${SDK_BUILD_IR_TARGET},INCLUDE_DIRECTORIES>")
-  set(compile_definitions "$<TARGET_PROPERTY:${SDK_BUILD_IR_TARGET},COMPILE_DEFINITIONS>")
+  set(include_directories "$<TARGET_PROPERTY:${ARG_TARGET},INCLUDE_DIRECTORIES>")
+  set(compile_definitions "$<TARGET_PROPERTY:${ARG_TARGET},COMPILE_DEFINITIONS>")
   set(generated_include_directories
     $<$<BOOL:${include_directories}>:-I\"$<JOIN:${include_directories},\"\t-I\">\">)
   set(generated_compile_definitions
     $<$<BOOL:${compile_definitions}>:-D$<JOIN:${compile_definitions},\t-D>>)
 
   # Obtain language standard of the file
   set(device_compiler_cxx_standard)
-  get_target_property(targetCxxStandard ${SDK_BUILD_IR_TARGET} CXX_STANDARD)
+  get_target_property(targetCxxStandard ${ARG_TARGET} CXX_STANDARD)
   if (targetCxxStandard MATCHES 17)
     set(device_compiler_cxx_standard "-std=c++1z")
   elseif (targetCxxStandard MATCHES 14)
@@ -358,7 +358,7 @@ function(__build_ir)
   endif()
 
   get_property(source_compile_flags
-    SOURCE ${SDK_BUILD_IR_SOURCE}
+    SOURCE ${ARG_SOURCE}
     PROPERTY COMPUTECPP_SOURCE_FLAGS
   )
   separate_arguments(source_compile_flags)
@@ -372,8 +372,8 @@ function(__build_ir)
     ${computecpp_source_flags}
   )
 
-  set(ir_dependencies ${SDK_BUILD_IR_SOURCE})
-  get_target_property(target_libraries ${SDK_BUILD_IR_TARGET} LINK_LIBRARIES)
+  set(ir_dependencies ${ARG_SOURCE})
+  get_target_property(target_libraries ${ARG_TARGET} LINK_LIBRARIES)
   if(target_libraries)
     foreach(library ${target_libraries})
       if(TARGET ${library})
@@ -400,51 +400,51 @@ function(__build_ir)
             ${generated_compile_definitions}
             -sycl-ih ${outputSyclFile}
             -o ${outputDeviceFile}
-            -c ${SDK_BUILD_IR_SOURCE}
+            -c ${ARG_SOURCE}
             ${generate_depfile}
     DEPENDS ${ir_dependencies}
-    IMPLICIT_DEPENDS CXX ${SDK_BUILD_IR_SOURCE}
+    IMPLICIT_DEPENDS CXX ${ARG_SOURCE}
     ${enable_depfile}
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     COMMENT "Building ComputeCpp integration header file ${outputSyclFile}")
 
   # Name: (user-defined name)_(source file)_(counter)_ih
   set(headerTargetName
-    ${SDK_BUILD_IR_TARGET}_${sourceFileName}_${SDK_BUILD_IR_COUNTER}_ih)
+    ${ARG_TARGET}_${sourceFileName}_${ARG_COUNTER}_ih)
 
   if(NOT MSVC)
     # Add a custom target for the generated integration header
     add_custom_target(${headerTargetName} DEPENDS ${outputDeviceFile} ${outputSyclFile})
-    add_dependencies(${SDK_BUILD_IR_TARGET} ${headerTargetName})
+    add_dependencies(${ARG_TARGET} ${headerTargetName})
   endif()
 
   # This property can be set on a per-target basis to indicate that the
   # integration header should appear after the main source listing
-  get_target_property(includeAfter ${SDK_ADD_SYCL_TARGET} COMPUTECPP_INCLUDE_AFTER)
+  get_target_property(includeAfter ${ARG_TARGET} COMPUTECPP_INCLUDE_AFTER)
 
   if(includeAfter)
     # Change the source file to the integration header - e.g.
     # g++ -c source_file_name.cpp.sycl
-    get_target_property(current_sources ${SDK_BUILD_IR_TARGET} SOURCES)
+    get_target_property(current_sources ${ARG_TARGET} SOURCES)
     # Remove absolute path to source file
-    list(REMOVE_ITEM current_sources ${SDK_BUILD_IR_SOURCE})
+    list(REMOVE_ITEM current_sources ${ARG_SOURCE})
     # Remove relative path to source file
     string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" ""
-      rel_source_file ${SDK_BUILD_IR_SOURCE}
+      rel_source_file ${ARG_SOURCE}
     )
     list(REMOVE_ITEM current_sources ${rel_source_file})
     # Add SYCL header to source list
     list(APPEND current_sources ${outputSyclFile})
-    set_property(TARGET ${SDK_BUILD_IR_TARGET}
+    set_property(TARGET ${ARG_TARGET}
       PROPERTY SOURCES ${current_sources})
     # CMake/gcc don't know what language a .sycl file is, so tell them
     set_property(SOURCE ${outputSyclFile} PROPERTY LANGUAGE CXX)
-    set(includedFile ${SDK_BUILD_IR_SOURCE})
+    set(includedFile ${ARG_SOURCE})
     set(cppFile ${outputSyclFile})
   else()
     set_property(SOURCE ${outputSyclFile} PROPERTY HEADER_FILE_ONLY ON)
     set(includedFile ${outputSyclFile})
-    set(cppFile ${SDK_BUILD_IR_SOURCE})
+    set(cppFile ${ARG_SOURCE})
   endif()
 
   # Force inclusion of the integration header for the host compiler
@@ -455,11 +455,11 @@ function(__build_ir)
     if(includeAfter)
       # Allow the source file to be edited using Visual Studio.
       # It will be added as a header file so it won't be compiled.
-      set_property(SOURCE ${SDK_BUILD_IR_SOURCE} PROPERTY HEADER_FILE_ONLY true)
+      set_property(SOURCE ${ARG_SOURCE} PROPERTY HEADER_FILE_ONLY true)
     endif()
 
     # Add both source and the sycl files to the VS solution.
-    target_sources(${SDK_BUILD_IR_TARGET} PUBLIC ${SDK_BUILD_IR_SOURCE} ${outputSyclFile})
+    target_sources(${ARG_TARGET} PUBLIC ${ARG_SOURCE} ${outputSyclFile})
 
     set(forceIncludeFlags "/FI${includedFile} /TP")
   else()
@@ -491,17 +491,17 @@ function(add_sycl_to_target)
   set(multi_value_args
     SOURCES
   )
-  cmake_parse_arguments(SDK_ADD_SYCL
+  cmake_parse_arguments(ARG
     "${options}"
     "${one_value_args}"
     "${multi_value_args}"
     ${ARGN}
   )
-  if ("${SDK_ADD_SYCL_SOURCES}" STREQUAL "")
+  if ("${ARG_SOURCES}" STREQUAL "")
     message(WARNING "No source files provided to add_sycl_to_target. "
                     "SYCL integration headers may not be generated.")
   endif()
-  set_target_properties(${SDK_ADD_SYCL_TARGET} PROPERTIES LINKER_LANGUAGE CXX)
+  set_target_properties(${ARG_TARGET} PROPERTIES LINKER_LANGUAGE CXX)
 
   # If the CXX compiler is set to compute++ enable the driver.
   get_filename_component(cmakeCxxCompilerFileName "${CMAKE_CXX_COMPILER}" NAME)
@@ -511,19 +511,19 @@ function(add_sycl_to_target)
                            revert the CXX compiler to your default host compiler.")
     endif()
 
-    get_target_property(includeAfter ${SDK_ADD_SYCL_TARGET} COMPUTECPP_INCLUDE_AFTER)
+    get_target_property(includeAfter ${ARG_TARGET} COMPUTECPP_INCLUDE_AFTER)
     if(includeAfter)
       list(APPEND COMPUTECPP_USER_FLAGS -fsycl-ih-last)
     endif()
     list(INSERT COMPUTECPP_DEVICE_COMPILER_FLAGS 0 -sycl-driver)
     # Prepend COMPUTECPP_DEVICE_COMPILER_FLAGS and append COMPUTECPP_USER_FLAGS
     foreach(prop COMPILE_OPTIONS INTERFACE_COMPILE_OPTIONS)
-      get_target_property(target_compile_options ${SDK_ADD_SYCL_TARGET} ${prop})
+      get_target_property(target_compile_options ${ARG_TARGET} ${prop})
       if(NOT target_compile_options)
         set(target_compile_options "")
       endif()
       set_property(
-        TARGET ${SDK_ADD_SYCL_TARGET}
+        TARGET ${ARG_TARGET}
         PROPERTY ${prop}
         ${COMPUTECPP_DEVICE_COMPILER_FLAGS}
         ${target_compile_options}
@@ -534,23 +534,23 @@ function(add_sycl_to_target)
     set(fileCounter 0)
     list(INSERT COMPUTECPP_DEVICE_COMPILER_FLAGS 0 -sycl)
     # Add custom target to run compute++ and generate the integration header
-    foreach(sourceFile ${SDK_ADD_SYCL_SOURCES})
+    foreach(sourceFile ${ARG_SOURCES})
       if(NOT IS_ABSOLUTE ${sourceFile})
         set(sourceFile "${CMAKE_CURRENT_SOURCE_DIR}/${sourceFile}")
       endif()
       __build_ir(
-        TARGET     ${SDK_ADD_SYCL_TARGET}
+        TARGET     ${ARG_TARGET}
         SOURCE     ${sourceFile}
         COUNTER    ${fileCounter}
       )
       MATH(EXPR fileCounter "${fileCounter} + 1")
     endforeach()
   endif()
 
-  set_property(TARGET ${SDK_ADD_SYCL_TARGET}
+  set_property(TARGET ${ARG_TARGET}
     APPEND PROPERTY LINK_LIBRARIES ComputeCpp::ComputeCpp)
-  set_property(TARGET ${SDK_ADD_SYCL_TARGET}
+  set_property(TARGET ${ARG_TARGET}
     APPEND PROPERTY INTERFACE_LINK_LIBRARIES ComputeCpp::ComputeCpp)
-  target_compile_definitions(${SDK_ADD_SYCL_TARGET} INTERFACE
+  target_compile_definitions(${ARG_TARGET} INTERFACE
     SYCL_LANGUAGE_VERSION=${SYCL_LANGUAGE_VERSION})
 endfunction(add_sycl_to_target)

samples/CMakeLists.txt

@@ -9,19 +9,19 @@ function(add_sample)
   set(options NO_TEST)
   set(one_value_args TARGET)
   set(multi_value_args SOURCES)
-  cmake_parse_arguments(SDK_ADD_SAMPLE
+  cmake_parse_arguments(ARG
     "${options}"
     "${one_value_args}"
     "${multi_value_args}"
     ${ARGN}
   )
-  add_executable(${SDK_ADD_SAMPLE_TARGET} ${SDK_ADD_SAMPLE_SOURCES})
-  add_sycl_to_target(TARGET ${SDK_ADD_SAMPLE_TARGET}
-    SOURCES ${SDK_ADD_SAMPLE_SOURCES})
-  if(NOT SDK_ADD_SAMPLE_NO_TEST)
-    add_test(NAME ${SDK_ADD_SAMPLE_TARGET} COMMAND ${SDK_ADD_SAMPLE_TARGET})
+  add_executable(${ARG_TARGET} ${ARG_SOURCES})
+  add_sycl_to_target(TARGET ${ARG_TARGET}
+    SOURCES ${ARG_SOURCES})
+  if(NOT ARG_NO_TEST)
+    add_test(NAME ${ARG_TARGET} COMMAND ${ARG_TARGET})
   endif()
-  install(TARGETS ${SDK_ADD_SAMPLE_TARGET} RUNTIME DESTINATION bin)
+  install(TARGETS ${ARG_TARGET} RUNTIME DESTINATION bin)
 endfunction(add_sample)
 
 add_sample(TARGET accessors SOURCES accessors.cpp)