Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-06 06:00:15 +01:00
Code Issues Projects Releases Packages Wiki Activity

Move parsers and lexers to css/ and html/ top-level dirs; fix some s/import/use/

Browse source
This commit is contained in:
Brian J. Burg 2012-09-06 15:44:12 -07:00
parent 10f1729a71
commit 977389d2a3
9 changed files with 87 additions and 86 deletions
Download patch file Download diff file Expand all files Collapse all files

64
src/servo/content/content_task.rs
View file

@ -7,43 +7,43 @@ export ContentTask;
export ControlMsg, ExecuteMsg, ParseMsg, ExitMsg, Timer;
export PingMsg, PongMsg;
import std::arc::{ARC, clone};
import comm::{Port, Chan, listen, select2};
import task::{spawn, spawn_listener};
import io::{read_whole_file, println};
use std::arc::{ARC, clone};
use comm::{Port, Chan, listen, select2};
use task::{spawn, spawn_listener};
use io::{read_whole_file, println};
import dom::base::{Document, Node, NodeScope, Window, define_bindings};
import dom::event::{Event, ResizeEvent, ReflowEvent};
import gfx::compositor::Compositor;
import parser::html_lexer::spawn_html_lexer_task;
import parser::html_builder::build_dom;
import layout::layout_task;
import layout_task::{LayoutTask, BuildMsg};
use dom::base::{Document, Node, NodeScope, Window, define_bindings};
use dom::event::{Event, ResizeEvent, ReflowEvent};
use gfx::compositor::Compositor;
use html::lexer::spawn_html_lexer_task;
use html::dom_builder::build_dom;
use layout::layout_task;
use layout_task::{LayoutTask, BuildMsg};
import css::styles::Stylesheet;
use css::styles::Stylesheet;
import jsrt = js::rust::rt;
import js::rust::{cx, methods};
import js::global::{global_class, debug_fns};
use jsrt = js::rust::rt;
use js::rust::{cx, methods};
use js::global::{global_class, debug_fns};
import either::{Either, Left, Right};
use either::{Either, Left, Right};
import dom::bindings::utils::rust_box;
import js::rust::compartment;
use dom::bindings::utils::rust_box;
use js::rust::compartment;
import resource::resource_task;
import resource_task::{ResourceTask};
use resource::resource_task;
use resource_task::{ResourceTask};
import std::net::url::Url;
import url_to_str = std::net::url::to_str;
import util::url::make_url;
import task::{task, SingleThreaded};
use std::net::url::Url;
use url_to_str = std::net::url::to_str;
use util::url::make_url;
use task::{task, SingleThreaded};
import js::glue::bindgen::RUST_JSVAL_TO_OBJECT;
import js::JSVAL_NULL;
import js::jsapi::jsval;
import js::jsapi::bindgen::JS_CallFunctionValue;
import ptr::null;
use js::glue::bindgen::RUST_JSVAL_TO_OBJECT;
use js::JSVAL_NULL;
use js::jsapi::jsval;
use js::jsapi::bindgen::JS_CallFunctionValue;
use ptr::null;
enum ControlMsg {
ParseMsg(Url),
@ -149,9 +149,9 @@ struct Content<C:Compositor> {
let css_rules = style_port.recv();
let js_scripts = js_port.recv();*/
let result = parser::hubbub_html_parser::parse_html(self.scope,
url,
self.resource_task);
let result = html::hubbub_html_parser::parse_html(self.scope,
url,
self.resource_task);
let root = result.root;
let css_rules = result.style_port.recv();

14
src/servo/parser/css_lexer.rs → src/servo/css/lexer.rs
View file

@ -1,15 +1,15 @@
#[doc = "Code to lex and tokenize css files."]
import option::is_none;
import str::from_bytes;
import vec::push;
use option::is_none;
use str::from_bytes;
use vec::push;
import pipes::{Port, Chan};
use pipes::{Port, Chan};
import lexer_util::*;
use html::lexer_util::*;
import std::net::url::Url;
import resource::resource_task::{ResourceTask, ProgressMsg, Load};
use std::net::url::Url;
use resource::resource_task::{ResourceTask, ProgressMsg, Load};
enum ParserState {
CssElement,

20
src/servo/parser/css_builder.rs → src/servo/css/parser.rs
View file

@ -3,18 +3,18 @@
// TODO: fail according to the css spec instead of failing when things
// are not as expected
import css::values::{DisInline, DisBlock, DisNone, Display, TextColor, BackgroundColor, FontSize,
use css::values::{DisInline, DisBlock, DisNone, Display, TextColor, BackgroundColor, FontSize,
Height, Width, StyleDeclaration};
// Disambiguate parsed Selector, Rule values from tokens
import css = css::values;
import tok = parser::css_lexer;
import parser::css_lexer::Token;
import comm::recv;
import option::{map, is_none};
import vec::push;
import parser::parser_util::{parse_display_type, parse_font_size, parse_size};
import util::color::parsing::parse_color;
import vec::push;
use css = css::values;
use tok = lexer;
use lexer::Token;
use comm::recv;
use option::{map, is_none};
use vec::push;
use parser_util::*;
use util::color::parsing::parse_color;
use vec::push;
type TokenReader = {stream : pipes::Port<Token>, mut lookahead : Option<Token>};

0
src/servo/parser/parser_util.rs → src/servo/css/parser_util.rs
View file

46
src/servo/parser/html_builder.rs → src/servo/html/dom_builder.rs
View file

@ -1,18 +1,18 @@
#[doc="Constructs a DOM tree from an incoming token stream."]
import dom::base::{Attr, Element, ElementData, ElementKind, HTMLDivElement, HTMLHeadElement,
use dom::base::{Attr, Element, ElementData, ElementKind, HTMLDivElement, HTMLHeadElement,
HTMLScriptElement};
import dom::base::{HTMLImageElement, Node, NodeScope, Text, UnknownElement};
import geom::size::Size2D;
import gfx::geometry;
import gfx::geometry::au;
import parser = parser::html_lexer;
import parser::Token;
import css::values::Stylesheet;
import vec::{push, push_all_move, flat_map};
import std::net::url::Url;
import resource::resource_task::{ResourceTask, Load, Payload, Done};
import to_str::ToStr;
use dom::base::{HTMLImageElement, Node, NodeScope, Text, UnknownElement};
use geom::size::Size2D;
use gfx::geometry;
use gfx::geometry::au;
use html::lexer;
use html::lexer::Token;
use css::values::Stylesheet;
use vec::{push, push_all_move, flat_map};
use std::net::url::Url;
use resource::resource_task::{ResourceTask, Load, Payload, Done};
use to_str::ToStr;
enum CSSMessage {
File(Url),
@ -105,8 +105,8 @@ fn css_link_listener(to_parent : comm::Chan<Stylesheet>, from_parent : comm::Por
let url = copy url;
task::spawn(|| {
// TODO: change copy to move once we can move into closures
let css_stream = css_lexer::spawn_css_lexer_task(copy url, resource_task);
let mut css_rules = css_builder::build_stylesheet(css_stream);
let css_stream = css::lexer::spawn_css_lexer_task(copy url, resource_task);
let mut css_rules = css::parser::build_stylesheet(css_stream);
result_chan.send(css_rules);
});
@ -192,24 +192,24 @@ fn build_dom(scope: NodeScope, stream: comm::Port<Token>, url: Url,
loop {
let token = stream.recv();
match token {
parser::Eof => { break; }
parser::StartOpeningTag(tag_name) => {
lexer::Eof => { break; }
lexer::StartOpeningTag(tag_name) => {
#debug["starting tag %s", tag_name];
let element_kind = build_element_kind(tag_name);
let new_node = scope.new_node(Element(ElementData(copy tag_name, element_kind)));
scope.add_child(cur_node, new_node);
cur_node = new_node;
}
parser::Attr(key, value) => {
lexer::Attr(key, value) => {
#debug["attr: %? = %?", key, value];
link_up_attribute(scope, cur_node, copy key, copy value);
}
parser::EndOpeningTag => {
lexer::EndOpeningTag => {
#debug("end opening tag");
}
// TODO: Fail more gracefully (i.e. according to the HTML5
// spec) if we close more tags than we open.
parser::SelfCloseTag => {
lexer::SelfCloseTag => {
//TODO: check for things other than the link tag
scope.read(cur_node, |n| {
match *n.kind {
@ -234,7 +234,7 @@ fn build_dom(scope: NodeScope, stream: comm::Port<Token>, url: Url,
});
cur_node = scope.get_parent(cur_node).get();
}
parser::EndTag(*) => {
lexer::EndTag(*) => {
// TODO: Assert that the closing tag has the right name.
scope.read(cur_node, |n| {
match *n.kind {
@ -253,14 +253,14 @@ fn build_dom(scope: NodeScope, stream: comm::Port<Token>, url: Url,
});
cur_node = scope.get_parent(cur_node).get();
}
parser::Text(s) if !s.is_whitespace() => {
lexer::Text(s) if !s.is_whitespace() => {
let new_node = scope.new_node(Text(copy s));
scope.add_child(cur_node, new_node);
}
parser::Text(_) => {
lexer::Text(_) => {
// FIXME: Whitespace should not be ignored.
}
parser::Doctype => {
lexer::Doctype => {
// TODO: Do something here...
}
}

16
src/servo/parser/hubbub_html_parser.rs → src/servo/html/hubbub_html_parser.rs
View file

@ -4,13 +4,13 @@ use dom::base::{Node, NodeScope, Text, UnknownElement};
use css::values::Stylesheet;
use geom::size::Size2D;
use gfx::geometry::px_to_au;
use parser::html_builder::CSSMessage;
use html::dom_builder::CSSMessage;
use resource::resource_task::{Done, Load, Payload, ResourceTask};
use CSSExitMessage = parser::html_builder::Exit;
use CSSFileMessage = parser::html_builder::File;
use JSExitMessage = parser::html_builder::js_exit;
use JSFileMessage = parser::html_builder::js_file;
use JSMessage = parser::html_builder::js_message;
use CSSExitMessage = html::dom_builder::Exit;
use CSSFileMessage = html::dom_builder::File;
use JSExitMessage = html::dom_builder::js_exit;
use JSFileMessage = html::dom_builder::js_file;
use JSMessage = html::dom_builder::js_message;
use comm::{Chan, Port};
use str::from_slice;
@ -52,8 +52,8 @@ fn css_link_listener(to_parent : comm::Chan<Stylesheet>, from_parent : comm::Por
let url = copy url;
task::spawn(|| {
// TODO: change copy to move once we can move into closures
let css_stream = css_lexer::spawn_css_lexer_task(copy url, resource_task);
let mut css_rules = css_builder::build_stylesheet(css_stream);
let css_stream = css::lexer::spawn_css_lexer_task(copy url, resource_task);
let mut css_rules = css::parser::build_stylesheet(css_stream);
result_chan.send(css_rules);
});

0
src/servo/parser/html_lexer.rs → src/servo/html/lexer.rs
View file

0
src/servo/parser/lexer_util.rs → src/servo/html/lexer_util.rs
View file

13
src/servo/servo.rc
View file

@ -39,6 +39,10 @@ mod content {
}
mod css {
mod lexer;
mod parser;
mod parser_util;
mod values;
mod styles;
mod resolve {
@ -74,13 +78,10 @@ mod image {
}
}
mod parser {
mod html {
mod lexer;
mod lexer_util;
mod parser_util;
mod css_lexer;
mod html_lexer;
mod html_builder;
mod css_builder;
mod dom_builder;
mod hubbub_html_parser;
}