From 5b4b6c9b6bd1cf258841004f2e11bb2a82ebfe24 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn-Egil=20Dahlberg?= <egil@erlang.org>
Date: Mon, 13 Jan 2014 18:05:00 +0100
Subject: compiler: Squash #c_map_pair_*{} to #c_map_pair{}

Simplify compiler internals and parsing of core format.
---
 lib/compiler/src/cerl_inline.erl | 46 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 45 insertions(+), 1 deletion(-)

(limited to 'lib/compiler/src/cerl_inline.erl')

diff --git a/lib/compiler/src/cerl_inline.erl b/lib/compiler/src/cerl_inline.erl
index c6de63c69f..3837b57750 100644
--- a/lib/compiler/src/cerl_inline.erl
+++ b/lib/compiler/src/cerl_inline.erl
@@ -63,7 +63,11 @@
 	       receive_clauses/1, receive_timeout/1, seq_arg/1,
 	       seq_body/1, set_ann/2, try_arg/1, try_body/1, try_vars/1,
 	       try_evars/1, try_handler/1, tuple_es/1, tuple_arity/1,
-	       type/1, values_es/1, var_name/1]).
+	       type/1, values_es/1, var_name/1,
+	       map_es/1, update_c_map/2,
+	       update_c_map_pair/4,
+	       map_pair_op/1, map_pair_key/1, map_pair_val/1
+	   ]).
 
 -import(lists, [foldl/3, foldr/3, mapfoldl/3, reverse/1]).
 
@@ -128,6 +132,8 @@ weight(call) -> 3;      % Assume remote-calls as efficient as `apply'.
 weight(primop) -> 2;    % Assume more efficient than `apply'.
 weight(binary) -> 4;    % Initialisation base cost.
 weight(bitstr) -> 3;    % Coding/decoding a value; like a primop.
+weight(map) -> 4;       % Initialisation base cost.
+weight(map_pair) -> 3;  % Coding/decoding a value; like a primop.
 weight(module) -> 1.    % Like a letrec with a constant body
 
 %% These "reference" structures are used for variables and function
@@ -333,6 +339,8 @@ i(E, Ctxt, Ren, Env, S0) ->
                     i_catch(E, Ctxt, Ren, Env, S);
 		binary ->
 		    i_binary(E, Ren, Env, S);
+		map ->
+		    i_map(E, Ctxt, Ren, Env, S);
                 module ->
                     i_module(E, Ctxt, Ren, Env, S)
             end
@@ -1324,6 +1332,25 @@ i_bitstr(E, Ren, Env, S) ->
     S3 = count_size(weight(bitstr), S2),
     {update_c_bitstr(E, Val, Size, Unit, Type, Flags), S3}.
 
+i_map(E, Ctx, Ren, Env, S) ->
+    %% Visit the segments for value.
+    {Es, S1} = mapfoldl(fun (E, S) ->
+				i_map_pair(E, Ctx, Ren, Env, S)
+			end,
+			S, map_es(E)),
+    S2 = count_size(weight(map), S1),
+    {update_c_map(E, Es), S2}.
+
+i_map_pair(E, Ctx, Ren, Env, S) ->
+    %% It is not necessary to visit the Op and Key fields,
+    %% since these are always literals.
+    {Val, S1} = i(map_pair_val(E), Ctx, Ren, Env, S),
+    Op = map_pair_op(E),
+    Key = map_pair_key(E),
+    S2 = count_size(weight(map_pair), S1),
+    {update_c_map_pair(E, Op, Key, Val), S2}.
+
+
 %% This is a simplified version of `i_pattern', for lists of parameter
 %% variables only. It does not modify the state.
 
@@ -1383,6 +1410,14 @@ i_pattern(E, Ren, Env, Ren0, Env0, S) ->
 				S, binary_segments(E)),
 	    S2 = count_size(weight(binary), S1),
 	    {update_c_binary(E, Es), S2};
+	map ->
+	    {Es, S1} = mapfoldl(fun (E, S) ->
+					i_map_pair_pattern(E, Ren, Env,
+							  Ren0, Env0, S)
+				end,
+				S, map_es(E)),
+	    S2 = count_size(weight(map), S1),
+	    {update_c_map(E, Es), S2};
 	_ ->
 	    case is_literal(E) of
 		true ->
@@ -1416,6 +1451,15 @@ i_bitstr_pattern(E, Ren, Env, Ren0, Env0, S) ->
     S3 = count_size(weight(bitstr), S2),
     {update_c_bitstr(E, Val, Size, Unit, Type, Flags), S3}.
 
+i_map_pair_pattern(E, Ren, Env, Ren0, Env0, S) ->
+    %% It is not necessary to visit the Op it is always a literal.
+    %% Same goes for Key
+    {Val, S1} = i_pattern(map_pair_val(E), Ren, Env, Ren0, Env0, S),
+    Op = map_pair_op(E), %% should be 'exact' literal
+    Key  = map_pair_key(E),
+    S2 = count_size(weight(map_pair), S1),
+    {update_c_map_pair(E, Op, Key, Val), S2}.
+
 
 %% ---------------------------------------------------------------------
 %% Other central inlining functions
-- 
cgit v1.2.3