Merge topic 'macro-function-docs'

4efef3f7 Help: Clarify that ARGV# beyond ARGC will have an undefined behavior (#15380)
e3363bfb Help: Refine the .rst formatting of macro and function documentation

2 files changed, 50 insertions, 36 deletions

diff --git a/Help/command/function.rst b/Help/command/function.rst
index b18e03c..7ffdfee 100644
--- a/Help/command/function.rst
+++ b/Help/command/function.rst
@@ -1,9 +1,7 @@
 function
 --------
 
-Start recording a function for later invocation as a command.
-
-::
+Start recording a function for later invocation as a command::
 
   function(<name> [arg1 [arg2 [arg3 ...]]])
     COMMAND1(ARGS ...)
@@ -11,21 +9,28 @@ Start recording a function for later invocation as a command.
     ...
   endfunction(<name>)
 
-Define a function named <name> that takes arguments named arg1 arg2
-arg3 (...).  Commands listed after function, but before the matching
-endfunction, are not invoked until the function is invoked.  When it
-is invoked, the commands recorded in the function are first modified
-by replacing formal parameters (${arg1}) with the arguments passed,
-and then invoked as normal commands.  In addition to referencing the
-formal parameters you can reference the variable ARGC which will be
-set to the number of arguments passed into the function as well as
-ARGV0 ARGV1 ARGV2 ...  which will have the actual values of the
-arguments passed in.  This facilitates creating functions with
-optional arguments.  Additionally ARGV holds the list of all arguments
-given to the function and ARGN holds the list of arguments past the
-last expected argument.
+Define a function named ``<name>`` that takes arguments named ``arg1``,
+``arg2``, ``arg3``, (...).
+Commands listed after function, but before the matching
+:command:`endfunction()`, are not invoked until the function is invoked.
+When it is invoked, the commands recorded in the function are first
+modified by replacing formal parameters (``${arg1}``) with the arguments
+passed, and then invoked as normal commands.
+In addition to referencing the formal parameters you can reference the
+``ARGC`` variable which will be set to the number of arguments passed
+into the function as well as ``ARGV0``, ``ARGV1``, ``ARGV2``, ...  which
+will have the actual values of the arguments passed in.
+This facilitates creating functions with optional arguments.
+Additionally ``ARGV`` holds the list of all arguments given to the
+function and ``ARGN`` holds the list of arguments past the last expected
+argument.
+Referencing to ``ARGV#`` arguments beyond ``ARGC`` have undefined
+behavior. Checking that ``ARGC`` is greater than ``#`` is the only way
+to ensure that ``ARGV#`` was passed to the function as an extra
+argument.
 
-A function opens a new scope: see set(var PARENT_SCOPE) for details.
+A function opens a new scope: see :command:`set(var PARENT_SCOPE)` for
+details.
 
-See the cmake_policy() command documentation for the behavior of
-policies inside functions.
+See the :command:`cmake_policy()` command documentation for the behavior
+of policies inside functions.
diff --git a/Help/command/macro.rst b/Help/command/macro.rst
index 258dc50..6bee69c 100644
--- a/Help/command/macro.rst
+++ b/Help/command/macro.rst
@@ -1,9 +1,7 @@
 macro
 -----
 
-Start recording a macro for later invocation as a command.
-
-::
+Start recording a macro for later invocation as a command::
 
   macro(<name> [arg1 [arg2 [arg3 ...]]])
     COMMAND1(ARGS ...)
@@ -11,22 +9,28 @@ Start recording a macro for later invocation as a command.
     ...
   endmacro(<name>)
 
-Define a macro named <name> that takes arguments named arg1 arg2 arg3
-(...).  Commands listed after macro, but before the matching endmacro,
-are not invoked until the macro is invoked.  When it is invoked, the
-commands recorded in the macro are first modified by replacing formal
-parameters (``${arg1}``) with the arguments passed, and then invoked as
-normal commands.  In addition to referencing the formal parameters you
-can reference the values ``${ARGC}`` which will be set to the number of
-arguments passed into the function as well as ``${ARGV0}`` ``${ARGV1}``
-``${ARGV2}`` ...  which will have the actual values of the arguments
-passed in.  This facilitates creating macros with optional arguments.
+Define a macro named ``<name>`` that takes arguments named ``arg1``,
+``arg2``, ``arg3``, (...).
+Commands listed after macro, but before the matching
+:command:`endmacro()`, are not invoked until the macro is invoked.
+When it is invoked, the commands recorded in the macro are first
+modified by replacing formal parameters (``${arg1}``) with the arguments
+passed, and then invoked as normal commands.
+In addition to referencing the formal parameters you can reference the
+values ``${ARGC}`` which will be set to the number of arguments passed
+into the function as well as ``${ARGV0}``, ``${ARGV1}``, ``${ARGV2}``,
+...  which will have the actual values of the arguments passed in.
+This facilitates creating macros with optional arguments.
 Additionally ``${ARGV}`` holds the list of all arguments given to the
 macro and ``${ARGN}`` holds the list of arguments past the last expected
 argument.
+Referencing to ``${ARGV#}`` arguments beyond ``${ARGC}`` have undefined
+behavior. Checking that ``${ARGC}`` is greater than ``#`` is the only
+way to ensure that ``${ARGV#}`` was passed to the function as an extra
+argument.
 
-See the cmake_policy() command documentation for the behavior of
-policies inside macros.
+See the :command:`cmake_policy()` command documentation for the behavior
+of policies inside macros.
 
 Macro Argument Caveats
 ^^^^^^^^^^^^^^^^^^^^^^
@@ -37,10 +41,15 @@ replacements much like the C preprocessor would do with a macro.
 Therefore you will NOT be able to use commands like::
 
  if(ARGV1) # ARGV1 is not a variable
+ if(DEFINED ARGV2) # ARGV2 is not a variable
+ if(ARGC GREATER 2) # ARGC is not a variable
  foreach(loop_var IN LISTS ARGN) # ARGN is not a variable
 
-In the first case you can use ``if(${ARGV1})``, in the second case, you can
-use ``foreach(loop_var ${ARGN})`` but this will skip empty arguments.
+In the first case, you can use ``if(${ARGV1})``.
+In the second and third case, the proper way to check if an optional
+variable was passed to the macro is to use ``if(${ARGC} GREATER 2)``.
+In the last case, you can use ``foreach(loop_var ${ARGN})`` but this
+will skip empty arguments.
 If you need to include them, you can use::
 
  set(list_var "${ARGN}")