W3C home > Mailing lists > Public > public-css-archive@w3.org > August 2021

[csswg-drafts] [css-values] nested `calc ()` is not defined by its grammar (#6506)

From: Guillaume via GitHub <sysbot+gh@w3.org>
Date: Tue, 10 Aug 2021 13:59:54 +0000
To: public-css-archive@w3.org
Message-ID: <issues.opened-965014687-1628603992-sysbot+gh@w3.org>
cdoublev has just created a new issue for https://github.com/w3c/csswg-drafts:

== [css-values] nested `calc ()` is not defined by its grammar ==

The grammar of `<calc-value>` ([Mathematical expressions - Syntax, CSS Values](https://drafts.csswg.org/css-values-4/#calc-syntax)) does not seem to allow `calc()` to be used recursively and in other math functions. This is only possible with simple blocks.

<calc-sum>     = <calc-product> [ [ '+' | '-' ] <calc-product> ]*
<calc-product> = <calc-value> [ [ '*' | '/' ] <calc-value> ]*
<calc-value>   = <number> | <dimension> | <percentage> | <calc-constant> | ( <calc-sum> )

<calc()> = calc( <calc-sum> )
<min()> = min( <calc-sum># )
... other math functions

Would the following change be appropriate?

- <calc-value> = <number> | <dimension> | <percentage> | <calc-constant> | ( <calc-sum> )
+ <calc-value> = <number> | <dimension> | <percentage> | <calc-constant> | ( <calc-sum> ) | <calc()>

To be honest, I'm creating this issue as a pretext to ask for clarifications about other math functions related parts of the specification that I'm not sure to understand correctly. I hope I will not waste anyone's time by asking stupid questions, and that they will help to improve some parts instead.

In the introduction of [The internal representation](https://drafts.csswg.org/css-values-4/#calc-internal) (of math functions), it is written:

> The internal representation [of any math function other than `calc()`] is an operator node with the same name as the function, whose children are the result of parsing a calculation from each of the function’s arguments, in the order they appear.

The `round()` function accepts a component value that is not a calculation as its arguments: `<round()> = round( <rounding-strategy>?, <calc-sum>, <calc-sum> )`. Am I right to think that the above definition was written after adding `round()` to the specification? `round()` does not seem to be handled also in the procedure to serialize a math function, which starts with *"If the root of the calculation tree `fn` represents is a numeric value [...]"*.

For step 3 of [the procedure to parse a calculation](https://drafts.csswg.org/css-values-4/#parse-a-calculation), it is written:

> For every consecutive run of value items in values separated by "*" or "/" operators: [...]

What is a "run" in a "every consecutive run of values"? Is it different from "every consecutive values"? Should `1 * 2 * 3 * 4` be reduced to a Product `[[1, 2], [3, 4]]`, `[[[[1, 2], 3], 4]`, or `[1, 2, 3, 4]`? Does it really matter? I believe that the procedure to simplify a calculation tree will be able to process and return the same result for these 3 different structures anyway, but I'm just not sure why this "consecutive run" term is used.

For step 4 of this same procedure, it is written:

> If `values` has only one item, and it is a Product node or a parenthesized simple block [...]

Given the grammar of `<calc-sum>`, theoretically a sum can only receive `<calc-product>`. Is it correct that this means that a Product data structure is different from a component value matching the grammar of `<calc-product>`? If so, that's quite confusing to me. Is it about to avoid writing the grammar of `<calc-sum>` with `<calc-value> | <calc-product> [['*' | '/'] <calc-product> `?

In step 4 of the [procedure to simplify a calculation tree](https://drafts.csswg.org/css-values-4/#simplify-a-calculation-tree), it is written:

> If root is an operator node that’s not one of the calc-operator nodes, and all of its children are numeric values with enough information to compute the operation root represents [...]

Is it correct that `root` can only be a math function? If so, what is the reason for not using the `math function` term instead of *an operator node that’s not one of the calc-operator nodes*?

Also, it seems to me that none of the remaining steps of this procedure handle a math function containing non numeric values. Does a step *10. Return `root`* is missing?

I see this note above the procedure to [serialize a mathematical function](https://drafts.csswg.org/css-values-4/#calc-serialize):

> This section is still [under discussion](https://lists.w3.org/Archives/Member/w3c-css-wg/2016AprJun/0239.html).

But access to the link target is restricted to W3C members. Is it possible to give me clues for the following terms that appear in the different steps of this procedure:

- *the root of the calculation tree `fn` represents*
- *`fn` represents*
- *the calculation tree’s `root` node is*

Do they mean different things?

Please view or discuss this issue at https://github.com/w3c/csswg-drafts/issues/6506 using your GitHub account

Sent via github-notify-ml as configured in https://github.com/w3c/github-notify-ml-config
Received on Tuesday, 10 August 2021 13:59:56 UTC

This archive was generated by hypermail 2.4.0 : Tuesday, 5 July 2022 06:42:42 UTC