Bugzilla

        use std::sync::Arc;

        use std::sync::Arc;

        use values::computed::{Context, ToComputedValue};

        use values::computed::{Context, ToComputedValue};

        use values::{computed, specified};

        use values::{computed, specified};

        use Atom;

        use Atom;

        ${caller.body()}

        ${caller.body()}

        #[allow(unused_variables)]

        #[allow(unused_variables)]

        pub fn cascade_property(declaration: &PropertyDeclaration,

        pub fn cascade_property(declaration: &PropertyDeclaration,

                                inherited_style: &ComputedValues,

                                inherited_style: &ComputedValues,

                                context: &mut computed::Context,

                                context: &mut computed::Context,

                                seen: &mut PropertyBitField,

                                seen: &mut PropertyBitField,

                                cacheable: &mut bool,

                                cacheable: &mut bool,

                                cascade_info: &mut Option<<&mut CascadeInfo>,

                                cascade_info: &mut Option<<&mut CascadeInfo>,

                                error_reporter: &mut StdBox<ParseErrorReporter + Send>) {

                                error_reporter: &mut StdBox<ParseErrorReporter + Send>) {

            let declared_value = match *declaration {

            let declared_value = match *declaration {

                PropertyDeclaration::${property.camel_case}(ref declared_value) => {

                PropertyDeclaration::${property.camel_case}(ref declared_value) => {

                    declared_value

                    declared_value

                            }

                            }

                            DeclaredValue::WithVariables { .. } => unreachable!(),

                            DeclaredValue::WithVariables { .. } => unreachable!(),

                            % if not data.current_style_struct.inherited:

                            % if not data.current_style_struct.inherited:

                            DeclaredValue::Unset |

                            DeclaredValue::Unset |

                            % endif

                            % endif

                            DeclaredValue::Initial => {

                            DeclaredValue::Initial => {

                                // We assume that it's faster to use copy_*_from rather than

                                // We assume that it's faster to use copy_*_from rather than

                                // set_*(get_initial_value());

                                // set_*(get_initial_value());

                                                      .get_${data.current_style_struct.name_lower}();

                                                      .get_${data.current_style_struct.name_lower}();

                                context.mutate_style().mutate_${data.current_style_struct.name_lower}()

                                context.mutate_style().mutate_${data.current_style_struct.name_lower}()

                                                      .copy_${property.ident}_from(initial_struct ${maybe_wm});

                                                      .copy_${property.ident}_from(initial_struct ${maybe_wm});

                            },

                            },

                            % if data.current_style_struct.inherited:

                            % if data.current_style_struct.inherited:

                            DeclaredValue::Unset |

                            DeclaredValue::Unset |

                            % endif

                            % endif

                            DeclaredValue::Inherit => {

                            DeclaredValue::Inherit => {

            root_font_size: longhands::font_size::get_initial_value(),

            root_font_size: longhands::font_size::get_initial_value(),

        };

        };

    }

    }

}

}

pub type CascadePropertyFn =

pub type CascadePropertyFn =

    extern "Rust" fn(declaration: &PropertyDeclaration,

    extern "Rust" fn(declaration: &PropertyDeclaration,

                     inherited_style: &ComputedValues,

                     inherited_style: &ComputedValues,

                     context: &mut computed::Context,

                     context: &mut computed::Context,

                     seen: &mut PropertyBitField,

                     seen: &mut PropertyBitField,

                     cacheable: &mut bool,

                     cacheable: &mut bool,

                     cascade_info: &mut Option<<&mut CascadeInfo>,

                     cascade_info: &mut Option<<&mut CascadeInfo>,

                     error_reporter: &mut StdBox<ParseErrorReporter + Send>);

                     error_reporter: &mut StdBox<ParseErrorReporter + Send>);

#[cfg(feature = "servo")]

#[cfg(feature = "servo")]

static CASCADE_PROPERTY: [CascadePropertyFn; ${len(data.longhands)}] = [

static CASCADE_PROPERTY: [CascadePropertyFn; ${len(data.longhands)}] = [

                    is_early_property

                    is_early_property

                {

                {

                    continue

                    continue

                }

                }

                let discriminant = longhand_id as usize;

                let discriminant = longhand_id as usize;

                (cascade_property[discriminant])(declaration,

                (cascade_property[discriminant])(declaration,

                                                 inherited_style,

                                                 inherited_style,

                                                 &mut context,

                                                 &mut context,

                                                 &mut seen,

                                                 &mut seen,

                                                 &mut cacheable,

                                                 &mut cacheable,

                                                 &mut cascade_info,

                                                 &mut cascade_info,

                                                 &mut error_reporter);

                                                 &mut error_reporter);

            }

            }

            % if category_to_cascade_now == "early":

            % if category_to_cascade_now == "early":

                let mode = get_writing_mode(context.style.get_inheritedbox());

                let mode = get_writing_mode(context.style.get_inheritedbox());