Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-css

Source of release 0.5.1

0.5.1 / tests / css_data_dump / dump_parts.lucb

#==============================================================================================
#
#   dump_parts - the keyword, input, property, descriptor, small-enum and unit parts
#
#   DESCRIPTION:
#       Each part prints the answers of one group of css_data functions, in the order and
#       format of the C++ side of the dump.
#
#==============================================================================================

## An optional enum value as its integer.
func opt[E](value: E?, to_int: func(E) -> u64) -> u64?:
    let present = value else return none
    return to_int(present)

func keyword_int(keyword: css_data.Keyword) -> u64:
    return (u64)(u16)keyword

func property_int(property_id: css_data.PropertyId) -> u64:
    return (u64)(u16)property_id

func environment_variable_int(value: css_data.EnvironmentVariable) -> u64:
    return (u64)(u8)value

func math_function_int(value: css_data.MathFunction) -> u64:
    return (u64)(i32)value

func media_feature_int(value: css_data.MediaFeatureId) -> u64:
    return (u64)(u8)value

func pseudo_class_int(value: css_data.PseudoClass) -> u64:
    return (u64)(i32)value

func pseudo_element_int(value: css_data.PseudoElement) -> u64:
    return (u64)(u8)value

func transform_function_int(value: css_data.TransformFunction) -> u64:
    return (u64)(i32)value

func dimension_int(value: css_data.DimensionType) -> u64:
    return (u64)(u8)value

func angle_unit_int(value: css_data.AngleUnit) -> u64:
    return (u64)(u8)value

func flex_unit_int(value: css_data.FlexUnit) -> u64:
    return (u64)(u8)value

func frequency_unit_int(value: css_data.FrequencyUnit) -> u64:
    return (u64)(u8)value

func length_unit_int(value: css_data.LengthUnit) -> u64:
    return (u64)(u8)value

func resolution_unit_int(value: css_data.ResolutionUnit) -> u64:
    return (u64)(u8)value

func time_unit_int(value: css_data.TimeUnit) -> u64:
    return (u64)(u8)value

func descriptor_int(value: css_data.DescriptorId) -> u64:
    return (u64)(u8)value

func logical_property_group_int(value: css_data.LogicalPropertyGroup) -> u64:
    return (u64)(u8)value

# mark: Keywords and inputs =====================================================================

## Each keyword's name, and the name of the first value past the last keyword.
func dump_keywords(out: Out*) -> !:
    for keyword in 0..=keyword_count:
        try out.p(f"keyword {keyword} ")
        try out.view(css_data.string_from_keyword((css_data.Keyword)(u16)keyword))
        try out.p("\n")

## For each line of `inputs`, what every from-string function answers for it.
func dump_inputs(out: Out*, inputs: const u8[]) -> !:
    var start: usize = 0
    while start < inputs.length:
        var end = start
        while end < inputs.length and inputs[end] != '\n':
            end += 1
        try dump_input(out, ak.string_view_from_bytes(inputs[start..<end]))
        start = end + 1

func dump_input(out: Out*, s: ak.StringView) -> !:
    try out.p("in \"")
    try out.view(s)
    try out.p("\" kw=")
    try put_optional(out, opt(css_data.keyword_from_string(s), keyword_int))
    try out.p(" wide=")
    try out.b(css_data.is_css_wide_keyword(s))
    try out.p(" prop=")
    try put_optional(out, opt(css_data.property_id_from_string(s), property_int))
    try out.p(" camel=")
    try put_optional(out, opt(css_data.property_id_from_camel_case_string(s), property_int))
    try out.p(" env=")
    try put_optional(out, opt(css_data.environment_variable_from_string(s), environment_variable_int))
    try out.p(" math=")
    try put_optional(out, opt(css_data.math_function_from_string(s), math_function_int))
    try out.p(" mf=")
    try put_optional(out, opt(css_data.media_feature_id_from_string(s), media_feature_int))
    try out.p(" pc=")
    try put_optional(out, opt(css_data.pseudo_class_from_string(s), pseudo_class_int))
    try out.p(" pe=")
    try put_optional(out, opt(css_data.pseudo_element_from_string(s), pseudo_element_int))
    try out.p(" ape=")
    try put_optional(out, opt(css_data.aliased_pseudo_element_from_string(s), pseudo_element_int))
    try out.p(" tf=")
    try put_optional(out, opt(css_data.transform_function_from_string(s), transform_function_int))
    try out.p(" dim=")
    try put_optional(out, opt(css_data.dimension_for_unit(s), dimension_int))
    try out.p(" angle=")
    try put_optional(out, opt(css_data.string_to_angle_unit(s), angle_unit_int))
    try out.p(" flex=")
    try put_optional(out, opt(css_data.string_to_flex_unit(s), flex_unit_int))
    try out.p(" frequency=")
    try put_optional(out, opt(css_data.string_to_frequency_unit(s), frequency_unit_int))
    try out.p(" length=")
    try put_optional(out, opt(css_data.string_to_length_unit(s), length_unit_int))
    try out.p(" resolution=")
    try put_optional(out, opt(css_data.string_to_resolution_unit(s), resolution_unit_int))
    try out.p(" time=")
    try put_optional(out, opt(css_data.string_to_time_unit(s), time_unit_int))
    try out.p(" desc=")
    for at_rule in 0..<at_rule_count:
        if at_rule > 0:
            try out.p(",")
        try put_optional(out, opt(css_data.descriptor_id_from_string((css_data.AtRuleId)(u8)at_rule, s), descriptor_int))
    try out.p("\n")

# mark: Properties ==============================================================================

## Every per-property fact, then the computation order, the constants and the logical mappings.
func dump_properties(out: Out*) -> !:
    for index in 0..<property_count:
        try dump_property(out, index, (css_data.PropertyId)(u16)index)
    try out.p("order")
    let order = css_data.property_computation_order()
    try put_property_ids(out, &order)
    try out.p("\n")
    try out.p(f"constants {property_int(css_data.first_property_id)} {property_int(css_data.last_property_id)}")
    try out.p(f" {property_int(css_data.first_inherited_property_id)} {property_int(css_data.last_inherited_property_id)}")
    try out.p(f" {property_int(css_data.first_longhand_property_id)} {property_int(css_data.last_longhand_property_id)}")
    try out.p(f" {css_data.number_of_longhand_properties}\n")
    for id in physical_properties:
        try out.p(f"unmap {property_int(id)}")
        for writing_mode in 0..<5:
            for direction in 0..<2:
                let context = css_data.LogicalAliasMappingContext(writing_mode = (css_data.WritingMode)(u8)writing_mode,
                                                                  direction = (css_data.Direction)(u8)direction)
                try out.p(f" {property_int(css_data.map_physical_property_to_logical_alias(id, context))}")
        try out.p("\n")
    for index in 0..<property_count:
        let id = (css_data.PropertyId)(u16)index
        if css_data.logical_property_group_for_property(id) == none or css_data.property_is_logical_alias(id):
            let context = css_data.LogicalAliasMappingContext(writing_mode = .horizontal_tb, direction = .ltr)
            try out.p(f"unmap-default {index} {property_int(css_data.map_physical_property_to_logical_alias(id, context))}\n")

## ` id id id` for a Vector of PropertyIDs.
func put_property_ids(out: Out*, ids: const ak.Vector[css_data.PropertyId]*) -> !:
    for id in ak.vector_span_const(ids):
        try out.p(f" {property_int(id)}")

func dump_property(out: Out*, index: u64, id: css_data.PropertyId) -> !:
    try out.p(f"prop {index} name=")
    try out.fly(css_data.string_from_property_id(id))
    try out.p(" camel=")
    try out.fly(css_data.camel_case_string_from_property_id(id))
    try out.p(" anim=")
    if css_data.property_is_shorthand(id):
        try out.p("S")
    else:
        try out.p(f"{(i32)css_data.animation_type_from_longhand_property(id)}")
    try out.p(" animatable=")
    try out.b(css_data.is_animatable_property(id))
    try out.p(" inherited=")
    try out.b(css_data.is_inherited_property(id))
    try out.p(" layout=")
    try out.b(css_data.property_affects_layout(id))
    try out.p(" stacking=")
    try out.b(css_data.property_affects_stacking_context(id))
    try out.p(" gcs=")
    try out.b(css_data.property_needs_layout_for_getcomputedstyle(id))
    try out.p(" node=")
    try out.b(css_data.property_needs_layout_node_for_resolved_value(id))
    try out.p(f" mult={(i32)css_data.property_multiplicity(id)} single=")
    try out.b(css_data.property_is_single_valued(id))
    try out.p(" list=")
    try out.b(css_data.property_is_list_valued(id))
    try out.p(" quirks=")
    try out.b(css_data.property_has_quirk(id, .hashless_hex_color))
    try out.b(css_data.property_has_quirk(id, .unitless_length))
    try out.p(f" max={css_data.property_maximum_value_count(id)} shorthand=")
    try out.b(css_data.property_is_shorthand(id))
    try out.p(" maps=")
    try out.b(css_data.property_maps_to_shorthand(id))
    try out.p(" positional=")
    try out.b(css_data.property_is_positional_value_list_shorthand(id))
    try out.p(" req=")
    try out.b(css_data.property_requires_computation_with_inherited_value(id))
    try out.b(css_data.property_requires_computation_with_initial_value(id))
    try out.b(css_data.property_requires_computation_with_cascaded_value(id))
    try out.p(" logical=")
    try out.b(css_data.property_is_logical_alias(id))
    try out.p(" group=")
    try put_optional(out, opt(css_data.logical_property_group_for_property(id), logical_property_group_int))
    try out.p("\n")

    try out.p(f"prop {index} keywords")
    for keyword in 0..<keyword_count:
        if css_data.property_accepts_keyword(id, (css_data.Keyword)(u16)keyword):
            try out.p(f" {keyword}")
    try out.p("\n")
    try out.p(f"prop {index} legacy")
    for keyword in 0..<keyword_count:
        if let resolved = css_data.resolve_legacy_value_alias(id, (css_data.Keyword)(u16)keyword):
            try out.p(f" {keyword}={keyword_int(resolved)}")
    try out.p("\n")
    try out.p(f"prop {index} blacklist")
    let blacklist = css_data.property_custom_ident_blacklist(id)
    for entry in ak.vector_span_const(&blacklist):
        try out.p(" ")
        try out.view(entry)
    try out.p("\n")
    try out.p(f"prop {index} int ")
    let integers: i64[9] = [-1000000, -1, 0, 1, 2, 999, 1000, 1001, 1000000]
    for value in integers:
        try out.b(css_data.property_accepts_integer(id, value))
    try out.p("\n")
    try out.p(f"prop {index} num ")
    let numbers: f64[11] = [-1000000000.0, -1.5, -1.0, -0.0, 0.0, 0.5, 1.0, 999.5, 1000.0, 1000.5, 1000000000.0]
    for value in numbers:
        try out.b(css_data.property_accepts_number(id, value))
    try out.p("\n")
    try out.p(f"prop {index} longhands")
    let longhands = css_data.longhands_for_shorthand(id)
    try put_property_ids(out, &longhands)
    try out.p("\n")
    try out.p(f"prop {index} expanded")
    let expanded = css_data.expanded_longhands_for_shorthand(id)
    try put_property_ids(out, &expanded)
    try out.p("\n")
    try out.p(f"prop {index} shorthands")
    let shorthands = css_data.shorthands_for_longhand(id)
    try put_property_ids(out, &shorthands)
    try out.p("\n")
    try out.p(f"prop {index} map")
    for writing_mode in 0..<5:
        for direction in 0..<2:
            let context = css_data.LogicalAliasMappingContext(writing_mode = (css_data.WritingMode)(u8)writing_mode,
                                                              direction = (css_data.Direction)(u8)direction)
            try out.p(f" {property_int(css_data.map_logical_alias_to_physical_property(id, context))}")
    try out.p("\n")

# mark: Descriptors =============================================================================

## The at-rule and descriptor names, which at-rule supports which descriptor, and the metadata
## of each supported pair.
func dump_descriptors(out: Out*) -> !:
    for at_rule in 0..<at_rule_count:
        try out.p(f"atrule {at_rule} ")
        try out.fly(css_data.to_string_at_rule_id((css_data.AtRuleId)(u8)at_rule))
        try out.p("\n")
    for descriptor in 0..<descriptor_count:
        try out.p(f"desc {descriptor} ")
        try out.fly(css_data.to_string_descriptor_id((css_data.DescriptorId)(u8)descriptor))
        try out.p("\n")
    for at_rule in 0..<at_rule_count:
        for descriptor in 0..=descriptor_count:
            let at_rule_id = (css_data.AtRuleId)(u8)at_rule
            let descriptor_id = (css_data.DescriptorId)(u8)descriptor
            let supported = css_data.at_rule_supports_descriptor(at_rule_id, descriptor_id)
            try out.p(f"supports {at_rule} {descriptor} ")
            try out.b(supported)
            if supported:
                let metadata = css_data.get_descriptor_metadata(at_rule_id, descriptor_id)
                try out.p(" ")
                try out.b(metadata.allow_arbitrary_substitution_functions)
                for entry in ak.vector_span_const(&metadata.syntax):
                    match entry:
                        .keyword(value): try out.p(f" K{keyword_int(value)}")
                        .property_id(value): try out.p(f" P{property_int(value)}")
                        .descriptor_metadata_value_type(value): try out.p(f" V{(i32)value}")
            try out.p("\n")

# mark: Environment variables, media features, pseudo-classes and -elements, transforms ========

func dump_small(out: Out*) -> !:
    for index in 0..<environment_variable_count:
        let variable = (css_data.EnvironmentVariable)(u8)index
        try out.p(f"env {index} ")
        try out.view(css_data.to_string_environment_variable(variable))
        try out.p(f" {css_data.environment_variable_dimension_count(variable)}\n")

    for index in 0..<media_feature_count:
        let feature = (css_data.MediaFeatureId)(u8)index
        try out.p(f"mf {index} ")
        try out.view(css_data.string_from_media_feature_id(feature))
        try out.p(" range=")
        try out.b(css_data.media_feature_type_is_range(feature))
        try out.p(" types=")
        for value_type in 0..<5:
            try out.b(css_data.media_feature_accepts_type(feature, (css_data.MediaFeatureValueType)(i32)value_type))
        try out.p(" kws")
        for keyword in 0..<keyword_count:
            if css_data.media_feature_accepts_keyword(feature, (css_data.Keyword)(u16)keyword):
                try out.p(f" {keyword}")
        try out.p(" falsey")
        for keyword in 0..<keyword_count:
            if css_data.media_feature_keyword_is_falsey(feature, (css_data.Keyword)(u16)keyword):
                try out.p(f" {keyword}")
        try out.p("\n")

    for index in 0..<pseudo_class_count:
        let pseudo_class = (css_data.PseudoClass)(i32)index
        let metadata = css_data.pseudo_class_metadata(pseudo_class)
        try out.p(f"pc {index} ")
        try out.view(css_data.pseudo_class_name(pseudo_class))
        try out.p(f" {(i32)metadata.parameter_type}")
        try out.b(metadata.is_valid_as_function)
        try out.b(metadata.is_valid_as_identifier)
        try out.p("\n")

    for index in 0..=pseudo_element_count + 1:
        let pseudo_element = (css_data.PseudoElement)(u8)index
        try out.p(f"pe {index} ")
        if index < pseudo_element_count:
            try out.view(css_data.pseudo_element_name(pseudo_element))
        else:
            try out.p("-")
        try out.p(" has=")
        try out.b(css_data.is_has_allowed_pseudo_element(pseudo_element))
        try out.p(" tree=")
        try out.b(css_data.is_tree_abiding_pseudo_element(pseudo_element))
        try out.p(" backed=")
        try out.b(css_data.is_element_backed_pseudo_element(pseudo_element))
        try out.p(" root=")
        try out.b(css_data.is_pseudo_element_root(pseudo_element))
        if index != pseudo_element_count:
            let metadata = css_data.pseudo_element_metadata(pseudo_element)
            try out.p(f" meta={(i32)metadata.parameter_type}")
            try out.b(metadata.is_valid_as_function)
            try out.b(metadata.is_valid_as_identifier)
        try out.p(" unsupported")
        for property in 0..<property_count:
            if not css_data.pseudo_element_supports_property(pseudo_element, (css_data.PropertyId)(u16)property):
                try out.p(f" {property}")
        try out.p("\n")

    for index in 0..<transform_function_count:
        let function = (css_data.TransformFunction)(i32)index
        try out.p(f"tf {index} ")
        try out.view(css_data.to_string_transform_function(function))
        let metadata = css_data.transform_function_metadata(function)
        for parameter in ak.vector_span_const(&metadata.parameters):
            try out.p(f" {(i32)parameter.type_}")
            try out.b(parameter.required)
        try out.p("\n")

# mark: Units ===================================================================================

## For one dimension with `count` units: the canonical unit, each unit's name, and each pair's
## compatibility, with the ratio of compatible (and equal) units.
func dump_unit[E](out: Out*, name: str, count: u64, from_int: func(u64) -> E, to_int: func(E) -> u64,
                  canonical: func() -> E, to_string: func(E) -> ak.FlyString, compatible: func(E, E) -> bool,
                  ratio: func(E, E) -> f64) -> !:
    try out.p(f"canonical {name} {to_int(canonical())}\n")
    for value in 0..<count:
        try out.p(f"unit {name} {value} ")
        try out.fly(to_string(from_int(value)))
        try out.p("\n")
    for a in 0..<count:
        for b in 0..<count:
            let is_compatible = compatible(from_int(a), from_int(b))
            try out.p(f"compat {name} {a} {b} ")
            try out.b(is_compatible)
            if is_compatible or a == b:
                var buffer: u8[64]
                try out.p(f" {seventeen_digits(ratio(from_int(a), from_int(b)), buffer)}")
            try out.p("\n")

extern func dump_snprintf as "snprintf"(output: u8*, size: usize, format: c.str, ...) -> i32

## A ratio as the donor's C++ printed it: 17 significant digits (`%.17g`), where the
## standard library's format_f64 writes the shortest digits that read back.
func seventeen_digits(value: f64, buffer: u8[]) -> str:
    let n = dump_snprintf(&buffer[0], buffer.length, "%.17g", value)
    return (str)buffer[..<(usize)n]