Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-css

Source of release 0.5.1

0.5.1 / tools / gen_css / emit_descriptors.lucb

#==============================================================================================
#
#   emit_descriptors - generated_descriptor_id.lucb
#
#   DESCRIPTION:
#       Port of Meta/Generators/generate_libweb_css_descriptors.py: from Descriptors.json, the
#       at-rules, the descriptors of all of them, which at-rule accepts which descriptor, and
#       each descriptor's syntax. descriptor_initial_value() parses style values and is the
#       engine's.
#
#==============================================================================================

## Ported from generate_libweb_css_descriptors.py is_legacy_alias.
func is_descriptor_legacy_alias(descriptor: const Json*) -> bool:
    return descriptor.has("legacy-alias-for")

## The `descriptors` object of an at-rule, or an empty one (Python's `.get("descriptors", {})`).
func at_rule_descriptors(at_rule: const Json*) -> const Json*!:
    if let descriptors = at_rule.get("descriptors"):
        return descriptors
    return try json_new(.object, "")

## Ported from generate_libweb_css_descriptors.py collect_all_descriptors: every descriptor
## name that is not a legacy alias, once, in code point order.
func collect_all_descriptors(at_rules_data: const Json*) -> StrList!:
    var names = try StrList.create()
    for at_rule_index in 0..<at_rules_data.count:
        let descriptors = try at_rule_descriptors(at_rules_data.at(at_rule_index))
        for index in 0..<descriptors.count:
            if is_descriptor_legacy_alias(descriptors.at(index)):
                continue
            let name = descriptors.key(index)
            if not names.contains(name):
                try names.append(name)
    sort_strings(&names)
    return names

## generate_libweb_css_descriptors.py's VALUE_TYPE_NAMES.
func descriptor_value_type_name(entry: str) -> str?:
    if entry == "<family-name>": return "FamilyName"
    if entry == "<font-src-list>": return "FontSrcList"
    if entry == "<font-weight-absolute>{1,2}": return "FontWeightAbsolutePair"
    if entry == "<declaration-value>?": return "OptionalDeclarationValue"
    if entry == "<length>": return "Length"
    if entry == "<page-size>": return "PageSize"
    if entry == "<percentage [0,∞]>": return "PositivePercentage"
    if entry == "<string>": return "String"
    if entry == "<unicode-range-token>#": return "UnicodeRangeTokens"
    if entry == "<counter-style-system>": return "CounterStyleSystem"
    if entry == "<counter-style-negative>": return "CounterStyleNegative"
    if entry == "<symbol>": return "Symbol"
    if entry == "<symbol>+": return "Symbols"
    if entry == "<counter-style-range>": return "CounterStyleRange"
    if entry == "<counter-style-pad>": return "CounterStylePad"
    if entry == "<counter-style-name>": return "CounterStyleName"
    if entry == "<counter-style-additive-symbols>": return "CounterStyleAdditiveSymbols"
    return none

## Ported from generate_libweb_css_descriptors.py generate_syntax_list: append each entry of a
## descriptor's syntax to `metadata.syntax`.
func generate_syntax_list(out: Out*, syntax: const Json*, indent: str) -> !:
    let variant = "KeywordOrPropertyIdOrDescriptorMetadataValueType"
    for index in 0..<syntax.count:
        let entry = syntax.at(index).string()
        var alternative: str
        if starts_with(entry, "<'"):
            # Property reference like <'font-feature-settings'>
            let property_name = try title_casify(slice(entry, 2, entry.length - 2))
            alternative = try cat([variant, ".property_id(value = ", try enum_value("PropertyId", property_name), ")"])
        elif starts_with(entry, "<"):
            # Value type
            # FIXME: Actually parse the grammar, instead of hard-coding the options!
            let value_type = descriptor_value_type_name(entry) else trap(f"Unrecognized value type: `{entry}`")
            alternative = try cat([variant, ".descriptor_metadata_value_type(value = ", try enum_value("DescriptorMetadataValueType", value_type), ")"])
        elif entry == "crop || cross":
            # FIXME: This is extra hacky.
            alternative = try cat([variant, ".descriptor_metadata_value_type(value = DescriptorMetadataValueType.crop_or_cross)"])
        else:
            # Keyword
            alternative = try cat([variant, ".keyword(value = ", try enum_value("Keyword", try title_casify(entry)), ")"])
        try out.line(f"{indent}ak.vector_append_t(&metadata.syntax, {alternative})")

## Emit generated_descriptor_id.lucb from Descriptors.json.
func emit_descriptors(at_rules_data: const Json*) -> str!:
    let all_descriptors = try collect_all_descriptors(at_rules_data)
    var out = try Out.create()
    try put_generated_header(&out, "generated_descriptor_id", "the CSS at-rules and their descriptors",
                             ["DescriptorID.h", "DescriptorID.cpp"], "generate_libweb_css_descriptors.py", "Descriptors.json",
                             ["descriptor_initial_value(), which parses style values, is the engine's."])
    try out.blank()

    var at_rule_titles = try StrList.create()
    for index in 0..<at_rules_data.count:
        try at_rule_titles.append(try title_casify(at_rules_data.key(index)))
    try put_enum(&out, "Web::CSS::AtRuleID", "DescriptorID.h", "AtRuleId", underlying_type_for_enum(at_rules_data.count), &at_rule_titles)
    try out.blank()
    var descriptor_titles = try StrList.create()
    for index in 0..<all_descriptors.count:
        try descriptor_titles.append(try title_casify(all_descriptors.at(index)))
    try descriptor_titles.append("Custom")
    try put_enum(&out, "Web::CSS::DescriptorID", "DescriptorID.h", "DescriptorId", underlying_type_for_enum(all_descriptors.count), &descriptor_titles)

    try put_mark(&out, "DescriptorMetadata")
    try put_doc(&out, "Web::CSS::DescriptorMetadata", "DescriptorID.h")
    try out.line("pub struct DescriptorMetadata:")
    try out.line("    pub var syntax: ak.Vector[KeywordOrPropertyIdOrDescriptorMetadataValueType]")
    try out.line("    pub var allow_arbitrary_substitution_functions: bool  # C++ default: { false }")
    try out.blank()
    var value_types = try StrList.create()
    # FIXME: Parse the grammar instead of hard-coding all the options!
    for name in ["CounterStyleSystem", "CounterStyleAdditiveSymbols", "CounterStyleName", "CounterStyleNegative",
                 "CounterStylePad", "CounterStyleRange", "CropOrCross", "FamilyName", "FontSrcList",
                 "FontWeightAbsolutePair", "Length", "OptionalDeclarationValue", "PageSize", "PositivePercentage",
                 "String", "Symbol", "Symbols", "UnicodeRangeTokens"]:
        try value_types.append(name)
    try put_enum(&out, "Web::CSS::DescriptorMetadata::ValueType", "DescriptorID.h", "DescriptorMetadataValueType", "i32", &value_types)

    try put_mark(&out, "DescriptorID.cpp")
    try put_ported(&out, "DescriptorID.cpp", "Web::CSS::to_string(AtRuleID)")
    try out.line("pub func to_string_at_rule_id(at_rule_id: AtRuleId) -> ak.FlyString:")
    try out.line("    match at_rule_id:")
    for index in 0..<at_rules_data.count:
        try out.line(f"        .{try luce_case(at_rule_titles.at(index))}: return {try fly_string_literal(try cat(["@", at_rules_data.key(index)]))}")
    try out.line("        _: trap(\"VERIFY_NOT_REACHED\")")
    try out.blank()

    try put_ported(&out, "DescriptorID.cpp", "Web::CSS::descriptor_id_from_string")
    try out.line("pub func descriptor_id_from_string(at_rule_id: AtRuleId, string: ak.StringView) -> DescriptorId?:")
    try out.line("    match at_rule_id:")
    for index in 0..<at_rules_data.count:
        let at_rule = at_rules_data.at(index)
        try out.line(f"        .{try luce_case(at_rule_titles.at(index))}:")
        if at_rule.has("custom-descriptors"):
            try out.line("            if is_a_custom_property_name_string(string):")
            try out.line("                return DescriptorId.custom")
        let descriptors = at_rule.get("descriptors") else trap("an at-rule without descriptors")
        for descriptor_index in 0..<descriptors.count:
            let descriptor_name = descriptors.key(descriptor_index)
            var result_name = try title_casify(descriptor_name)
            if let alias_for = descriptors.at(descriptor_index).get("legacy-alias-for"):
                result_name = try title_casify(alias_for.string())
            try out.line(f"            if {try equals_ignoring_ascii_case("string", descriptor_name)}:")
            try out.line(f"                return {try enum_value("DescriptorId", result_name)}")
    try out.line("        _: return none")
    try out.line("    return none")
    try out.blank()

    try put_ported(&out, "DescriptorID.cpp", "Web::CSS::to_string(DescriptorID)")
    try out.line("pub func to_string_descriptor_id(descriptor_id: DescriptorId) -> ak.FlyString:")
    try out.line("    match descriptor_id:")
    for index in 0..<all_descriptors.count:
        try out.line(f"        .{try luce_case(descriptor_titles.at(index))}: return {try fly_string_literal(all_descriptors.at(index))}")
    try out.line("        .custom: trap(\"VERIFY_NOT_REACHED\")")
    try out.line("        _: trap(\"VERIFY_NOT_REACHED\")")
    try out.blank()

    try put_ported(&out, "DescriptorID.cpp", "Web::CSS::at_rule_supports_descriptor")
    try out.line("pub func at_rule_supports_descriptor(at_rule_id: AtRuleId, descriptor_id: DescriptorId) -> bool:")
    try out.line("    match at_rule_id:")
    for index in 0..<at_rules_data.count:
        let at_rule = at_rules_data.at(index)
        try out.line(f"        .{try luce_case(at_rule_titles.at(index))}:")
        try out.line("            match descriptor_id:")
        let descriptors = at_rule.get("descriptors") else trap("an at-rule without descriptors")
        for descriptor_index in 0..<descriptors.count:
            if is_descriptor_legacy_alias(descriptors.at(descriptor_index)):
                continue
            try out.line(f"                .{try luce_case(try title_casify(descriptors.key(descriptor_index)))}: return true")
        if at_rule.has("custom-descriptors"):
            try out.line("                .custom: return true")
        try out.line("                _: return false")
    try out.line("        _: trap(\"VERIFY_NOT_REACHED\")")
    try out.blank()

    try put_ported(&out, "DescriptorID.cpp", "Web::CSS::get_descriptor_metadata")
    try out.line("pub func get_descriptor_metadata(at_rule_id: AtRuleId, descriptor_id: DescriptorId) -> DescriptorMetadata:")
    try out.line("    match at_rule_id:")
    for index in 0..<at_rules_data.count:
        let at_rule = at_rules_data.at(index)
        try out.line(f"        .{try luce_case(at_rule_titles.at(index))}:")
        try out.line("            match descriptor_id:")
        let descriptors = at_rule.get("descriptors") else trap("an at-rule without descriptors")
        for descriptor_index in 0..<descriptors.count:
            let descriptor = descriptors.at(descriptor_index)
            if is_descriptor_legacy_alias(descriptor):
                continue
            try out.line(f"                .{try luce_case(try title_casify(descriptors.key(descriptor_index)))}:")
            try emit_descriptor_metadata(&out, descriptor)
        if let custom_descriptors = at_rule.get("custom-descriptors"):
            try out.line("                .custom:")
            try emit_descriptor_metadata(&out, custom_descriptors)
        try out.line("                _: trap(\"VERIFY_NOT_REACHED\")")
    try out.line("        _: trap(\"VERIFY_NOT_REACHED\")")
    return out.text()

# One case of get_descriptor_metadata: the metadata of `descriptor`.
func emit_descriptor_metadata(out: Out*, descriptor: const Json*) -> !:
    let indent = "                    "
    try out.line(f"{indent}var metadata = DescriptorMetadata()")
    let syntax = descriptor.get("syntax") else trap("a descriptor without a syntax")
    try generate_syntax_list(out, syntax, indent)
    let allow_arbitrary = get_flag(descriptor, "allow-arbitrary-substitution-functions")
    try out.line(f"{indent}metadata.allow_arbitrary_substitution_functions = {allow_arbitrary}")
    try out.line(f"{indent}return metadata")