dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / css / parser / property_parsing_14.lucb
#==============================================================================================
#
# property_parsing_14 - parsing property values: the grid shorthands
#
# DESCRIPTION:
# Port of LibWeb/CSS/Parser/PropertyParsing.cpp (lines 4729-5085): grid-column and
# grid-row, grid-template (and the grid-template part of grid), grid-area and grid.
#
#==============================================================================================
# mark: grid-column and grid-row ================================================================
## `GridTrackPlacementStyleValue::create(placement)` as a StyleValue.
func css_grid_track_placement_value_of(placement: CssGridTrackPlacement) -> CssStyleValue*:
return css_grid_track_placement_style_value_create(placement).css_style_value()
## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:4729 Web::CSS::Parser::Parser::parse_grid_track_placement_shorthand_value.
pub func css_parser_parse_grid_track_placement_shorthand_value(this: CssParser*, property_id: css_data.PropertyId, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
let start_property = css_data.PropertyId.grid_column_start if property_id == css_data.PropertyId.grid_column else css_data.PropertyId.grid_row_start
let end_property = css_data.PropertyId.grid_column_end if property_id == css_data.PropertyId.grid_column else css_data.PropertyId.grid_row_end
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
css_syntax.token_stream_discard_whitespace(tokens)
var current_token = css_syntax.token_stream_consume_a_token(tokens)
var track_start_placement_tokens = ak.Vector[css_syntax.ComponentValue]()
while true:
if css_syntax.component_value_is_delim(¤t_token, (u32)'/'):
css_syntax.token_stream_discard_whitespace(tokens)
if not css_syntax.token_stream_has_next_token(tokens):
return none
break
ak.vector_append_t(&track_start_placement_tokens, current_token)
css_syntax.token_stream_discard_whitespace(tokens)
if not css_syntax.token_stream_has_next_token(tokens):
break
current_token = css_syntax.token_stream_consume_a_token(tokens)
var track_end_placement_tokens = ak.Vector[css_syntax.ComponentValue]()
if css_syntax.token_stream_has_next_token(tokens):
current_token = css_syntax.token_stream_consume_a_token(tokens)
while true:
ak.vector_append_t(&track_end_placement_tokens, current_token)
css_syntax.token_stream_discard_whitespace(tokens)
if not css_syntax.token_stream_has_next_token(tokens):
break
current_token = css_syntax.token_stream_consume_a_token(tokens)
var track_start_placement_token_stream = css_syntax.token_stream_create(track_start_placement_tokens)
let parsed_start_value = css_parser_parse_grid_track_placement(this, &track_start_placement_token_stream)
if let start_value = parsed_start_value:
if ak.vector_is_empty(&track_end_placement_tokens):
css_syntax.state_transaction_commit(&transaction)
let start_placement = css_grid_track_placement_style_value_grid_track_placement(start_value)
if css_grid_track_placement_is_custom_ident(&start_placement):
let custom_ident = start_value.css_style_value()
return css_shorthand_of(property_id, css_property_ids_of([start_property, end_property]), css_style_values_of([custom_ident, custom_ident]))
return css_shorthand_of(property_id,
css_property_ids_of([start_property, end_property]),
css_style_values_of([start_value.css_style_value(), css_grid_track_placement_value_of(css_grid_track_placement_make_auto())]))
var track_end_placement_token_stream = css_syntax.token_stream_create(track_end_placement_tokens)
let parsed_end_value = css_parser_parse_grid_track_placement(this, &track_end_placement_token_stream)
if let start_value = parsed_start_value:
if let end_value = parsed_end_value:
css_syntax.state_transaction_commit(&transaction)
return css_shorthand_of(property_id,
css_property_ids_of([start_property, end_property]),
css_style_values_of([start_value.css_style_value(), end_value.css_style_value()]))
return none
# mark: grid-template ===========================================================================
## The captures of the GridTrackParser lambda of parse_grid_track_size_list_shorthand_value.
struct CssParserParseGridTrackSizeListShorthandValueCaptures:
var this: CssParser*
var area_tokens: ak.Vector[css_syntax.ComponentValue]*
## The GridTrackParser lambda of parse_grid_track_size_list_shorthand_value: a <string> (kept for the areas) and an
## optional <track-size>.
func css_parser_parse_grid_template_row_track(context: void*?, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssExplicitGridTrack?:
let captures = (CssParserParseGridTrackSizeListShorthandValueCaptures*)(context else trap("no captures"))
css_syntax.token_stream_discard_whitespace(tokens)
if not css_syntax.token_stream_has_next_token(tokens):
return none
let token = css_syntax.token_stream_consume_a_token(tokens)
if not css_syntax.component_value_is(&token, .string):
return none
ak.vector_append_t(captures.area_tokens, token)
css_syntax.token_stream_discard_whitespace(tokens)
if let track_size = css_parser_parse_grid_track_size(captures.this, tokens):
return track_size
css_syntax.token_stream_discard_whitespace(tokens)
return css_explicit_grid_track_new(.css_grid_size(css_grid_size_make_auto()))
## The `[ <'grid-template-rows'> / <'grid-template-columns'> ]` block of parse_grid_track_size_list_shorthand_value,
## in a transaction: the rows and the columns.
func css_parser_parse_grid_template_rows_and_columns(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> (CssStyleValue*, CssStyleValue*)?:
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
if let parsed_template_rows_values = css_parser_parse_grid_track_size_list(this, tokens):
css_syntax.token_stream_discard_whitespace(tokens)
if css_syntax.token_stream_has_next_token(tokens) and css_next_token_is_delim(tokens, (u32)'/'):
css_syntax.token_stream_discard_a_token(tokens) # /
css_syntax.token_stream_discard_whitespace(tokens)
if let parsed_template_columns_values = css_parser_parse_grid_track_size_list(this, tokens):
css_syntax.state_transaction_commit(&transaction)
return (parsed_template_rows_values, parsed_template_columns_values)
return none
## The `[ <line-names>? <string> <track-size>? <line-names>? ]+ [ / <explicit-track-list> ]?` block of
## parse_grid_track_size_list_shorthand_value, in a transaction: the areas, rows and columns when they parse (the
## C++ block's `return nullptr`s and falling out of the block both end in the function's `return nullptr`).
func css_parser_parse_grid_template_areas_rows_and_columns(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> (CssStyleValue*, CssStyleValue*, CssStyleValue*)?:
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
var track_list = CssGridTrackSizeList()
var area_tokens = ak.Vector[css_syntax.ComponentValue]()
var captures = CssParserParseGridTrackSizeListShorthandValueCaptures(this = this, area_tokens = &area_tokens)
let parse_grid_track = ak.Function1[css_syntax.TokenStream[css_syntax.ComponentValue]*, CssExplicitGridTrack?](call = css_parser_parse_grid_template_row_track, context = &captures)
let parsed_track_count = css_parser_parse_track_list_impl(this, tokens, &track_list, parse_grid_track, CssParserAllowTrailingLineNamesForEachTrack.yes)
if parsed_track_count > 0:
var area_tokens_stream = css_syntax.token_stream_create(area_tokens)
let grid_areas = css_parser_parse_grid_template_areas_value(this, &area_tokens_stream) else return none
let rows_track_list = css_grid_track_size_list_style_value_create(track_list).css_style_value()
css_syntax.token_stream_discard_whitespace(tokens)
var columns_track_list = css_property_initial_value(css_data.PropertyId.grid_template_columns)
if css_syntax.token_stream_has_next_token(tokens) and css_next_token_is_delim(tokens, (u32)'/'):
css_syntax.token_stream_discard_a_token(tokens) # /
css_syntax.token_stream_discard_whitespace(tokens)
let parsed_columns = css_parser_parse_explicit_track_list(this, tokens)
if not css_grid_track_size_list_is_empty(&parsed_columns):
css_syntax.state_transaction_commit(&transaction)
columns_track_list = css_grid_track_size_list_style_value_create(parsed_columns).css_style_value()
else:
return none
elif css_syntax.token_stream_has_next_token(tokens):
return none
css_syntax.state_transaction_commit(&transaction)
return (grid_areas, rows_track_list, columns_track_list)
return none
## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:4792 Web::CSS::Parser::Parser::parse_grid_track_size_list_shorthand_value.
# https://www.w3.org/TR/css-grid-2/#explicit-grid-shorthand
# 7.4. Explicit Grid Shorthand: the grid-template property
pub func css_parser_parse_grid_track_size_list_shorthand_value(this: CssParser*, property_id: css_data.PropertyId, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*,
include_grid_auto_properties: bool = false) -> CssStyleValue*?:
var sub_properties = ak.Vector[css_data.PropertyId]()
var values = ak.Vector[CssStyleValue*]()
if include_grid_auto_properties:
ak.vector_append_t(&sub_properties, css_data.PropertyId.grid_auto_flow)
ak.vector_append_t(&sub_properties, css_data.PropertyId.grid_auto_rows)
ak.vector_append_t(&sub_properties, css_data.PropertyId.grid_auto_columns)
ak.vector_append_t(&values, css_property_initial_value(css_data.PropertyId.grid_auto_flow))
ak.vector_append_t(&values, css_property_initial_value(css_data.PropertyId.grid_auto_rows))
ak.vector_append_t(&values, css_property_initial_value(css_data.PropertyId.grid_auto_columns))
ak.vector_append_t(&sub_properties, css_data.PropertyId.grid_template_areas)
ak.vector_append_t(&sub_properties, css_data.PropertyId.grid_template_rows)
ak.vector_append_t(&sub_properties, css_data.PropertyId.grid_template_columns)
ak.vector_ensure_capacity(&values, ak.vector_size(&sub_properties))
# none
if css_parser_parse_all_as_single_keyword_value(this, tokens, css_data.Keyword.none_) != none:
ak.vector_unchecked_append_u(&values, css_property_initial_value(css_data.PropertyId.grid_template_areas))
ak.vector_unchecked_append_u(&values, css_property_initial_value(css_data.PropertyId.grid_template_rows))
ak.vector_unchecked_append_u(&values, css_property_initial_value(css_data.PropertyId.grid_template_columns))
return css_shorthand_of(property_id, sub_properties, values)
# [ <'grid-template-rows'> / <'grid-template-columns'> ]
if let rows_and_columns = css_parser_parse_grid_template_rows_and_columns(this, tokens):
ak.vector_unchecked_append_u(&values, css_property_initial_value(css_data.PropertyId.grid_template_areas))
ak.vector_unchecked_append_u(&values, rows_and_columns.0)
ak.vector_unchecked_append_u(&values, rows_and_columns.1)
return css_shorthand_of(property_id, sub_properties, values)
# [ <line-names>? <string> <track-size>? <line-names>? ]+ [ / <explicit-track-list> ]?
# NB: The GridTrackParser lambda is css_parser_parse_grid_template_row_track.
if let areas_rows_and_columns = css_parser_parse_grid_template_areas_rows_and_columns(this, tokens):
ak.vector_unchecked_append_u(&values, areas_rows_and_columns.0)
ak.vector_unchecked_append_u(&values, areas_rows_and_columns.1)
ak.vector_unchecked_append_u(&values, areas_rows_and_columns.2)
return css_shorthand_of(property_id, sub_properties, values)
return none
# mark: grid-area ===============================================================================
## The `parse_placement_tokens` lambda of parse_grid_area_shorthand_value.
func css_parse_grid_area_placement_tokens(tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, placement_tokens: ak.Vector[css_syntax.ComponentValue]*, check_for_delimiter: bool = true):
css_syntax.token_stream_discard_whitespace(tokens)
while css_syntax.token_stream_has_next_token(tokens):
let current_token = css_syntax.token_stream_consume_a_token(tokens)
if check_for_delimiter and css_syntax.component_value_is_delim(¤t_token, (u32)'/'):
break
ak.vector_append_t(placement_tokens, current_token)
css_syntax.token_stream_discard_whitespace(tokens)
## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:4896 Web::CSS::Parser::Parser::parse_grid_area_shorthand_value.
pub func css_parser_parse_grid_area_shorthand_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
# NB: The `parse_placement_tokens` lambda is css_parse_grid_area_placement_tokens.
var row_start_placement_tokens = ak.Vector[css_syntax.ComponentValue]()
css_parse_grid_area_placement_tokens(tokens, &row_start_placement_tokens)
var column_start_placement_tokens = ak.Vector[css_syntax.ComponentValue]()
if css_syntax.token_stream_has_next_token(tokens):
css_parse_grid_area_placement_tokens(tokens, &column_start_placement_tokens)
var row_end_placement_tokens = ak.Vector[css_syntax.ComponentValue]()
if css_syntax.token_stream_has_next_token(tokens):
css_parse_grid_area_placement_tokens(tokens, &row_end_placement_tokens)
var column_end_placement_tokens = ak.Vector[css_syntax.ComponentValue]()
if css_syntax.token_stream_has_next_token(tokens):
css_parse_grid_area_placement_tokens(tokens, &column_end_placement_tokens, false)
# https://www.w3.org/TR/css-grid-2/#placement-shorthands
# The grid-area property is a shorthand for grid-row-start, grid-column-start, grid-row-end and
# grid-column-end.
var row_start_placement_token_stream = css_syntax.token_stream_create(row_start_placement_tokens)
let row_start_style_value = css_parser_parse_grid_track_placement(this, &row_start_placement_token_stream)
if css_syntax.token_stream_has_next_token(&row_start_placement_token_stream):
return none
var column_start_placement_token_stream = css_syntax.token_stream_create(column_start_placement_tokens)
let column_start_style_value = css_parser_parse_grid_track_placement(this, &column_start_placement_token_stream)
if css_syntax.token_stream_has_next_token(&column_start_placement_token_stream):
return none
var row_end_placement_token_stream = css_syntax.token_stream_create(row_end_placement_tokens)
let row_end_style_value = css_parser_parse_grid_track_placement(this, &row_end_placement_token_stream)
if css_syntax.token_stream_has_next_token(&row_end_placement_token_stream):
return none
var column_end_placement_token_stream = css_syntax.token_stream_create(column_end_placement_tokens)
let column_end_style_value = css_parser_parse_grid_track_placement(this, &column_end_placement_token_stream)
if css_syntax.token_stream_has_next_token(&column_end_placement_token_stream):
return none
# If four <grid-line> values are specified, grid-row-start is set to the first value, grid-column-start
# is set to the second value, grid-row-end is set to the third value, and grid-column-end is set to the
# fourth value.
var row_start = css_grid_track_placement_make_auto()
var column_start = css_grid_track_placement_make_auto()
var row_end = css_grid_track_placement_make_auto()
var column_end = css_grid_track_placement_make_auto()
if let value = row_start_style_value:
row_start = css_grid_track_placement_style_value_grid_track_placement(value)
# When grid-column-start is omitted, if grid-row-start is a <custom-ident>, all four longhands are set to
# that value. Otherwise, it is set to auto.
if let value = column_start_style_value:
column_start = css_grid_track_placement_style_value_grid_track_placement(value)
elif css_grid_track_placement_is_custom_ident(&row_start):
column_start = row_start
# When grid-row-end is omitted, if grid-row-start is a <custom-ident>, grid-row-end is set to that
# <custom-ident>; otherwise, it is set to auto.
if let value = row_end_style_value:
row_end = css_grid_track_placement_style_value_grid_track_placement(value)
elif css_grid_track_placement_is_custom_ident(&row_start):
row_end = row_start
# When grid-column-end is omitted, if grid-column-start is a <custom-ident>, grid-column-end is set to
# that <custom-ident>; otherwise, it is set to auto.
if let value = column_end_style_value:
column_end = css_grid_track_placement_style_value_grid_track_placement(value)
elif css_grid_track_placement_is_custom_ident(&column_start):
column_end = column_start
css_syntax.state_transaction_commit(&transaction)
return css_shorthand_of(css_data.PropertyId.grid_area,
css_property_ids_of([css_data.PropertyId.grid_row_start, css_data.PropertyId.grid_column_start, css_data.PropertyId.grid_row_end,
css_data.PropertyId.grid_column_end]),
css_style_values_of([css_grid_track_placement_value_of(row_start), css_grid_track_placement_value_of(column_start),
css_grid_track_placement_value_of(row_end), css_grid_track_placement_value_of(column_end)]))
# mark: grid ====================================================================================
## The `parse_auto_flow_and_dense` lambda of parse_grid_shorthand_value.
func css_parse_grid_auto_flow_and_dense(tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, axis: CssGridAutoFlowStyleValueAxis) -> CssStyleValue*?:
var found_auto_flow = false
var dense = CssGridAutoFlowStyleValueDense.no
var i = 0
while i < 2 and css_syntax.token_stream_has_next_token(tokens):
let token = css_syntax.token_stream_next_token(tokens)
if css_syntax.component_value_is_ident(&token, ak.sv("auto-flow")) and not found_auto_flow:
css_syntax.token_stream_discard_a_token(tokens) # auto-flow
css_syntax.token_stream_discard_whitespace(tokens)
found_auto_flow = true
elif css_syntax.component_value_is_ident(&token, ak.sv("dense")) and dense == CssGridAutoFlowStyleValueDense.no:
css_syntax.token_stream_discard_a_token(tokens) # dense
css_syntax.token_stream_discard_whitespace(tokens)
dense = CssGridAutoFlowStyleValueDense.yes
else:
break
i += 1
if found_auto_flow:
return css_grid_auto_flow_style_value_create(axis, dense).css_style_value()
return none
## `grid_auto_tracks->as_grid_track_size_list().grid_track_size_list().is_empty()`.
func css_grid_track_size_list_value_is_empty(value: CssStyleValue*) -> bool:
let list = css_grid_track_size_list_style_value_grid_track_size_list(css_style_value_as_grid_track_size_list(value))
return css_grid_track_size_list_is_empty(&list)
## The `parse_shorthand_branch_1` lambda of parse_grid_shorthand_value:
## `[ auto-flow && dense? ] <'grid-auto-rows'>? / <'grid-template-columns'>`.
func css_parser_parse_grid_shorthand_branch_1(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
css_syntax.token_stream_discard_whitespace(tokens)
let grid_auto_flow = css_parse_grid_auto_flow_and_dense(tokens, CssGridAutoFlowStyleValueAxis.row) else return none
var grid_auto_rows = css_parser_parse_grid_auto_track_sizes(this, tokens) else trap("VERIFY: grid-auto-rows")
if css_grid_track_size_list_value_is_empty(grid_auto_rows):
grid_auto_rows = css_property_initial_value(css_data.PropertyId.grid_auto_rows)
css_syntax.token_stream_discard_whitespace(tokens)
if not css_syntax.token_stream_has_next_token(tokens) or not css_next_token_is_delim(tokens, (u32)'/'):
return none
css_syntax.token_stream_discard_a_token(tokens) # /
css_syntax.token_stream_discard_whitespace(tokens)
let grid_template_columns = css_parser_parse_grid_track_size_list(this, tokens) else return none
css_syntax.state_transaction_commit(&transaction)
return css_shorthand_of(css_data.PropertyId.grid,
css_property_ids_of([css_data.PropertyId.grid_auto_flow, css_data.PropertyId.grid_auto_rows, css_data.PropertyId.grid_auto_columns,
css_data.PropertyId.grid_template_areas, css_data.PropertyId.grid_template_rows, css_data.PropertyId.grid_template_columns]),
css_style_values_of([grid_auto_flow, grid_auto_rows, css_property_initial_value(css_data.PropertyId.grid_auto_columns),
css_property_initial_value(css_data.PropertyId.grid_template_areas), css_property_initial_value(css_data.PropertyId.grid_template_rows),
grid_template_columns]))
## The `parse_shorthand_branch_2` lambda of parse_grid_shorthand_value:
## `<'grid-template-rows'> / [ auto-flow && dense? ] <'grid-auto-columns'>?`.
func css_parser_parse_grid_shorthand_branch_2(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
css_syntax.token_stream_discard_whitespace(tokens)
let grid_template_rows = css_parser_parse_grid_track_size_list(this, tokens) else return none
css_syntax.token_stream_discard_whitespace(tokens)
if not css_syntax.token_stream_has_next_token(tokens) or not css_next_token_is_delim(tokens, (u32)'/'):
return none
css_syntax.token_stream_discard_a_token(tokens) # /
css_syntax.token_stream_discard_whitespace(tokens)
let grid_auto_flow = css_parse_grid_auto_flow_and_dense(tokens, CssGridAutoFlowStyleValueAxis.column) else return none
var grid_auto_columns = css_parser_parse_grid_auto_track_sizes(this, tokens) else trap("VERIFY: grid-auto-columns")
if css_grid_track_size_list_value_is_empty(grid_auto_columns):
grid_auto_columns = css_property_initial_value(css_data.PropertyId.grid_auto_columns)
css_syntax.state_transaction_commit(&transaction)
return css_shorthand_of(css_data.PropertyId.grid,
css_property_ids_of([css_data.PropertyId.grid_auto_flow, css_data.PropertyId.grid_auto_rows, css_data.PropertyId.grid_auto_columns,
css_data.PropertyId.grid_template_areas, css_data.PropertyId.grid_template_rows, css_data.PropertyId.grid_template_columns]),
css_style_values_of([grid_auto_flow, css_property_initial_value(css_data.PropertyId.grid_auto_rows), grid_auto_columns,
css_property_initial_value(css_data.PropertyId.grid_template_areas), grid_template_rows,
css_property_initial_value(css_data.PropertyId.grid_template_columns)]))
## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:4987 Web::CSS::Parser::Parser::parse_grid_shorthand_value.
pub func css_parser_parse_grid_shorthand_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
# <'grid-template'>
if let grid_template = css_parser_parse_grid_track_size_list_shorthand_value(this, css_data.PropertyId.grid, tokens, true):
return grid_template
# NB: The `parse_auto_flow_and_dense`, `parse_shorthand_branch_1` and `parse_shorthand_branch_2` lambdas are
# css_parse_grid_auto_flow_and_dense, css_parser_parse_grid_shorthand_branch_1 and
# css_parser_parse_grid_shorthand_branch_2.
if let grid = css_parser_parse_grid_shorthand_branch_1(this, tokens):
return grid
if let grid = css_parser_parse_grid_shorthand_branch_2(this, tokens):
return grid
return none