// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef COBALT_CSS_PARSER_SCANNER_H_
#define COBALT_CSS_PARSER_SCANNER_H_

#include <deque>
#include <stack>
#include <string>

#include "base/basictypes.h"
#include "cobalt/css_parser/grammar.h"
#include "cobalt/cssom/media_feature_names.h"
#include "third_party/icu/source/common/unicode/umachine.h"

namespace cobalt {
namespace css_parser {

class StringPool;
typedef int Token;
struct TrivialStringPiece;

// Being initialized with a zero-terminated input string in UTF-8 encoding,
// a scanner produces a series of CSS tokens, ending with kEndOfFileToken.
// The scanner is designed to be resilient to errors in the input and is
// supposed to reach the end of the input in any case.
//
// The scanner tries to minimize the amount of string copying, with most
// returned strings referencing the input. If a string copy is needed because
// a string contains an escape sequence, the copy will be allocated on an
// injected string pool.
//
// This implementation is an adaptation of the hand-written CSS scanner from
// WebKit that has shown a 2x performance improvement over the one generated
// by Flex. See https://bugs.webkit.org/show_bug.cgi?id=70107.
//
// Detailed information on the CSS grammar can be found at
// https://www.w3.org/TR/css-syntax-3/.
class Scanner {
 public:
  Scanner(const char* input_iterator, StringPool* string_pool);

  // Recognizes a token under the input iterator.
  // Returns a token, initializes its value (if any) and advances the input
  // iterator accordingly. Guaranteed to succeed because unrecognized characters
  // are returned as is (and are expected to trigger a parser error).
  Token Scan(TokenValue* token_value, YYLTYPE* token_location);

  // Token injection, used by the parser to choose an entry point.
  void PrependToken(Token token);
  bool DetectPropertyNameToken(const std::string& property_name,
                               Token* property_name_token) const;

 private:
  // Parsing modes are the equivalent of Flex start conditions:
  // http://flex.sourceforge.net/manual/Start-Conditions.html
  enum ParsingMode {
    // A scanner is initialized in this mode and spends most of the time in it.
    kNormalMode,

    // A scanner enters this mode after seeing "@media" or "@import" and exits
    // it after ";" or "{". The mode is needed to recognize "and", "not", "only"
    // as keywords (which are treated as identifiers or function names in
    // normal mode).
    kMediaQueryMode,

    // A scanner enters this mode after seeing "@supports" and exits it after
    // ";" or "{". The mode is needed to recognize "and", "not", "or" as
    // keywords (which are treated as identifiers or function names in normal
    // mode).
    kSupportsMode,

    // A scanner enters this mode after seeing "nth-child" or similar function
    // and exits it after ")". The mode is needed to recognize "an+b"
    // microsyntax: https://www.w3.org/TR/css-syntax-3/#anb
    kNthChildMode
  };

  // ScanFrom*() methods are called by a main scanner loop when an input
  // iterator is pointing at a character of a corresponding type. These methods
  // are guaranteed to succeed. They always return a token, initialize its value
  // (if any) and advance the input iterator accordingly.
  Token ScanFromCaselessU(TokenValue* token_value);
  Token ScanFromIdentifierStart(TokenValue* token_value);
  Token ScanFromDot(TokenValue* token_value);
  Token ScanFromNumber(TokenValue* token_value);
  Token ScanFromDash(TokenValue* token_value);
  Token ScanFromOtherCharacter();
  Token ScanFromNull();  // Does not advance input_iterator_ beyond
                         // the end of input.
  Token ScanFromWhitespace();
  Token ScanFromEndMediaQueryOrSupports();
  Token ScanFromEndNthChild();
  Token ScanFromQuote(TokenValue* token_value);
  Token ScanFromExclamationMark(TokenValue* token_value);
  Token ScanFromHashmark(TokenValue* token_value);
  Token ScanFromSlash();
  Token ScanFromDollar();
  Token ScanFromAsterisk();
  Token ScanFromPlus(TokenValue* token_value);
  Token ScanFromLess();
  Token ScanFromAt(TokenValue* token_value);
  Token ScanFromBackSlash(TokenValue* token_value);
  Token ScanFromXor();
  Token ScanFromVerticalBar();
  Token ScanFromTilde();

  // Scan*() methods are much like ScanFrom*() except they recognize only one
  // type of tokens.
  //
  // TryScan*() methods also recognize only one type of tokens but are not
  // guaranteed to succeed. If they fail to recognize a token, they return false
  // and restore a position of the input iterator.
  //
  // Detect*() methods check whether a previously scanned identifier
  // matches one of CSS keywords. If they they succeed, they initialize a token
  // type and return true, otherwise they return false and leave a token type
  // intact.
  //
  // Detect*AndMaybeChangeParsingMode() methods may change a parsing mode
  // if they match an appropriate CSS keyword. The parsing mode may stay intact
  // even if a method succeeds.
  //
  // TryScanAndMaybeCopy*() methods are intended to be called twice: first time
  // to try scanning a token through a fast track that does not require copying,
  // second time through a slower copying track if an escape sequence is found
  // during the first pass.
  bool TryScanUnicodeRange(TrivialIntPair* value);
  void ScanIdentifier(TrivialStringPiece* value, bool* has_escape);
  bool IsInputIteratorAtIdentifierStart() const;
  template <bool copy>
  bool TryScanAndMaybeCopyIdentifier(TrivialStringPiece* value,
                                     std::string* value_copy);
  UChar32 ScanEscape();  // Escape is not a token, it is a part of string.
  bool DetectPropertyNameToken(const TrivialStringPiece& name,
                               Token* property_name_token) const;
  bool DetectPropertyValueToken(const TrivialStringPiece& name,
                                Token* property_value_token) const;
  bool DetectPseudoClassNameToken(const TrivialStringPiece& name,
                                  Token* pseudo_class_name_token) const;
  bool DetectPseudoElementNameToken(const TrivialStringPiece& name,
                                    Token* pseudo_element_name_token) const;
  bool DetectSupportsToken(const TrivialStringPiece& name,
                           Token* supports_token) const;
  bool DetectKnownFunctionTokenAndMaybeChangeParsingMode(
      const TrivialStringPiece& name, Token* known_function_token);
  bool DetectMediaQueryToken(const TrivialStringPiece& name,
                             Token* media_query_token,
                             cssom::MediaFeatureName* media_feature_name) const;
  bool TryScanUri(TrivialStringPiece* uri);
  bool FindUri(const char** uri_start, const char** uri_end, char* quote) const;
  template <bool copy>
  bool TryScanAndMaybeCopyUri(char quote, TrivialStringPiece* uri,
                              std::string* uri_copy);
  void ScanString(char quote, TrivialStringPiece* value);
  template <bool copy>
  bool TryScanAndMaybeCopyString(char quote, TrivialStringPiece* value,
                                 std::string* value_copy);
  bool TryScanNthChild(TrivialStringPiece* nth);
  bool TryScanNthChildExtra(TrivialStringPiece* nth);
  bool DetectUnitToken(const TrivialStringPiece& unit, Token* token) const;
  bool DetectAtTokenAndMaybeChangeParsingMode(const TrivialStringPiece& name,
                                              bool has_escape, Token* at_token);

  bool DetectMediaFeatureNamePrefix(Token* token);
  void ScanUnrecognizedAtRule();
  void HandleBraceIfExists(char character);

  const char* input_iterator_;
  StringPool* const string_pool_;

  ParsingMode parsing_mode_;

  int line_number_;
  const char* line_start_;

  std::deque<Token> prepended_tokens_;

  // Used to cache the open braces and close them if no matching at the end of
  // input.
  std::stack<char> open_braces_;

  DISALLOW_COPY_AND_ASSIGN(Scanner);
};

// By Bison's convention, a function that returns next token, should
// be named yylex().
inline Token yylex(TokenValue* token_value, YYLTYPE* token_location,
                   Scanner* scanner) {
  return scanner->Scan(token_value, token_location);
}

}  // namespace css_parser
}  // namespace cobalt

#endif  // COBALT_CSS_PARSER_SCANNER_H_