docs: def content_val(self, ymldata=None, messages=None):
          """Validates the Command Dictionary to ensure the contents for each of the fields
          meets specific criteria regarding the expected types, byte ranges, etc."""
  
          self._ymlproc = YAMLProcessor(self._ymlfile, False)
  
          # Turn off the YAML Processor
          log.debug("BEGIN: Content-based validation of Command dictionary")
          if ymldata is not None:
              cmddict = ymldata
          elif ymldata is None and self._ymlproc.loaded:
              cmddict = self._ymlproc.data
          elif not self._ymlproc.loaded:
              raise util.YAMLError("YAML failed to load.")
  
          try:
              # instantiate the document number. this will increment in order to
              # track the line numbers and section where validation fails
              docnum = 0
  
              # boolean to hold argument validity
              argsvalid = True
  
              # list of rules to validate against
              rules = []
  
              ### set the command rules
              #
              # set uniqueness rule for command names
              rules.append(UniquenessRule('name', "Duplicate command name: %s", messages))
  
              # set uniqueness rule for opcodes
              rules.append(UniquenessRule('opcode', "Duplicate opcode: %s", messages))
              #
              ###
              for cmdcnt, cmddefn in enumerate(cmddict[0]):
                  # check the command rules
                  for rule in rules:
                      rule.check(cmddefn)
  
                  # list of argument rules to validate against
                  argrules = []
  
                  ### set rules for command arguments
                  #
                  # set uniqueness rule for opcodes
                  argrules.append(UniquenessRule('name', "Duplicate argument name: " + cmddefn.name + ".%s", messages))
  
                  # set type rule for arg.type
                  argrules.append(TypeRule('type', "Invalid argument type for argument: " + cmddefn.name + ".%s", messages))
  
                  # set argument size rule for arg.type.nbytes
                  argrules.append(TypeSizeRule('nbytes', "Invalid argument size for argument: " + cmddefn.name + ".%s", messages))
  
                  # set argument enumerations rule to check no enumerations contain un-quoted YAML special variables
                  argrules.append(EnumRule('enum', "Invalid enum value for argument: " + cmddefn.name + ".%s", messages))
  
                  # set byte order rule to ensure proper ordering of aruguments
                  argrules.append(ByteOrderRule('bytes', "Invalid byte order for argument: " + cmddefn.name + ".%s", messages))
                  #
                  ###
  
                  argdefns = cmddefn.argdefns
                  for arg in argdefns:
                      # check argument rules
                      for rule in argrules:
                          rule.check(arg)
  
                  # check if argument rule failed, if so set the validity to False
                  if not all(r.valid is True for r in argrules):
                      argsvalid = False
  
              log.debug("END: Content-based validation complete for '%s'", self._ymlfile)
  
              # check validity of all command rules and argument validity
              return all(rule.valid is True for rule in rules) and argsvalid
  
          except util.YAMLValidationError, e:
              # Display the error message
              if messages is not None:
                  if len(e.message) < 128:
                      msg = "Validation Failed for YAML file '" + self._ymlfile + "': '" + str(e.message) + "'"
                  else:
                      msg = "Validation Failed for YAML file '" + self._ymlfile + "'"
  
                  log.error(msg)
                  self.ehandler.process(docnum, self.ehandler.doclines, e, messages)
                  return False