Revert of Experimental parsing expression grammar (PEG) template library

experimental/svg/model/SkPEG.h

Index: experimental/svg/model/SkPEG.h
diff --git a/experimental/svg/model/SkPEG.h b/experimental/svg/model/SkPEG.h
deleted file mode 100644
index 886852019e1acc979ab2469a14aa9d4e7a49417c..0000000000000000000000000000000000000000
--- a/experimental/svg/model/SkPEG.h
+++ /dev/null
@@ -1,244 +0,0 @@
-/*
- * Copyright 2016 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkPEG_DEFINED
-#define SkPEG_DEFINED
-
-#include "SkTDArray.h"
-#include "SkTLazy.h"
-
-namespace skpeg {
-
-/**
- *  The result of an expression match attempt.
- *
- *  If the match was successful, |fNext| points to the next unconsumed character in the
- *  input string, and |fValue| holds an (arbitrarily nested) match result value.
- *
- *  Otherwise, |fNext| is nullptr and |fValue| is uninitialized.
- */
-template <typename V>
-struct MatchResult {
-    MatchResult(std::nullptr_t) : fNext(nullptr) {}
-    MatchResult(const char* next, const V& v) : fNext(next), fValue(&v) {}
-
-    operator bool() const {
-        SkASSERT(fValue.isValid() == SkToBool(fNext));
-        return SkToBool(fNext);
-    }
-
-    const V& operator* () const { return *fValue.get(); }
-    const V* operator->() const { return  fValue.get(); }
-
-    const char* fNext;
-    SkTLazy<V>  fValue;
-};
-
-/**
- * Optional operator (e?).  Always succeeds.
- *
- * If e also matches, then the result of e::Match() is stored in |fValue|.
- * Otherwise, |fValue| is uninitialized.
- *
- */
-template <typename E>
-struct Opt {
-    struct V {
-        V(const typename E::V* v) : fValue(v) {}
-
-        SkTLazy<typename E::V> fValue;
-    };
-    using MatchT = MatchResult<V>;
-
-    static MatchT Match(const char* in) {
-        const auto m = E::Match(in);
-        return m ? MatchT(m.fNext, V(m.fValue.get()))
-                 : MatchT(in, nullptr);
-    }
-};
-
-/**
- * Helper for selecting the value type of the n-th expression type in the list.
- */
-template <size_t, typename... Es> struct SelectV;
-
-template <typename E, typename... Es>
-struct SelectV<0, E, Es...> {
-    using V = typename E::V;
-};
-
-template <size_t idx, typename E, typename... Es>
-struct SelectV<idx, E, Es...> {
-    using V = typename SelectV<idx - 1, Es...>::V;
-};
-
-/**
- * Sequence operator (e0 e1...).
- *
- * Succeeds when all expressions match, in sequence.  The subexpression match
- * results can be accessed via get<INDEX>() -- where get<0> returns the value
- * of the first expression, and so on.
- *
- */
-template <typename... E> struct Seq;
-
-template <>
-struct Seq<> {
-    struct V {};
-    using MatchT = MatchResult<V>;
-
-    static MatchT Match(const char* in) {
-        return MatchT(in, V());
-    }
-};
-
-template <typename E, typename... Es>
-struct Seq<E, Es...> {
-    class V {
-    public:
-        V(const typename E::V& head, const typename Seq<Es...>::V& tail)
-            : fHeadV(head), fTailV(tail) {}
-
-        template <size_t idx, typename std::enable_if<idx == 0, bool>::type = 0>
-        const typename E::V& get() const {
-            return fHeadV;
-        }
-
-        template <size_t idx, typename std::enable_if<idx != 0, bool>::type = 0>
-        const typename SelectV<idx, E, Es...>::V& get() const {
-            return fTailV.template get<idx - 1>();
-        }
-
-    private:
-        typename E::V          fHeadV;
-        typename Seq<Es...>::V fTailV;
-    };
-    using MatchT = MatchResult<V>;
-
-    static MatchT Match(const char* in) {
-        const auto headMatch = E::Match(in);
-        if (!headMatch) {
-            return nullptr;
-        }
-
-        const auto tailMatch = Seq<Es...>::Match(headMatch.fNext);
-        return tailMatch ? MatchT(tailMatch.fNext, V(*headMatch, *tailMatch))
-                         : nullptr;
-    }
-};
-
-/**
- * Ordered choice operator (e1|e2).
- *
- * Succeeds when either e1 or e2 match (e1 is tried first, then e2).
- *
- * The (optional) match results are stored in |v1|, |v2|.
- *
- */
-template <typename E1, typename E2>
-struct Choice {
-    struct V {
-        V (const typename E1::V* v1, const typename E2::V* v2) : v1(v1), v2(v2)
-        {
-            SkASSERT(!v1 || !v2);
-        }
-
-        SkTLazy<typename E1::V> v1;
-        SkTLazy<typename E2::V> v2;
-    };
-    using MatchT = MatchResult<V>;
-
-    static MatchT Match(const char* in) {
-        if (const auto m1 = E1::Match(in)) {
-            return MatchT(m1.fNext, V(m1.fValue.get(), nullptr));
-        }
-        if (const auto m2 = E2::Match(in)) {
-            return MatchT(m2.fNext, V(nullptr, m2.fValue.get()));
-        }
-        return nullptr;
-    }
-};
-
-/**
- * Zero-or-more operator (e*).  Always succeeds.
- *
- * Matches e greedily, and stores the match results in |fValues|.
- *
- */
-template <typename E>
-struct Any {
-    struct V {
-        V(SkTDArray<typename E::V>&& vs) : fValues(vs) {}
-
-        SkTDArray<typename E::V> fValues;
-    };
-    using MatchT = MatchResult<V>;
-
-    static MatchT Match(const char* in) {
-        SkTDArray<typename E::V> values;
-        while (const auto m = E::Match(in)) {
-            in = m.fNext;
-            *values.append() = *m;
-        }
-        return MatchT(in, std::move(values));
-    }
-};
-
-/**
- * One-or-more operator (e+).
- *
- * Same as zero-or-more, except it fails if e doesn't match at least once.
- *
- */
-template <typename E>
-using Some = Seq<E, Any<E>>;
-
-/**
- * End-of-string atom.  Matches \0.
- */
-struct EOS {
-    struct V {};
-    using MatchT = MatchResult<V>;
-
-    static MatchT Match(const char* in) {
-        return (*in != '\0') ? nullptr : MatchT(in, V());
-    }
-};
-
-
-/**
- * Literal atom.  Matches a list of char literals.
- */
-template <char... Cs> struct LIT;
-
-template <>
-struct LIT<> {
-    struct V {};
-    using MatchT = MatchResult<V>;
-
-    static MatchT Match(const char* in) {
-        return MatchT(in, V());
-    }
-};
-
-template <char C, char... Cs>
-struct LIT<C, Cs...> {
-    struct V {};
-    using MatchT = MatchResult<V>;
-
-    static MatchT Match(const char* in) {
-        if (*in != C) {
-            return nullptr;
-        }
-        const auto m = LIT<Cs...>::Match(in + 1);
-        return m ? MatchT(m.fNext, V()) : nullptr;
-    }
-};
-
-} // skpeg ns
-
-#endif // SkPEG_DEFINED