docs: def run_code (self, code, file_name, argv=None):
          if logger.parent.level<=logging.DEBUG2:  # pragma: no cover
              logger.debug2 ('------------------')
              logger.debug2 ('main (gobal) code:')
              handler= logger.parent.handlers[0]
  
              handler.acquire ()
              dis.dis (code, file=handler.stream)
              handler.release ()
  
              for inst in dis.Bytecode (code):
                  if inst.opname=='LOAD_CONST':
                      if type (inst.argval)==type (code):
                          logger.debug ('------------------')
                          handler.acquire ()
                          dis.dis (inst.argval, file=handler.stream)
                          handler.release ()
                      elif type (inst.argval)==str:
                          logger.debug ("last function is called: %s", inst.argval)
  
          # prepare environment
          if self.polute_globals:
              self.globals.update (os.environ)
  
              logger.debug (argv)
              if argv is None:
                  argv= [ file_name ]
              self.globals['argv']= Argv (argv)
  
          '''
          exec(): If only globals is provided, it must be a dictionary, which will
          be used for both the global and the local variables. If globals and locals
          are given, they are used for the global and local variables, respectively.
          If provided, locals can be any mapping object. Remember that at module
          level, globals and locals are the same dictionary. If exec gets two
          separate objects as globals and locals, the code will be executed as if
          it were embedded in a class definition.
  
          If the globals dictionary does not contain a value for the key __builtins__,
          a reference to the dictionary of the built-in module builtins is inserted
          under that key. That way you can control what builtins are available to
          the executed code by inserting your own __builtins__ dictionary into
          globals before passing it to exec().
  
          The default locals act as described for function locals() below:
          modifications to the default locals dictionary should not be attempted.
          Pass an explicit locals dictionary if you need to see effects of the code
          on locals after function exec() returns.
  
          locals(): Update and return a dictionary representing the current local
          symbol table. Free variables are returned by locals() when it is called
          in function blocks, but not in class blocks.
  
          The contents of this dictionary should not be modified; changes may not
          affect the values of local and free variables used by the interpreter.
          '''
          error= None
          result= None
          try:
              logger.debug3 ('globals for script: %s', ayrton.utils.dump_dict (self.globals))
              if self.params.trace:  # pragma: no cover
                  sys.settrace (self.global_tracer)
  
              exec (code, self.globals, self.locals)
              result= self.locals.get ('ayrton_return_value', None)
          except Exit as e:
              result= e.exit_value
          except Exception as e:  # pragma: no cover
              if self.params.pdb:
                  pdb.set_trace ()
  
              logger.debug ('script finished by Exception')
              logger.debug (traceback.format_exc ())
              error= e
          finally:  # pragma: no cover
              sys.settrace (None)
  
          logger.debug3 ('globals at script exit: %s', ayrton.utils.dump_dict (self.globals))
          logger.debug3 ('locals at script exit: %s', ayrton.utils.dump_dict (self.locals))
          logger.debug ('ayrton_return_value: %r', result)
  
          if error is not None:
              raise error
  
          return result