docs: def handle(self, name):
          """
          Call all advices at the provided name.
  
          This has an analogue in the join point in aspected oriented
          programming, but the analogy is a weak one as we don't have the
          proper metaobject protocol to support this.  Implementation that
          make use of this system should make it clear that they will call
          this method with name associated with its group before and after
          its execution, or that the method at hand that want this invoked
          be called by this other conductor method.
  
          For the Toolchain standard steps (prepare, compile, assemble,
          link and finalize), this handle method will only be called by
          invoking the toolchain as a callable.  Calling those methods
          piecemeal will not trigger the invocation, even though it
          probably should.  Modules, classes and methods that desire to
          call their own handler should instead follow the convention
          where the handle be called before and after with the appropriate
          names.  For instance:
  
              def test(self, spec):
                  spec.handle(BEFORE_TEST)
                  # do the things
                  spec.handle(AFTER_TEST)
  
          This arrangement will need to be revisited when a proper system
          is written at the metaclass level.
  
          Arguments:
  
          name
              The name of the advices group.  All the callables
              registered to this group will be invoked, last-in-first-out.
          """
  
          if name in self._called:
              logger.warning(
                  "advice group '%s' has been called for this spec %r",
                  name, self,
              )
              # only now ensure checking
              self.__advice_stack_frame_protection(currentframe())
          else:
              self._called.add(name)
  
          # Get a complete clone, so indirect manipulation done to the
          # reference that others have access to will not have an effect
          # within the scope of this execution.  Please refer to the
          # test_toolchain, test_spec_advice_no_infinite_pop test case.
          advices = []
          advices.extend(self._advices.get(name, []))
  
          if advices and self.get('debug'):
              logger.debug(
                  "handling %d advices in group '%s' ", len(advices), name)
  
          while advices:
              try:
                  # cleanup basically done lifo (last in first out)
                  values = advices.pop()
                  advice, a, kw = values
                  if not ((callable(advice)) and
                          isinstance(a, tuple) and
                          isinstance(kw, dict)):
                      raise TypeError
              except ValueError:
                  logger.info('Spec advice extraction error: got %s', values)
              except TypeError:
                  logger.info('Spec advice malformed: got %s', values)
              else:
                  try:
                      try:
                          advice(*a, **kw)
                      except Exception as e:
                          # get that back by the id.
                          frame = self._frames.get(id(values))
                          if frame:
                              logger.info('Spec advice exception: %r', e)
                              logger.info(
                                  'Traceback for original advice:\n%s', frame)
                          # continue on for the normal exception
                          raise
                  except AdviceCancel as e:
                      logger.info(
                          "advice %s in group '%s' signaled its cancellation "
                          "during its execution: %s", advice, name, e
                      )
                      if self.get(DEBUG):
                          logger.debug(
                              'showing traceback for cancellation', exc_info=1,
                          )
                  except AdviceAbort as e:
                      # this is a signaled error with a planned abortion
                      logger.warning(
                          "advice %s in group '%s' encountered a known error "
                          "during its execution: %s; continuing with toolchain "
                          "execution", advice, name, e
                      )
                      if self.get(DEBUG):
                          logger.warning(
                              'showing traceback for error', exc_info=1,
                          )
                  except ToolchainCancel:
                      # this is the safe cancel
                      raise
                  except ToolchainAbort as e:
                      logger.critical(
                          "an advice in group '%s' triggered an abort: %s",
                          name, str(e)
                      )
                      raise
                  except KeyboardInterrupt:
                      raise ToolchainCancel('interrupted')
                  except Exception as e:
                      # a completely unplanned failure
                      logger.critical(
                          "advice %s in group '%s' terminated due to an "
                          "unexpected exception: %s", advice, name, e
                      )
                      if self.get(DEBUG):
                          logger.critical(
                              'showing traceback for error', exc_info=1,
                          )