From 205405f0bf1d2fa37d4c8170c11689a2937f5d9c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Tue, 1 Mar 2016 06:23:36 +0100
Subject: 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 >>
---
 lib/compiler/src/v3_core.erl | 40 ++++++++++++++++++++++++++++++++++------
 1 file changed, 34 insertions(+), 6 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/v3_core.erl b/lib/compiler/src/v3_core.erl
index 68c9f964d8..830dd9973a 100644
--- a/lib/compiler/src/v3_core.erl
+++ b/lib/compiler/src/v3_core.erl
@@ -1080,13 +1080,39 @@ bc_tq1(Line, E, [#igen{anno=GAnno,ceps=Ceps,
 bc_tq1(Line, E, [#ifilter{}=Filter|Qs], Mc, St) ->
     filter_tq(Line, E, Filter, Mc, St, Qs, fun bc_tq1/5);
 bc_tq1(_, {bin,Bl,Elements}, [], AccVar, St0) ->
-    {E,Pre,St} = expr({bin,Bl,[{bin_element,Bl,
-				{var,Bl,AccVar#c_var.name},
-				{atom,Bl,all},
-				[binary,{unit,1}]}|Elements]}, St0),
+    bc_tq_build(Bl, [], AccVar, Elements, St0);
+bc_tq1(Line, E0, [], AccVar, St0) ->
+    BsFlags = [binary,{unit,1}],
+    BsSize = {atom,Line,all},
+    {E1,Pre0,St1} = safe(E0, St0),
+    case E1 of
+	#c_var{name=VarName} ->
+	    Var = {var,Line,VarName},
+	    Els = [{bin_element,Line,Var,BsSize,BsFlags}],
+	    bc_tq_build(Line, Pre0, AccVar, Els, St1);
+	#c_literal{val=Val} when is_bitstring(Val) ->
+	    Bits = bit_size(Val),
+	    <<Int0:Bits>> = Val,
+	    Int = {integer,Line,Int0},
+	    Sz = {integer,Line,Bits},
+	    Els = [{bin_element,Line,Int,Sz,[integer,{unit,1},big]}],
+	    bc_tq_build(Line, Pre0, AccVar, Els, St1);
+	_ ->
+	    %% Any other safe (cons, tuple, literal) is not a
+	    %% bitstring. Force the evaluation to fail (and
+	    %% generate a warning).
+	    Els = [{bin_element,Line,{atom,Line,bad_value},BsSize,BsFlags}],
+	    bc_tq_build(Line, Pre0, AccVar, Els, St1)
+    end.
+
+bc_tq_build(Line, Pre0, #c_var{name=AccVar}, Elements0, St0) ->
+    Elements = [{bin_element,Line,{var,Line,AccVar},{atom,Line,all},
+		 [binary,{unit,1}]}|Elements0],
+    {E,Pre,St} = expr({bin,Line,Elements}, St0),
     #a{anno=A} = Anno0 = get_anno(E),
     Anno = Anno0#a{anno=[compiler_generated,single_use|A]},
-    {set_anno(E, Anno),Pre,St}.
+    {set_anno(E, Anno),Pre0++Pre,St}.
+
 
 %% filter_tq(Line, Expr, Filter, Mc, State, [Qualifier], TqFun) ->
 %%     {Case,[PreExpr],State}.
@@ -1307,7 +1333,9 @@ bc_elem_size({bin,_,El}, St0) ->
 	    Vs = [V || {_,#c_var{name=V}} <- Vars0],
 	    {E,Pre,St} = bc_mul_pairs(F, #c_literal{val=Bits}, [], St0),
 	    {E,Pre,Vs,St}
-    end.
+    end;
+bc_elem_size(_, _) ->
+    throw(impossible).
 
 bc_elem_size_1([{bin_element,_,_,{integer,_,N},Flags}|Es], Bits, Vars) ->
     {unit,U} = keyfind(unit, 1, Flags),
-- 
cgit v1.2.3