diff --git a/lib/gen_print.py b/lib/gen_print.py
index e7efb16..996a289 100755
--- a/lib/gen_print.py
+++ b/lib/gen_print.py
@@ -500,7 +500,7 @@
         loc_col1_width = loc_col1_width - loc_col1_indent
         # See if the user wants the output in hex format.
         if hex:
-            if type(var_value) in (str, unicode):
+            if type(var_value) not in (int, long):
                 value_format = "%s"
                 if var_value is "":
                     var_value = "<blank>"
@@ -597,6 +597,79 @@
 
 
 ###############################################################################
+def sprint_vars(*args):
+
+    r"""
+    Sprint the values of one or more variables.
+
+    Description of args:
+    args:
+        If the first argument is an integer, it will be interpreted to be the
+        "indent" value.
+        If the second argument is an integer, it will be interpreted to be the
+        "col1_width" value.
+        If the third argument is an integer, it will be interpreted to be the
+        "hex" value.
+        All remaining parms are considered variable names which are to be
+        sprinted.
+    """
+
+    if len(args) == 0:
+        return
+
+    # Get the name of the first variable passed to this function.
+    stack_frame = 2
+    caller_func_name = sprint_func_name(2)
+    if caller_func_name.endswith("print_vars"):
+        stack_frame += 1
+
+    parm_num = 1
+
+    # Create list from args (which is a tuple) so that it can be modified.
+    args_list = list(args)
+
+    var_name = get_arg_name(None, parm_num, stack_frame)
+    # See if parm 1 is to be interpreted as "indent".
+    try:
+        if type(int(var_name)) is int:
+            indent = int(var_name)
+            args_list.pop(0)
+            parm_num += 1
+    except ValueError:
+        indent = 0
+
+    var_name = get_arg_name(None, parm_num, stack_frame)
+    # See if parm 1 is to be interpreted as "col1_width".
+    try:
+        if type(int(var_name)) is int:
+            loc_col1_width = int(var_name)
+            args_list.pop(0)
+            parm_num += 1
+    except ValueError:
+        loc_col1_width = col1_width
+
+    var_name = get_arg_name(None, parm_num, stack_frame)
+    # See if parm 1 is to be interpreted as "hex".
+    try:
+        if type(int(var_name)) is int:
+            hex = int(var_name)
+            args_list.pop(0)
+            parm_num += 1
+    except ValueError:
+        hex = 0
+
+    buffer = ""
+    for var_value in args_list:
+        var_name = get_arg_name(None, parm_num, stack_frame)
+        buffer += sprint_varx(var_name, var_value, hex, indent, loc_col1_width)
+        parm_num += 1
+
+    return buffer
+
+###############################################################################
+
+
+###############################################################################
 def lprint_varx(var_name,
                 var_value,
                 hex=0,
@@ -927,8 +1000,8 @@
 
 
 ###############################################################################
-def sissuing(cmd_buf,
-             test_mode=0):
+def sprint_issuing(cmd_buf,
+                   test_mode=0):
 
     r"""
     Return a line indicating a command that the program is about to execute.
@@ -1038,10 +1111,10 @@
 # func_names contains a list of all print functions which should be created
 # from their sprint counterparts.
 func_names = ['print_time', 'print_timen', 'print_error', 'print_varx',
-              'print_var', 'print_dashes', 'indent', 'print_call_stack',
-              'print_func_name', 'print_executing', 'print_pgm_header',
-              'issuing', 'print_pgm_footer', 'print_error_report', 'print',
-              'printn']
+              'print_var', 'print_vars', 'print_dashes', 'indent',
+              'print_call_stack', 'print_func_name', 'print_executing',
+              'print_pgm_header', 'print_issuing', 'print_pgm_footer',
+              'print_error_report', 'print', 'printn']
 
 for func_name in func_names:
     if func_name == "print":
diff --git a/lib/gen_robot_print.py b/lib/gen_robot_print.py
index 331690b..8fdd7d0 100755
--- a/lib/gen_robot_print.py
+++ b/lib/gen_robot_print.py
@@ -6,6 +6,7 @@
 
 import sys
 import re
+import os
 
 import gen_print as gp
 
@@ -13,54 +14,40 @@
 from robot.api import logger
 
 
+try:
+    # The user can set environment variable "GEN_ROBOT_PRINT_DEBUG" to get
+    # debug output from this module.
+    gen_robot_print_debug = os.environ['GEN_ROBOT_PRINT_DEBUG']
+except KeyError:
+    gen_robot_print_debug = 0
+
+
 ###############################################################################
-# In the following section of code, we will dynamically create robot versions
-# of print functions for each of the sprint functions defined in the
-# gen_print.py module.  So, for example, where we have an sprint_time()
-# function defined above that returns the time to the caller in a string, we
-# will create a corresponding rprint_time() function that will print that
-# string directly to stdout.
+def set_quiet_default(quiet=None,
+                      default=0):
 
-# It can be complicated to follow what's being creaed by the exec statement
-# below.  Here is an example of the rprint_time() function that will be
-# created (as of the time of this writing):
+    r"""
+    Return a default value for the quiet variable based on its current value,
+    the value of global ${QUIET} and default.
 
-# def rprint_time(*args):
-#   s_func = getattr(gp, "sprint_time")
-#   BuiltIn().log_to_console(s_func(*args),
-#                            stream='STDIN',
-#                            no_newline=True)
+    Description of Arguments:
+    quiet                           If this is set already, no default value
+                                    is chosen.  Otherwise, it will be set to
+                                    either the global ${QUIET} robot variable
+                                    or to default (below).
+    default                         The default value to be used if global
+                                    ${QUIET} does not exist.
+    """
 
-# Here are comments describing the lines in the body of the created function.
-# Put a reference to the "s" version of this function in s_func.
-# Call the "s" version of this function passing it all of our arguments.
-# Write the result to stdout.
+    if quiet is None:
+        # Set default quiet value.
+        try:
+            quiet = int(BuiltIn().get_variable_value("${quiet}"))
+        except TypeError:
+            quiet = int(default)
+    quiet = int(quiet)
 
-robot_prefix = "r"
-for func_name in gp.func_names:
-    # The print_var function's job is to figure out the name of arg 1 and
-    # then call print_varx.  This is not currently supported for robot
-    # programs.  Though it IS supported for python modules.
-    if func_name == "print_error":
-        output_stream = "STDERR"
-    else:
-        output_stream = "STDIN"
-    func_def = \
-        [
-            "def " + robot_prefix + func_name + "(*args):",
-            "  s_func = getattr(gp, \"s" + func_name + "\")",
-            "  BuiltIn().log_to_console(s_func(*args),"
-            " stream='" + output_stream + "',"
-            " no_newline=True)"
-        ]
-
-    pgm_definition_string = '\n'.join(func_def)
-    exec(pgm_definition_string)
-
-    # Create abbreviated aliases (e.g. rpvarx is an alias for rprint_varx).
-    alias = re.sub("print_", "p", func_name)
-    exec(robot_prefix + alias + " = " + robot_prefix + func_name)
-
+    return quiet
 
 ###############################################################################
 
@@ -73,14 +60,13 @@
     rprint stands for "Robot Print".  This keyword will print the user's
     buffer to the console.  This keyword does not write a linefeed.  It is the
     responsibility of the caller to include a line feed if desired.  This
-    keyword is essentially an alias for "Log to Console  <string>
-    <stream>".
+    keyword is essentially an alias for "Log to Console  <string>  <stream>".
 
     Description of arguments:
     buffer                          The value that is to written to stdout.
     """
 
-    BuiltIn().log_to_console(buffer, no_newline=True, stream=stream)
+    BuiltIn().log_to_console(str(buffer), no_newline=True, stream=stream)
 
 ###############################################################################
 
@@ -104,64 +90,303 @@
 
 
 ###############################################################################
-def rprint_auto_vars(headers=0):
+def sprint_vars(*args):
 
     r"""
-    This keyword will print all of the Automatic Variables described in the
-    Robot User's Guide using rpvars.
+    sprint_vars stands for "String Print Vars".  This is a robot redefinition
+    of the sprint_vars function in gen_print.py.  Given a list of variable
+    names, this keyword will string print each variable name and value such
+    that the value lines up in the same column as messages printed with rptime.
+
+    Description of arguments:
+    args:
+        If the first argument is an integer, it will be interpreted to be the
+        "indent" value.
+        If the second argument is an integer, it will be interpreted to be the
+        "col1_width" value.
+        If the third argument is an integer, it will be interpreted to be the
+        "hex" value.
+        All remaining parms are considered variable names which are to be
+        sprinted.
+    """
+
+    if len(args) == 0:
+        return
+
+    # Create list from args (which is a tuple) so that it can be modified.
+    args_list = list(args)
+
+    # See if parm 1 is to be interpreted as "indent".
+    try:
+        if type(int(args_list[0])) is int:
+            indent = int(args_list[0])
+            args_list.pop(0)
+    except ValueError:
+        indent = 0
+
+    # See if parm 2 is to be interpreted as "col1_width".
+    try:
+        if type(int(args_list[0])) is int:
+            loc_col1_width = int(args_list[0])
+            args_list.pop(0)
+    except ValueError:
+        loc_col1_width = gp.col1_width
+
+    # See if parm 2 is to be interpreted as "hex".
+    try:
+        if type(int(args_list[0])) is int:
+            hex = int(args_list[0])
+            args_list.pop(0)
+    except ValueError:
+        hex = 0
+
+    buffer = ""
+    for var_name in args_list:
+        var_value = BuiltIn().get_variable_value("${" + var_name + "}")
+        buffer += gp.sprint_varx(var_name, var_value, hex, indent,
+                                 loc_col1_width)
+
+    return buffer
+
+###############################################################################
+
+
+###############################################################################
+def sprint_pgm_header(indent=0):
+
+    r"""
+    Sprint a standardized header that robot programs should print at the
+    beginning of the run.  The header includes useful information like command
+    line, pid, userid, program parameters, etc.  Callers need to have declared
+    a global @{parm_list} variable which contains the names of all program
+    parameters.
+    """
+
+    loc_col1_width = gp.col1_width + indent
+
+    linefeed = 0
+    rprintn()
+    suite_name = BuiltIn().get_variable_value("${suite_name}")
+
+    buffer = "\n"
+    buffer += gp.sindent(gp.sprint_time("Running test suite \"" +
+                                        suite_name + "\".\n"),
+                         indent)
+    buffer += gp.sprint_pgm_header(indent, linefeed)
+
+    # Get value of global parm_list.
+    parm_list = BuiltIn().get_variable_value("${parm_list}")
+
+    buffer += sprint_vars(str(indent), str(loc_col1_width), *parm_list)
+    buffer += "\n"
+
+    return buffer
+
+###############################################################################
+
+
+###############################################################################
+def sprint_error_report(error_text="\n"):
+
+    r"""
+    Print a standardized error report that robot programs should print on
+    failure.  The report includes useful information like error text, command
+    line, pid, userid, program parameters, etc.  Callers must have declared a
+    @{parm_list} variable which contains the names of all program parameters.
+    """
+
+    buffer = ""
+    buffer += gp.sprint_dashes(width=120, char="=")
+    buffer += gp.sprint_error(error_text)
+
+    indent = 2
+    linefeed = 0
+
+    buffer += sprint_pgm_header(indent)
+
+    buffer += gp.sprint_dashes(width=120, char="=")
+
+    return buffer
+
+###############################################################################
+
+
+###############################################################################
+def sprint_issuing_keyword(cmd_buf,
+                           test_mode=0):
+
+    r"""
+    Return a line indicating a robot command (i.e. keyword + args) that the
+    program is about to execute.
+
+    For example, for the following robot code...
+
+    @{cmd_buf}=  Set Variable  Set Environment Variable  VAR1  1
+    rdprint_issuing_keyword
+
+    The output would look something like this:
+
+    #(CDT) 2016/10/27 12:04:21 - Issuing: Set Environment Variable  VAR1  1
+
+    Description of args:
+    cmd_buf                         A list containing the keyword and
+                                    arguments to be run.
+    """
+
+    buffer = ""
+    cmd_buf_str = '  '.join([str(element) for element in cmd_buf])
+    buffer += gp.sprint_issuing(cmd_buf_str, int(test_mode))
+
+    return buffer
+
+###############################################################################
+
+
+###############################################################################
+def sprint_auto_vars(headers=0):
+
+    r"""
+    This keyword will string print all of the Automatic Variables described in
+    the Robot User's Guide using rprint_vars.
 
     NOTE: Not all automatic variables are guaranteed to exist.
 
     Description of arguments:
     headers                         This indicates that a header and footer
-                                    will be printed.
+                                    should be printed.
     """
 
+    buffer = ""
     if int(headers) == 1:
-        BuiltIn().log_to_console(gp.sprint_dashes(), no_newline=True)
-        BuiltIn().log_to_console("Automatic Variables:", no_newline=False)
+        buffer += gp.sprint_dashes()
+        buffer += "Automatic Variables:"
 
-    rpvars("TEST_NAME", "TEST_TAGS", "TEST_DOCUMENTATION", "TEST_STATUS",
-           "TEST_DOCUMENTATION", "TEST_STATUS", "TEST_MESSAGE",
-           "PREV_TEST_NAME", "PREV_TEST_STATUS", "PREV_TEST_MESSAGE",
-           "SUITE_NAME", "SUITE_SOURCE", "SUITE_DOCUMENTATION",
-           "SUITE_METADATA", "SUITE_STATUS", "SUITE_MESSAGE", "KEYWORD_STATUS",
-           "KEYWORD_MESSAGE", "LOG_LEVEL", "OUTPUT_FILE", "LOG_FILE",
-           "REPORT_FILE", "DEBUG_FILE", "OUTPUT_DIR")
+    buffer += \
+        sprint_vars(
+            "TEST_NAME", "TEST_TAGS", "TEST_DOCUMENTATION", "TEST_STATUS",
+            "TEST_DOCUMENTATION", "TEST_STATUS", "TEST_MESSAGE",
+            "PREV_TEST_NAME", "PREV_TEST_STATUS", "PREV_TEST_MESSAGE",
+            "SUITE_NAME", "SUITE_SOURCE", "SUITE_DOCUMENTATION",
+            "SUITE_METADATA", "SUITE_STATUS", "SUITE_MESSAGE",
+            "KEYWORD_STATUS", "KEYWORD_MESSAGE", "LOG_LEVEL", "OUTPUT_FILE",
+            "LOG_FILE", "REPORT_FILE", "DEBUG_FILE", "OUTPUT_DIR")
 
     if int(headers) == 1:
-        BuiltIn().log_to_console(gp.sprint_dashes(), no_newline=True)
+        buffer += gp.sprint_dashes()
+
+    return buffer
 
 ###############################################################################
 
 
 ###############################################################################
-def rpvars(*var_names):
+# In the following section of code, we will dynamically create robot versions
+# of print functions for each of the sprint functions defined in the
+# gen_print.py module.  So, for example, where we have an sprint_time()
+# function defined above that returns the time to the caller in a string, we
+# will create a corresponding rprint_time() function that will print that
+# string directly to stdout.
 
-    r"""
-    rpvars stands for "Robot Print Vars".  Given a list of variable names,
-    this keyword will print each variable name and value such that the value
-    lines up in the same column as messages printed with rptime.
+# It can be complicated to follow what's being created by the exec statement
+# below.  Here is an example of the rprint_time() function that will be
+# created (as of the time of this writing):
 
-    NOTE: This function should NOT be called for local variables.  It is
-    incapable of obtaining their values.
+# def rprint_time(*args):
+#   s_func = getattr(gp, "sprint_time")
+#   BuiltIn().log_to_console(s_func(*args),
+#                            stream='STDIN',
+#                            no_newline=True)
 
-    NOTE: I intend to add code to allow the last several parms to be
-    recognized as hex, indent, etc. and passed on to rpvarx function.  See the
-    sprint_var() function in gen_print.py for details.
+# Here are comments describing the lines in the body of the created function.
+# Put a reference to the "s" version of this function in s_func.
+# Call the "s" version of this function passing it all of our arguments.  Log
+# the result to the console.
 
-    Description of arguments:
-    var_names                       A list of the names of variables to be
-                                    printed.
-    """
+robot_prefix = "r"
+robot_func_names =\
+    [
+        'print_error_report', 'print_pgm_header',
+        'print_issuing_keyword', 'print_vars', 'print_auto_vars'
+    ]
+func_names = gp.func_names + robot_func_names
+for func_name in func_names:
+    # The print_var function's job is to figure out the name of arg 1 and
+    # then call print_varx.  This is not currently supported for robot
+    # programs.  Though it IS supported for python modules.
+    if func_name == "print_error" or func_name == "print_error_report":
+        output_stream = "STDERR"
+    else:
+        output_stream = "STDIN"
+    if func_name in robot_func_names:
+        object_name = "__import__(__name__)"
+    else:
+        object_name = "gp"
+    func_def = \
+        [
+            "def " + robot_prefix + func_name + "(*args):",
+            "  s_func = getattr(" + object_name + ", \"s" + func_name + "\")",
+            "  BuiltIn().log_to_console(s_func(*args),"
+            " stream='" + output_stream + "',"
+            " no_newline=True)"
+        ]
 
-    for var_name in var_names:
-        var_value = BuiltIn().get_variable_value("${" + var_name + "}")
-        rpvarx(var_name, var_value)
+    pgm_definition_string = '\n'.join(func_def)
+    if gen_robot_print_debug:
+        rprintn(pgm_definition_string)
+    exec(pgm_definition_string)
+
+    # Now define "q" versions of each print function.  The q functions only
+    # print if global robot var "quiet" is 0.  If the global var quiet is not
+    # defined, it will be treated as though it were "1", i.e. no printing will
+    # be done.
+    func_def = \
+        [
+            "def rq" + func_name + "(*args):",
+            "  try:",
+            "    quiet = int(BuiltIn().get_variable_value(\"${quiet}\"))",
+            "  except TypeError:",
+            "    quiet = 1",
+            "  if quiet:",
+            "    return",
+            "  r" + func_name + "(*args)"
+        ]
+
+    pgm_definition_string = '\n'.join(func_def)
+    if gen_robot_print_debug:
+        rprintn(pgm_definition_string)
+    exec(pgm_definition_string)
+
+    # Now define "d" versions of each print function.  The d functions only
+    # print if global robot var "debug" is 1.
+    func_def = \
+        [
+            "def rd" + func_name + "(*args):",
+            "  try:",
+            "    debug = int(BuiltIn().get_variable_value(\"${debug}\"))",
+            "  except TypeError:",
+            "    debug = 0",
+            "  if not debug:",
+            "    return",
+            "  r" + func_name + "(*args)"
+        ]
+
+    pgm_definition_string = '\n'.join(func_def)
+    if gen_robot_print_debug:
+        rprintn(pgm_definition_string)
+    exec(pgm_definition_string)
+
+    # Create abbreviated aliases (e.g. rpvarx is an alias for rprint_varx).
+    alias = re.sub("print_", "p", func_name)
+    cmd_buf = robot_prefix + alias + " = " + robot_prefix + func_name
+    if gen_robot_print_debug:
+        rprintn(cmd_buf)
+    exec(cmd_buf)
+
+# Define an alias.  rpvar is just a special case of rpvars where the args
+# list contains only one element.
+cmd_buf = "rpvar = rpvars"
+if gen_robot_print_debug:
+    rprintn(cmd_buf)
+exec(cmd_buf)
 
 ###############################################################################
-
-
-# Define an alias.  rpvar is just a special case of rpvars where the
-# var_names list contains only one element.
-rpvar = rpvars
diff --git a/lib/gen_robot_valid.py b/lib/gen_robot_valid.py
new file mode 100755
index 0000000..8a58d8c
--- /dev/null
+++ b/lib/gen_robot_valid.py
@@ -0,0 +1,139 @@
+#!/usr/bin/env python
+
+r"""
+This file contains functions useful for validating variables in robot.
+"""
+
+import gen_robot_print as grp
+import gen_valid as gv
+
+from robot.libraries.BuiltIn import BuiltIn
+from robot.api import logger
+
+
+###############################################################################
+def rvalid_value(var_name,
+                 invalid_values=[],
+                 valid_values=[]):
+
+    r"""
+    rprint stands for "Robot Valid Value".  This function is the robot wrapper
+    for gen_robot_print.svalid_value.
+
+    Description of arguments:
+    var_name                        The name of the variable whose value is to
+                                    be validated.
+    invalid_values                  A list of invalid values.  If var_value is
+                                    equal to any of these, it is invalid.
+                                    Note that if you specify anything for
+                                    invalid_values (below), the valid_values
+                                    list is not even processed.
+    valid_values                    A list of invalid values.  var_value must
+                                    be equal to one of these values to be
+                                    considered valid.
+
+    Examples of robot calls and corresponding output:
+
+    Robot code...
+    rvalid_value                    MY_PARM
+
+    Output...
+    #(CDT) 2016/11/02 10:04:20 - **ERROR** Variable "MY_PARM" not found (i.e.
+    #it's undefined).
+
+    or if it is defined but blank:
+
+    Output...
+    #(CDT) 2016/11/02 10:14:24 - **ERROR** The following variable has an
+    #invalid value:
+    MY_PARM:
+
+    It must NOT be one of the following values:
+    invalid_values:
+      invalid_values[0]:         <blank>
+
+    Robot code...
+    ${invalid_values}=  Create List  one  two  three
+    ${MY_PARM}=  Set Variable  one
+    rvalid_value                    MY_PARM  invalid_values=${invalid_values}
+
+    Output...
+    #(CDT) 2016/11/02 10:20:05 - **ERROR** The following variable has an
+    #invalid value:
+    MY_PARM:                     one
+
+    It must NOT be one of the following values:
+    invalid_values:
+        invalid_values[0]:       one
+        invalid_values[1]:       two
+        invalid_values[2]:       three
+
+    """
+
+    # Note: get_variable_value() seems to have no trouble with local variables.
+    var_value = BuiltIn().get_variable_value("${" + var_name + "}")
+
+    if var_value is None:
+        var_value = ""
+        error_message = "Variable \"" + var_name +\
+                        "\" not found (i.e. it's undefined).\n"
+    else:
+        error_message = gv.svalid_value(var_value, invalid_values,
+                                        valid_values, var_name)
+    if not error_message == "":
+        error_message = grp.sprint_robot_error_report(error_message)
+        BuiltIn().fail(error_message)
+
+###############################################################################
+
+
+###############################################################################
+def rvalid_integer(var_name):
+
+    r"""
+    rprint stands for "Robot Valid Integer".  This function is the robot
+    wrapper for gen_robot_print.svalid_integer.
+
+    Description of arguments:
+    var_name                        The name of the variable whose value is to
+                                    be validated.
+
+    Examples of robot calls and corresponding output:
+
+    Robot code...
+    Rvalid Integer  MY_PARM
+
+    Output...
+    #(CDT) 2016/11/02 10:44:43 - **ERROR** Variable "MY_PARM" not found (i.e.
+    #it's undefined).
+
+    or if it is defined but blank:
+
+    Output...
+    #(CDT) 2016/11/02 10:45:37 - **ERROR** Invalid integer value:
+    MY_PARM:                     <blank>
+
+    Robot code...
+    ${MY_PARM}=  Set Variable  HELLO
+    Rvalid Integer  MY_PARM
+
+    Output...
+    #(CDT) 2016/11/02 10:46:18 - **ERROR** Invalid integer value:
+    MY_PARM:                     HELLO
+
+    """
+
+    # Note: get_variable_value() seems to have no trouble with local variables.
+    var_value = BuiltIn().get_variable_value("${" + var_name + "}")
+
+    if var_value is None:
+        var_value = ""
+        error_message = "Variable \"" + var_name +\
+                        "\" not found (i.e. it's undefined).\n"
+    else:
+        error_message = gv.svalid_integer(var_value, var_name)
+    if not error_message == "":
+        error_message = grp.sprint_robot_error_report(error_message)
+        BuiltIn().fail(error_message)
+
+###############################################################################