dymokomi/luce-browser-css
Source of release 0.5.1
0.5.1 / tools / gen_css / emit_units.lucb
#==============================================================================================
#
# emit_units - generated_units.lucb
#
# DESCRIPTION:
# Port of Meta/Generators/generate_libweb_css_units.py: from Units.json, the dimension
# types, one unit enum per dimension, and the unit names, compatibility and ratios.
#
#==============================================================================================
## Ported from generate_libweb_css_units.py json_is_valid: every dimension and unit in order,
## and each unit exactly one of canonical, a number of the canonical unit, or relative.
func units_json_is_valid(dimensions_data: const Json*, json_path: str) -> bool!:
var is_valid = true
var most_recent_dimension_name = ""
for dimension_index in 0..<dimensions_data.count:
let dimension_name = dimensions_data.key(dimension_index)
let units = dimensions_data.at(dimension_index)
# Dimensions should be in alphabetical order
if string_less(try lower(dimension_name), try lower(most_recent_dimension_name)):
print(f"{json_path}: Dimension `{dimension_name}` is in the wrong position. Please keep this list alphabetical!")
is_valid = false
most_recent_dimension_name = dimension_name
var most_recent_unit_name = ""
var canonical_unit: str? = none
for unit_index in 0..<units.count:
let unit_name = units.key(unit_index)
let unit_data = units.at(unit_index)
# Units should be in alphabetical order
if string_less(try lower(unit_name), try lower(most_recent_unit_name)):
print(f"{json_path}: {dimension_name} unit `{unit_name}` is in the wrong position. Please keep this list alphabetical!")
is_valid = false
most_recent_unit_name = unit_name
var is_canonical_unit = false
if let canonical = unit_data.get("is-canonical-unit"):
is_canonical_unit = canonical.kind == JsonKind.boolean and canonical.boolean()
let has_number_of_canonical_unit = unit_data.has("number-of-canonical-unit")
let relative_to = unit_data.get("relative-to")
var provided_count = 0
if is_canonical_unit:
provided_count += 1
if has_number_of_canonical_unit:
provided_count += 1
if relative_to != none:
provided_count += 1
if provided_count != 1:
print(f"{json_path}: {dimension_name} unit `{unit_name}` must have exactly 1 of `is-canonical-unit: true`, `number-of-canonical-unit`, or `relative-to` provided.")
is_valid = false
if is_canonical_unit:
if let existing = canonical_unit:
print(f"{json_path}: {dimension_name} unit `{unit_name}` marked canonical, but `{existing}` was already. Must have exactly 1.")
is_valid = false
else:
canonical_unit = unit_name
if let relative = relative_to:
if dimension_name == "length":
if not (relative.string() == "font" or relative.string() == "viewport"):
print(f"{json_path}: {dimension_name} unit `{unit_name}` is marked as relative to `{relative.string()}`, which is unsupported.")
is_valid = false
else:
print(f"{json_path}: {dimension_name} unit `{unit_name}` is marked as relative, but only relative length units are currently supported.")
is_valid = false
if canonical_unit == none:
print(f"{json_path}: {dimension_name} has no unit marked as canonical. Must have exactly 1.")
is_valid = false
return is_valid
## Ported from generate_libweb_css_units.py canonical_unit_name.
func canonical_unit_name(units: const Json*) -> str:
for index in 0..<units.count:
if let canonical = units.at(index).get("is-canonical-unit"):
if canonical.kind == JsonKind.boolean and canonical.boolean():
return units.key(index)
trap("No canonical unit found")
## The unit's `relative-to` member, or none.
func unit_relative_to(unit_data: const Json*) -> str?:
let relative = unit_data.get("relative-to") else return none
return relative.string()
## Emit generated_units.lucb from Units.json.
func emit_units(dimensions_data: const Json*) -> str!:
if not try units_json_is_valid(dimensions_data, "Units.json"):
trap("Units.json is not valid")
var out = try Out.create()
try put_generated_header(&out, "generated_units", "the CSS dimensions and their units",
["Units.h", "Units.cpp"], "generate_libweb_css_units.py", "Units.json", no_notes())
try out.blank()
var dimension_titles = try StrList.create()
for index in 0..<dimensions_data.count:
try dimension_titles.append(try title_casify(dimensions_data.key(index)))
try put_enum(&out, "Web::CSS::DimensionType", "Units.h", "DimensionType",
underlying_type_for_enum(dimensions_data.count), &dimension_titles)
try out.blank()
try put_ported(&out, "Units.cpp", "Web::CSS::dimension_for_unit")
try out.line("pub func dimension_for_unit(unit_name: ak.StringView) -> DimensionType?:")
for dimension_index in 0..<dimensions_data.count:
let units = dimensions_data.at(dimension_index)
for unit_index in 0..<units.count:
let condition = try equals_ignoring_ascii_case("unit_name", units.key(unit_index))
if unit_index == 0:
try out.put(f" if ({condition}")
else:
try out.put(f"\n or {condition}")
try out.line("):")
try out.line(f" return {try enum_value("DimensionType", dimension_titles.at(dimension_index))}")
try out.line(" return none")
for dimension_index in 0..<dimensions_data.count:
let dimension_name = dimensions_data.key(dimension_index)
let units = dimensions_data.at(dimension_index)
let name_titlecase = dimension_titles.at(dimension_index)
let name_snakecase = try snake_casify(dimension_name)
let unit_type = try cat([name_titlecase, "Unit"])
let suffix = try overload_suffix(unit_type)
let canonical = try title_casify(canonical_unit_name(units))
try put_mark(&out, unit_type)
var titles = try StrList.create()
for unit_index in 0..<units.count:
try titles.append(try title_casify(units.key(unit_index)))
try put_enum(&out, try cat(["Web::CSS::", unit_type]), "Units.h", unit_type,
underlying_type_for_enum(units.count), &titles)
try out.blank()
try put_ported(&out, "Units.h", try cat(["Web::CSS::canonical_", name_snakecase, "_unit"]))
try out.line(f"pub func canonical_{name_snakecase}_unit() -> {unit_type}:")
try out.line(f" return {try enum_value(unit_type, canonical)}")
try out.blank()
try put_ported(&out, "Units.cpp", try cat(["Web::CSS::string_to_", name_snakecase, "_unit"]))
try out.line(f"pub func string_to_{name_snakecase}_unit(unit_name: ak.StringView) -> {unit_type}?:")
for unit_index in 0..<units.count:
try out.line(f" if {try equals_ignoring_ascii_case("unit_name", units.key(unit_index))}:")
try out.line(f" return {try enum_value(unit_type, titles.at(unit_index))}")
try out.line(" return none")
try out.blank()
try put_ported(&out, "Units.cpp", try cat(["Web::CSS::to_string(", unit_type, ")"]))
try out.line(f"pub func to_string_{suffix}(value: {unit_type}) -> ak.FlyString:")
try out.line(" match value:")
for unit_index in 0..<units.count:
try out.line(f" .{try luce_case(titles.at(unit_index))}: return {try fly_string_literal(units.key(unit_index))}")
try out.line(" _: trap(\"VERIFY_NOT_REACHED\")")
try out.blank()
try out.line(f"# units_are_compatible({unit_type}, {unit_type})'s lambda `is_absolute`.")
try out.line(f"func units_are_compatible_{suffix}_is_absolute(unit_: {unit_type}) -> bool:")
try out.line(" match unit_:")
# https://drafts.csswg.org/css-values-4/#compatible-units
for unit_index in 0..<units.count:
if units.at(unit_index).has("relative-to"):
continue
try out.line(f" .{try luce_case(titles.at(unit_index))}: return true")
try out.line(" _: return false")
try out.blank()
try put_ported(&out, "Units.cpp", try cat(["Web::CSS::units_are_compatible(", unit_type, ", ", unit_type, ")"]))
try out.line(f"pub func units_are_compatible_{suffix}(a: {unit_type}, b: {unit_type}) -> bool:")
try out.line(f" return units_are_compatible_{suffix}_is_absolute(a) and units_are_compatible_{suffix}_is_absolute(b)")
try out.blank()
try out.line(f"# ratio_between_units({unit_type}, {unit_type})'s lambda `ratio_to_canonical_unit`.")
try out.line(f"func ratio_between_units_{suffix}_ratio_to_canonical_unit(unit_: {unit_type}) -> f64:")
try out.line(" match unit_:")
for unit_index in 0..<units.count:
let unit_data = units.at(unit_index)
if unit_data.has("relative-to"):
continue
var ratio_text = "1.0"
if let ratio = unit_data.get("number-of-canonical-unit"):
ratio_text = try format_ratio(ratio.text)
else:
# This must be the canonical unit, so the ratio is 1.
ratio_text = "1.0"
try out.line(f" .{try luce_case(titles.at(unit_index))}: return {ratio_text}")
try out.line(" # `from` is a relative unit, so this isn't valid.")
try out.line(" _: trap(\"VERIFY_NOT_REACHED\")")
try out.blank()
try put_ported(&out, "Units.cpp", try cat(["Web::CSS::ratio_between_units(", unit_type, ", ", unit_type, ")"]))
try out.line(f"pub func ratio_between_units_{suffix}(from_: {unit_type}, to: {unit_type}) -> f64:")
try out.line(" if from_ == to:")
try out.line(" return 1.0")
try out.line(f" if to == {try enum_value(unit_type, canonical)}:")
try out.line(f" return ratio_between_units_{suffix}_ratio_to_canonical_unit(from_)")
try out.line(f" return ratio_between_units_{suffix}_ratio_to_canonical_unit(from_) / ratio_between_units_{suffix}_ratio_to_canonical_unit(to)")
# Length-specific functions
let length_units = dimensions_data.get("length") else trap("Units.json has no length units")
try put_mark(&out, "LengthUnit")
try put_ported(&out, "Units.cpp", "Web::CSS::is_absolute")
try out.line("pub func is_absolute(unit_: LengthUnit) -> bool:")
try out.line(" match unit_:")
for index in 0..<length_units.count:
if length_units.at(index).has("relative-to"):
continue
try out.line(f" .{try luce_case(try title_casify(length_units.key(index)))}: return true")
try out.line(" _: return false")
try out.blank()
for relative_to in ["font", "viewport"]:
try put_ported(&out, "Units.cpp", try cat(["Web::CSS::is_", relative_to, "_relative"]))
try out.line(f"pub func is_{relative_to}_relative(unit_: LengthUnit) -> bool:")
try out.line(" match unit_:")
for index in 0..<length_units.count:
let unit_relative = unit_relative_to(length_units.at(index)) else continue
if unit_relative != relative_to:
continue
try out.line(f" .{try luce_case(try title_casify(length_units.key(index)))}: return true")
try out.line(" _: return false")
try out.blank()
try put_ported(&out, "Units.h", "Web::CSS::is_relative")
try out.line("pub func is_relative(unit_: LengthUnit) -> bool:")
try out.line(" return not is_absolute(unit_)")
return out.text()
# mark: Numbers =================================================================================
## A JSON number as a Luce f64 literal of the same value, spelled as generate_libweb_css_units.py's
## format_ratio spells it: Python's `str` of the parsed number, the shortest decimal that reads
## back as the same double, with `.0` added to a whole number.
func format_ratio(text: str) -> str!:
let value = try strings.parse_f64(text)
if value < 0.0:
trap(f"format_ratio: unsupported negative number {text}")
# The double's value to 17 significant digits (%.17g), then the fewest of those digits
# that read back as the same double.
var buffer: u8[64]
let exact = try strings.format_f64(value, buffer)
var digits: collections.Buffer
var point: isize = 0
var seen_point = false
var leading = true
var exponent: isize = 0
var index: usize = 0
while index < exact.length:
let byte = exact.bytes[index]
index += 1
if byte == '.':
seen_point = true
continue
if byte == 'e' or byte == 'E':
let parsed = strings.parse_i64(slice(exact, index, exact.length)) else trap(f"format_ratio: bad exponent in {exact}")
exponent = (isize)parsed
break
if not is_digit(byte):
trap(f"format_ratio: unsupported number {exact}")
if leading and byte == '0':
if seen_point:
point -= 1
continue
leading = false
let one: u8[1] = [byte]
_ = try digits.write(one)
if not seen_point:
point += 1
let all = digits.text()
if all.length == 0:
return "0.0"
for count in 1..=all.length:
let candidate = try round_digits(all, count, point + exponent)
if try strings.parse_f64(candidate) == value:
return candidate
trap(f"format_ratio: no representation of {text}")
# `digits` (a decimal point `point` digits from their start) rounded half up to `count`
# significant digits, spelled positionally.
func round_digits(digits: str, count: usize, point: isize) -> str!:
var kept = try new u8[count + 1]
for index in 0..<count:
kept[index + 1] = digits.bytes[index]
var position = point + 1
if count < digits.length and digits.bytes[count] >= '5':
var index = count
while true:
if kept[index] == '9':
kept[index] = '0'
index -= 1
continue
if index == 0:
kept[0] = '1'
else:
kept[index] += 1
break
var start: usize = 1
if kept[0] == '1':
start = 0
else:
position -= 1
# The digits without trailing zeros.
var end = kept.length
while end > start + 1 and kept[end - 1] == '0':
end -= 1
let significant = (str)kept[start..<end]
var out: collections.Buffer
if position <= 0:
try out.put_text("0.")
var zeros = position
while zeros < 0:
try out.put_text("0")
zeros += 1
try out.put_text(significant)
elif (usize)position >= significant.length:
try out.put_text(significant)
var zeros = (usize)position - significant.length
while zeros > 0:
try out.put_text("0")
zeros -= 1
try out.put_text(".0")
else:
try out.put_text(slice(significant, 0, (usize)position))
try out.put_text(".")
try out.put_text(slice(significant, (usize)position, significant.length))
return out.text()