docs: def argv(self, module, argv=sys.argv[1:]):
          '''
          Processes argv for any options specific to the specified module.
  
          @module - The module to process argv for.
          @argv   - A list of command line arguments (excluding argv[0]).
  
          Returns a dictionary of kwargs for the specified module.
          '''
          kwargs = {'enabled': False}
          last_priority = {}
          parser = argparse.ArgumentParser(add_help=False)
          # Hack: This allows the ListActionParser class to correllate short options to long options.
          # There is probably a built-in way to do this in the
          # argparse.ArgumentParser class?
          parser.short_to_long = {}
  
          # Must build arguments from all modules so that:
          #
          #    1) Any conflicting arguments will raise an exception
          #    2) The only unknown arguments will be the target files, making them
          #       easy to identify
          for m in self.list(attribute="CLI"):
  
              for module_option in m.CLI:
  
                  parser_args = []
                  parser_kwargs = {}
  
                  if not module_option.long:
                      continue
  
                  if module_option.short:
                      parser_args.append('-' + module_option.short)
                  parser_args.append('--' + module_option.long)
                  parser_kwargs['dest'] = module_option.long
  
                  if module_option.type is None:
                      parser_kwargs['action'] = 'store_true'
                  elif module_option.type is list:
                      parser_kwargs['action'] = 'append'
                      parser.short_to_long[
                          module_option.short] = module_option.long
  
                  parser.add_argument(*parser_args, **parser_kwargs)
  
          args, unknown = parser.parse_known_args(argv)
          args = args.__dict__
  
          # Only add parsed options pertinent to the requested module
          for module_option in module.CLI:
  
              if module_option.type == binwalk.core.common.BlockFile:
  
                  for k in get_keys(module_option.kwargs):
                      kwargs[k] = []
                      for unk in unknown:
                          kwargs[k].append(unk)
  
              elif has_key(args, module_option.long) and args[module_option.long] not in [None, False]:
  
                  # Loop through all the kwargs for this command line option
                  for (name, default_value) in iterator(module_option.kwargs):
  
                      # If this kwarg has not been previously processed, or if its priority is equal to or
                      # greater than the previously processed kwarg's priority,
                      # then let's process it.
                      if not has_key(last_priority, name) or last_priority[name] <= module_option.priority:
  
                          # Track the priority for future iterations that may
                          # process the same kwarg name
                          last_priority[name] = module_option.priority
  
                          try:
                              kwargs[name] = module_option.convert(args[module_option.long], default_value)
                          except KeyboardInterrupt as e:
                              raise e
                          except Exception as e:
                              raise ModuleException("Invalid usage: %s" % str(e))
  
          binwalk.core.common.debug("%s :: %s => %s" % (module.TITLE, str(argv), str(kwargs)))
          return kwargs