html_lexer.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_LEXER_H_
#define PAGESPEED_KERNEL_HTML_HTML_LEXER_H_

#include <vector>

#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/printf_format.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/html/doctype.h"
#include "pagespeed/kernel/html/html_element.h"
#include "pagespeed/kernel/html/html_name.h"
#include "pagespeed/kernel/http/content_type.h"

namespace net_instaweb {

class HtmlParse;

class HtmlLexer {
 public:
  explicit HtmlLexer(HtmlParse* html_parse);
  ~HtmlLexer();

  void StartParse(const StringPiece& id, const ContentType& content_type);

  void Parse(const char* text, int size);

  void FinishParse();

  bool IsImplicitlyClosedTag(HtmlName::Keyword keyword) const;

  static bool IsLiteralTag(HtmlName::Keyword keyword);

  static bool IsSometimesLiteralTag(HtmlName::Keyword keyword);

  bool TagAllowsBriefTermination(HtmlName::Keyword keyword) const;

  bool IsOptionallyClosedTag(HtmlName::Keyword keyword) const;

  void DebugPrintStack();

  HtmlElement* Parent() const;

  const DocType& doctype() const { return doctype_; }

  void set_size_limit(int64 x) { size_limit_ = x; }

  bool size_limit_exceeded() const { return size_limit_exceeded_; }

 private:
  inline void EvalStart(char c);
  inline void EvalTag(char c);
  inline void EvalTagOpen(char c);
  inline void EvalTagCloseNoName(char c);
  inline void EvalTagClose(char c);
  inline void EvalTagBriefClose(char c);
  inline void EvalCommentStart1(char c);
  inline void EvalCommentStart2(char c);
  inline void EvalCommentBody(char c);
  inline void EvalCommentEnd1(char c);
  inline void EvalCommentEnd2(char c);
  inline void EvalCdataStart1(char c);
  inline void EvalCdataStart2(char c);
  inline void EvalCdataStart3(char c);
  inline void EvalCdataStart4(char c);
  inline void EvalCdataStart5(char c);
  inline void EvalCdataStart6(char c);
  inline void EvalCdataBody(char c);
  inline void EvalCdataEnd1(char c);
  inline void EvalCdataEnd2(char c);
  inline void EvalAttribute(char c);
  inline void EvalAttrName(char c);
  inline void EvalAttrNameSpace(char c);
  inline void EvalAttrEq(char c);
  inline void EvalAttrVal(char c);
  inline void EvalAttrValSq(char c);
  inline void EvalAttrValDq(char c);
  inline void EvalLiteralTag(char c);
  inline void EvalScriptTag(char c);
  inline void EvalDirective(char c);
  inline void EvalBogusComment(char c);

  void MakeElement();

  void MakeAttribute(bool has_value);
  void FinishAttribute(char c, bool has_value, bool brief_close);

  void EmitCdata();
  void EmitComment();
  void EmitLiteral();
  void EmitTagOpen(bool allow_implicit_close); 
  void EmitTagClose(HtmlElement::Style style);
  void EmitTagBriefClose();
  void EmitDirective();
  void Restart(char c);

  void SyntaxError(const char* format, ...) INSTAWEB_PRINTF_FORMAT(2, 3);

  HtmlElement* PopElementMatchingTag(const StringPiece& tag);

  HtmlElement* PopElement();
  void CloseElement(HtmlElement* element, HtmlElement::Style style);

  static inline bool IsI18nChar(char c) {return (((c) & 0x80) != 0); }

  static inline bool IsLegalTagFirstChar(char c);
  static inline bool IsLegalTagChar(char c);

  static inline bool IsLegalAttrNameChar(char c);

  enum State {
    START,
    TAG,                   
    TAG_CLOSE_NO_NAME,     
    TAG_CLOSE,             
    TAG_CLOSE_TERMINATE,   
    TAG_OPEN,              
    TAG_BRIEF_CLOSE,       
    COMMENT_START1,        
    COMMENT_START2,        
    COMMENT_BODY,          
    COMMENT_END1,          
    COMMENT_END2,          
    CDATA_START1,          
    CDATA_START2,          
    CDATA_START3,          
    CDATA_START4,          
    CDATA_START5,          
    CDATA_START6,          
    CDATA_BODY,            
    CDATA_END1,            
    CDATA_END2,            
    TAG_ATTRIBUTE,         
    TAG_ATTR_NAME,         
    TAG_ATTR_NAME_SPACE,   
    TAG_ATTR_EQ,           
    TAG_ATTR_VAL,          
    TAG_ATTR_VALDQ,        
    TAG_ATTR_VALSQ,        
    LITERAL_TAG,           
    SCRIPT_TAG,            
    DIRECTIVE,             
    BOGUS_COMMENT,         
  };

  HtmlParse* html_parse_;
  State state_;
  GoogleString token_; 
  GoogleString literal_; 
  GoogleString attr_name_; 
  GoogleString attr_value_; 
  HtmlElement::QuoteStyle attr_quote_; 
  bool has_attr_value_; 
  HtmlElement* element_; 
  int line_;
  int tag_start_line_; 
  GoogleString id_;
  GoogleString literal_close_; 
  bool script_html_comment_; 
  bool script_html_comment_script_; 
  bool discard_until_start_state_for_error_recovery_;

  ContentType content_type_;
  DocType doctype_;

  std::vector<HtmlElement*> element_stack_;

  bool size_limit_exceeded_;
  bool skip_parsing_;
  int64 num_bytes_parsed_;
  int64 size_limit_;

  
};

}  

#endif