kc3-lang/angle/src/compiler/translator/TranslatorMetalDirect/DebugSink.h

• Show log

  Commit

• Hash : d7aa0130
  Author :
  Date : 2021-04-26T16:56:15
  

  Upstream Apple's direct-to-Metal backend: compile translator.
  
  This change is meant to merge the translator changes from Apple's
  direct-to-Metal backend. Taken from Kyle Piddington's CL:
  https://chromium-review.googlesource.com/c/angle/angle/+/2857366/
  The goal of this CL is to merge the translator code in a state that
  compiles, but not to switch the Metal backend over to use this
  translator backend yet.
  
  Bug: angleproject:5505
  Change-Id: I68a6354604498cd5fd1eb96c13fc56f3b38f2bd0
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2897536
  Reviewed-by: Jonah Ryan-Davis <jonahr@google.com>
  Commit-Queue: Jonah Ryan-Davis <jonahr@google.com>
  

Download

• src/compiler/translator/TranslatorMetalDirect/DebugSink.h

• //
  // Copyright 2020 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  #include <iostream>
  
  #include "compiler/translator/InfoSink.h"
  
  namespace sh
  {
  
  class StringObserver
  {
    public:
      StringObserver(const std::string &needle) : needle(needle) { ASSERT(!needle.empty()); }
  
      bool observe(char c)
      {
          if (needle[currPos] == c)
          {
              ++currPos;
              if (currPos == needle.size())
              {
                  reset();
                  return true;
              }
          }
          else
          {
              reset();
          }
          return false;
      }
  
      const std::string &getNeedle() const { return needle; }
  
      void reset() { currPos = 0; }
  
    private:
      std::string needle;
      size_t currPos = 0;
  };
  
  class DebugSink : angle::NonCopyable
  {
    public:
      friend class EscapedSink;
      class EscapedSink : angle::NonCopyable
      {
          friend class DebugSink;
  
        private:
          EscapedSink(DebugSink &owner) : mOwner(owner), mBegin(owner.size()) {}
  
        public:
          EscapedSink(EscapedSink &&other) : mOwner(other.mOwner), mBegin(other.mBegin) {}
  
          ~EscapedSink()
          {
              const char *p = mOwner.c_str();
              const int end = mOwner.size();
              mOwner.onWrite(p + mBegin, p + end);
          }
  
          TInfoSinkBase &get() { return mOwner.mParent; }
  
          operator TInfoSinkBase &() { return get(); }
  
        private:
          DebugSink &mOwner;
          const int mBegin;
      };
  
    public:
      DebugSink(TInfoSinkBase &parent, bool alsoLogToStdout)
          : mParent(parent), mAlsoLogToStdout(alsoLogToStdout)
      {}
  
      void watch(std::string const &needle)
      {
          if (!needle.empty())
          {
              mObservers.emplace_back(needle);
          }
      }
  
      void erase()
      {
          mParent.erase();
          for (StringObserver &observer : mObservers)
          {
              observer.reset();
          }
      }
  
      int size() { return mParent.size(); }
  
      const TPersistString &str() const { return mParent.str(); }
  
      const char *c_str() const { return mParent.c_str(); }
  
      EscapedSink escape() { return EscapedSink(*this); }
  
      template <typename T>
      DebugSink &operator<<(const T &value)
      {
          const size_t begin = mParent.size();
          mParent << value;
          const size_t end = mParent.size();
  
          const char *p = mParent.c_str();
          onWrite(p + begin, p + end);
  
          return *this;
      }
  
    private:
      void onWrite(const char *begin, char const *end)
      {
          const char *p = begin;
          while (p != end)
          {
              if (mAlsoLogToStdout)
              {
                  std::cout << *p;
              }
  
              for (StringObserver &observer : mObservers)
              {
                  if (observer.observe(*p))
                  {
                      if (mAlsoLogToStdout)
                      {
                          std::cout.flush();
                      }
                      const std::string &needle = observer.getNeedle();
                      (void)needle;
                      ASSERT(true);  // place your breakpoint here
                  }
              }
  
              ++p;
          }
  
          if (mAlsoLogToStdout)
          {
              std::cout.flush();
          }
      }
  
    private:
      TInfoSinkBase &mParent;
      std::vector<StringObserver> mObservers;
      bool mAlsoLogToStdout;
  };
  
  }  // namespace sh
  

Download