vendor/xml5ever/examples/simple_xml_tokenizer.rs

   1 #!/usr/bin/env run-cargo-script
   2 //! This is a regular crate doc comment, but it also contains a partial
   3 //! Cargo manifest.  Note the use of a *fenced* code block, and the
   4 //! `cargo` "language".
   5 //!
   6 //! ```cargo
   7 //! [dependencies]
   8 //! xml5ever = "0.1.1"
   9 //! tendril = "0.1.3"
  10 //! markup5ever = "0.7.4"
  11 //! ```
  12 extern crate markup5ever;
  13 extern crate xml5ever;
  14
  15 use std::default::Default;
  16 use std::io;
  17
  18 use markup5ever::buffer_queue::BufferQueue;
  19 use xml5ever::tendril::{ByteTendril, ReadExt};
  20 use xml5ever::tokenizer::{CharacterTokens, NullCharacterToken, TagToken};
  21 use xml5ever::tokenizer::{CommentToken, PIToken, Pi};
  22 use xml5ever::tokenizer::{Doctype, DoctypeToken, EOFToken};
  23 use xml5ever::tokenizer::{ParseError, Token, TokenSink, XmlTokenizer};
  24
  25 struct SimpleTokenPrinter;
  26
  27 impl TokenSink for SimpleTokenPrinter {
  28     fn process_token(&mut self, token: Token) {
  29         match token {
  30             CharacterTokens(b) => {
  31                 println!("TEXT: {}", &*b);
  32             },
  33             NullCharacterToken => print!("NULL"),
  34             TagToken(tag) => {
  35                 println!("{:?} {} ", tag.kind, &*tag.name.local);
  36             },
  37             ParseError(err) => {
  38                 println!("ERROR: {}", err);
  39             },
  40             PIToken(Pi {
  41                 ref target,
  42                 ref data,
  43             }) => {
  44                 println!("PI : <?{} {}?>", &*target, &*data);
  45             },
  46             CommentToken(ref comment) => {
  47                 println!("<!--{:?}-->", &*comment);
  48             },
  49             EOFToken => {
  50                 println!("EOF");
  51             },
  52             DoctypeToken(Doctype {
  53                 ref name,
  54                 ref public_id,
  55                 ..
  56             }) => {
  57                 println!("<!DOCTYPE {:?} {:?}>", &*name, &*public_id);
  58             },
  59         }
  60     }
  61 }
  62
  63 fn main() {
  64     // Our implementation of TokenSink
  65     let sink = SimpleTokenPrinter;
  66
  67     // We need a ByteTendril to read a file
  68     let mut input = ByteTendril::new();
  69
  70     // Using SliceExt.read_to_tendril we can read stdin
  71     io::stdin().read_to_tendril(&mut input).unwrap();
  72     // For xml5ever we need StrTendril, so we reinterpret it
  73     // into StrTendril.
  74
  75     // Load input into BufferQueue
  76     let mut input_buffer = BufferQueue::new();
  77     input_buffer.push_back(input.try_reinterpret().unwrap());
  78     // Here we create and run tokenizer
  79     let mut tok = XmlTokenizer::new(sink, Default::default());
  80     tok.feed(&mut input_buffer);
  81     tok.end();
  82 }