28

I have an engine that does some mathematical and logical operations by taking formulas, operands and operators from a file. All the operations are executed in an eval scope and the final result is saved in another file.

These files are often transferred through a network, so I am trying to minimize them by stripping all the spaces before and after operations. As far as I know there are no strict rules about that matter, however I stumbled upon this behavior:

$x = 1;
$result = $x++-++$x; // works
$result = $x+++++$x; // fails
$result = $x++ + ++$x; // works again

  1. Why is PHP confused by the "+++++" syntax, but accepts "++-++"? How is "plus" better than "minus"?

  2. Is there a list anywhere of operators that are sensitive about spaces?

Axalix
  • 2,831
  • 1
  • 20
  • 37
  • 9
    don't know the answer but I hope you're being *really* careful about those input files that you `eval()` because they would otherwise present a huge vulnerability – BeetleJuice Aug 13 '17 at 00:10
  • 4
    Be really, really careful with eval. And this seems like a messy way to go about it, but its an interesting question none the less. – Qirel Aug 13 '17 at 00:12
  • Thank you for the warning about `eval`. There is no really any user input that could come from the web. But yes, you are right - it was just the easiest solution for me to execute a string as a code. – Axalix Aug 13 '17 at 00:19
  • Given there is NO php language standard, you cannot tell what behaviour is right or wrong: it works the way it works simply because that's how it's implemented, there is no other reason for it. – zerkms Aug 13 '17 at 01:23
  • 5
    @zerkms Actually, there *is* a PHP Language Spec, but it exists largely to enshrine the behaviour of the original implementation so alternatives like HHVM have something to benchmark against. https://github.com/php/php-langspec – IMSoP Aug 13 '17 at 01:38
  • @IMSoP it's far to cover the php in full. For a language standard to be "the standard", the process of language evolution should go the "standard -> implementation" way, not the other way around. It covers something, indeed, but it's not reliable. Compare it with Java, C# or ES standards. – zerkms Aug 13 '17 at 02:34
  • Take a look at [this answer](https://stackoverflow.com/a/45140057/4265352). It's a different question but the same principle. The parser reads as much as it can; after `$x++` it reads `++` and it gets `($x++)++` that is invalid because `$x++` is not a [l-value](https://en.m.wikipedia.org/wiki/L-value). – axiac Aug 13 '17 at 06:49
  • 1
    @zerkms Sure, I was just pointing out that technically, it does exist, and does define some of the edge cases like this. Interesting you mention ES though, which clearly *didn't* predate implementations; similarly, ISO C came decades after C was invented and popularised. If HHVM had continued to grow in popularity, PHP lang spec would be more well known, and any remaining edge cases covered off. – IMSoP Aug 13 '17 at 11:14
  • related: [Why doesn't `a+++++b` work in C?](https://stackoverflow.com/q/5341202/995714), [What are the parsing rules for expressions in C?](https://stackoverflow.com/q/4005076/995714) – phuclv Aug 13 '17 at 11:28
  • 5
    Coming from `C`, I cringe when I see something like `x++-++x`, which is textbook undefined behavior. Does PHP nail down its meaning? – John Coleman Aug 13 '17 at 12:46
  • 2
    “I am trying to minimize them by stripping all the spaces before and after operations” Have you considered using something like GZIP? – Andrea Lazzarotto Aug 13 '17 at 19:48

3 Answers3

35

The PHP parser is searching for the ++ sign before the last + sign, and the syntax ($x++)++ makes no sense, due to the fact that the increment operator should be applied to a variable (and not an integer, which is the result of the first $x++).

The precedence of the operator's operations can be found here:
http://php.net/manual/en/language.operators.precedence.php

$x+++++$x;
^ php parser starts here, find $x++
    ^ here there is a new ++, which has hight precedence to the next + char
      ^ here is the last +, which the php parser will find last.

When the two ++, ++ split with a minus sign, the code is actually $x++ - ++$x, one which the PHP parser can understand.

This is also the reason why $x++ + ++$x works.

Dekel
  • 60,707
  • 10
  • 101
  • 129
12

The answer is that the parser looks for longer tokens before looking for shorter ones. Therefore ++++++ becomes ++ ++ +, which is unsensible to the interpreter.

PHP is one of many those languages that borrows its expression grammar from C, so this note may be of interest to you. In the C11 draft, section 6.4 clause 6 gave an example:

The program fragment x+++++y is parsed as x ++ ++ + y, which violates a constraint on increment operators, even though the parse x ++ + ++ y might yield a correct expression.

DannyNiu
  • 1,313
  • 8
  • 27
10

A little more supplementary info. When a PHP script is "lexed", i.e. when it is scanned, the tokens comprising the script are examined. A pair of characters like "++" signify an increment token, as follows:

<ST_IN_SCRIPTING>"++" {
    RETURN_TOKEN(T_INC);
}

This "rule" is in the file Zend/language_scanner.l which accompanies PHP when you download and install it. The only way that a script when scanned becomes intelligible to the lexer with regards to pre- or post-incrementing variables is if there is some kind of demarcation such as spacing so that each "+" is properly evaluated in context.

Note that writing code like the following is inadvisable:

  <?php

  $x=0;
  echo $x++ + ++$x;

even tho' it will be lexed correctly. The reason for objecting to this coding style is because it can be less than apparent to human brains as to what is really occurring. The order of evaluation is not what it may seem, i.e. a variable being post-incremented and then being added to itself with its pre-incremented value.

Per the opcodes, the pre- and post-incrementations occur before addition takes place. Also, note that post-incrementation returns a variable's value and then increments it. So, initially, $x is assigned a value of 0. Then, it is post-incremented so that a temporary variable returns with a value of zero. Then, $x gets incremented to acquire a value of one. Next, $x is pre-incremented, and so $x moves from a value of one to two and its temporary variable evaluates as two. Lastly, the the two temporary variables are added, so that 0 + 2 == 2; see here as well as here.

Also, an excellent read here.

Incidentally, in this case PHP conforms with its forbear The C Programming Language; see here.

slevy1
  • 3,797
  • 2
  • 27
  • 33