DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (b6d82b1a6b02)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sts=2 et sw=2 tw=80:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
 * A variant-like class abstracting operations on a Parser with a given
 * ParseHandler but unspecified character type.
 */

#ifndef frontend_EitherParser_h
#define frontend_EitherParser_h

#include "mozilla/Attributes.h"
#include "mozilla/Move.h"
#include "mozilla/Tuple.h"
#include "mozilla/TypeTraits.h"
#include "mozilla/Utf8.h"
#include "mozilla/Variant.h"

#include <utility>

#include "frontend/BCEParserHandle.h"
#include "frontend/Parser.h"
#include "frontend/TokenStream.h"

namespace js {

namespace detail {

template <template <class Parser> class GetThis,
          template <class This> class MemberFunction, typename... Args>
struct InvokeMemberFunction {
  mozilla::Tuple<typename mozilla::Decay<Args>::Type...> args;

  template <class This, size_t... Indices>
  auto matchInternal(This* obj, std::index_sequence<Indices...>) -> decltype(
      ((*obj).*(MemberFunction<This>::get()))(mozilla::Get<Indices>(args)...)) {
    return ((*obj).*
            (MemberFunction<This>::get()))(mozilla::Get<Indices>(args)...);
  }

 public:
  template <typename... ActualArgs>
  explicit InvokeMemberFunction(ActualArgs&&... actualArgs)
      : args{std::forward<ActualArgs>(actualArgs)...} {}

  template <class Parser>
  auto operator()(Parser* parser)
      -> decltype(this->matchInternal(GetThis<Parser>::get(parser),
                                      std::index_sequence_for<Args...>{})) {
    return this->matchInternal(GetThis<Parser>::get(parser),
                               std::index_sequence_for<Args...>{});
  }
};

// |this|-computing templates.

template <class Parser>
struct GetParser {
  static Parser* get(Parser* parser) { return parser; }
};

template <class Parser>
struct GetTokenStream {
  static auto get(Parser* parser) { return &parser->tokenStream; }
};

// Member function-computing templates.

template <class Parser>
struct ParserOptions {
  static constexpr auto get() { return &Parser::options; }
};

template <class Parser>
struct ParserNewObjectBox {
  static constexpr auto get() { return &Parser::newObjectBox; }
};

template <class TokenStream>
struct TokenStreamComputeLineAndColumn {
  static constexpr auto get() { return &TokenStream::computeLineAndColumn; }
};

// Generic matchers.

struct ParseHandlerMatcher {
  template <class Parser>
  frontend::FullParseHandler& operator()(Parser* parser) {
    return parser->handler_;
  }
};

struct ParserSharedBaseMatcher {
  template <class Parser>
  frontend::ParserSharedBase& operator()(Parser* parser) {
    return *static_cast<frontend::ParserSharedBase*>(parser);
  }
};

struct ErrorReporterMatcher {
  template <class Parser>
  frontend::ErrorReporter& operator()(Parser* parser) {
    return parser->tokenStream;
  }
};

}  // namespace detail

namespace frontend {

class EitherParser : public BCEParserHandle {
  // Leave this as a variant, to promote good form until 8-bit parser
  // integration.
  mozilla::Variant<Parser<FullParseHandler, char16_t>* const,
                   Parser<FullParseHandler, mozilla::Utf8Unit>* const>
      parser;

  using Node = typename FullParseHandler::Node;

  template <template <class Parser> class GetThis,
            template <class This> class GetMemberFunction,
            typename... StoredArgs>
  using InvokeMemberFunction =
      detail::InvokeMemberFunction<GetThis, GetMemberFunction, StoredArgs...>;

 public:
  template <class Parser>
  explicit EitherParser(Parser* parser) : parser(parser) {}

  FullParseHandler& astGenerator() final {
    return parser.match(detail::ParseHandlerMatcher());
  }

  ErrorReporter& errorReporter() final {
    return parser.match(detail::ErrorReporterMatcher());
  }
  const ErrorReporter& errorReporter() const final {
    return parser.match(detail::ErrorReporterMatcher());
  }

  const JS::ReadOnlyCompileOptions& options() const final {
    InvokeMemberFunction<detail::GetParser, detail::ParserOptions>
        optionsMatcher;
    return parser.match(std::move(optionsMatcher));
  }

  ObjectBox* newObjectBox(JSObject* obj) final {
    InvokeMemberFunction<detail::GetParser, detail::ParserNewObjectBox,
                         JSObject*>
        matcher{obj};
    return parser.match(std::move(matcher));
  }

  void computeLineAndColumn(uint32_t offset, uint32_t* line,
                            uint32_t* column) const {
    InvokeMemberFunction<detail::GetTokenStream,
                         detail::TokenStreamComputeLineAndColumn, uint32_t,
                         uint32_t*, uint32_t*>
        matcher{offset, line, column};
    return parser.match(std::move(matcher));
  }
};

} /* namespace frontend */
} /* namespace js */

#endif /* frontend_EitherParser_h */