Generalize bit string comprehensions

The expression in a bit string comprehension is limited to a
literal bit string expression. That is, the following code
is legal:

  << <<X>> || X <- List >>

but not this code:

  << foo(X) || X <- List >>

The limitation is annoying. For one thing, tools that transform
the abstract format must be careful not to produce code such as:

  << begin
      %% Some instrumentation code.
      <<X>>
     end || X <- List >>

One reason for the limitation could be that we'll get
reduce/reduce conflicts if we try to allow an arbitrary
expression in a bit string comprehension:

  binary_comprehension -> '<<' expr '||' lc_exprs '>>' :
	{bc,?anno('$1'),'$2','$4'}.

Unfortunately, there does not seem to be an easy way to work
around that problem. The best we can do is to allow 'expr_max'
expressions (as in the binary syntax):

  binary_comprehension -> '<<' expr_max '||' lc_exprs '>>' :
	{bc,?anno('$1'),'$2','$4'}.

That will work, but functions calls must be enclosed in
parentheses:

  << (foo(X)) || X <- List >>

0 files changed, 0 insertions, 0 deletions