html_keywords.h

Go to the documentation of this file.

/*
 * Copyright 2010 Google Inc.
 *
 * 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 PAGESPEED_KERNEL_HTML_HTML_KEYWORDS_H_
#define PAGESPEED_KERNEL_HTML_HTML_KEYWORDS_H_

#include <algorithm>
#include <vector>

#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_hash.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/base/sparse_hash_map.h"
#include "pagespeed/kernel/html/html_name.h"

namespace net_instaweb {

class MessageHandler;
class Writer;

class HtmlKeywords {
 public:
  static void Init();

  static void ShutDown();

  static const StringPiece* KeywordToString(HtmlName::Keyword keyword) {
    if (keyword < HtmlName::kNotAKeyword) {
      return &singleton_->keyword_vector_[keyword];
    } else {
      return NULL;
    }
  }

  static StringPiece Escape(const StringPiece& unescaped, GoogleString* buf) {
    return singleton_->EscapeHelper(unescaped, buf);
  }

  static StringPiece Unescape(const StringPiece& escaped, GoogleString* buf,
                              bool* decoding_error) {
    return singleton_->UnescapeHelper(escaped, buf, decoding_error);
  }


  static bool IsAutoClose(HtmlName::Keyword k1, HtmlName::Keyword k2) {
    return std::binary_search(singleton_->auto_close_.begin(),
                              singleton_->auto_close_.end(),
                              MakeKeywordPair(k1, k2));
  }

  static bool IsContained(HtmlName::Keyword k1, HtmlName::Keyword k2) {
    return std::binary_search(singleton_->contained_.begin(),
                              singleton_->contained_.end(),
                              MakeKeywordPair(k1, k2));
  }

  static bool IsOptionallyClosedTag(HtmlName::Keyword keyword) {
    return std::binary_search(singleton_->optionally_closed_.begin(),
                              singleton_->optionally_closed_.end(),
                              keyword);
  }

  static bool WritePre(StringPiece text, StringPiece style,
                       Writer* writer, MessageHandler* handler);

 private:
  typedef int32 KeywordPair; 
  typedef std::vector<KeywordPair> KeywordPairVec;
  typedef std::vector<HtmlName::Keyword> KeywordVec;

  HtmlKeywords();
  const char* UnescapeAttributeValue();
  void InitEscapeSequences();
  void InitAutoClose();
  void InitContains();
  void InitOptionallyClosedKeywords();

  bool TryUnescape(bool accumulate_numeric_code,
                   uint32 numeric_value,
                   const GoogleString& escape,
                   bool was_terminated,
                   GoogleString* buf) const;

  static KeywordPair MakeKeywordPair(HtmlName::Keyword k1,
                                     HtmlName::Keyword k2) {
    return (static_cast<KeywordPair>(k1) << 16) | static_cast<KeywordPair>(k2);
  }

  void AddCrossProduct(const StringPiece& k1_list, const StringPiece& k2_list,
                       KeywordPairVec* kmap);
  void AddAutoClose(const StringPiece& k1_list, const StringPiece& k2_list) {
    AddCrossProduct(k1_list, k2_list, &auto_close_);
  }
  void AddContained(const StringPiece& k1_list, const StringPiece& k2_list) {
    AddCrossProduct(k1_list, k2_list, &contained_);
  }

  void AddToSet(const StringPiece& klist, KeywordVec* kset);

  static HtmlKeywords* singleton_;

  StringPiece EscapeHelper(const StringPiece& unescaped,
                           GoogleString* buf) const;
  StringPiece UnescapeHelper(const StringPiece& escaped,
                             GoogleString* buf,
                             bool* decoding_error) const;

  typedef sparse_hash_map<
    GoogleString, const char*,
    CaseFoldStringHash,
    CaseFoldStringEqual> StringStringSparseHashMapInsensitive;
  typedef sparse_hash_map<
    GoogleString, const char*,
    CasePreserveStringHash> StringStringSparseHashMapSensitive;

  StringStringSparseHashMapInsensitive unescape_insensitive_map_;
  StringStringSparseHashMapSensitive unescape_sensitive_map_;
  StringStringSparseHashMapSensitive escape_map_;

  StringPieceVector keyword_vector_;

  KeywordPairVec auto_close_;
  KeywordPairVec contained_;
  KeywordVec optionally_closed_;

  
};

}  

#endif