0
@@ -14,8 +14,7 @@
0
   ssa/1, 
0
   r2e/1, 
0
   dynamic/1, 
0
-  static/1, 
0
-  forms/1
0
+  static/1
0
 ]).
0
 
0
 default_passes() ->
0
@@ -52,7 +51,7 @@ r2e(Expressions) ->
0
     
0
 r2e([], Output) -> lists:reverse(Output);
0
 r2e([Expression|Rest], Output) ->
0
-  case forms(Expression) of
0
+  case reia_r2e:forms(Expression) of
0
     Expressions when is_list(Expressions) ->
0
       r2e(Rest, lists:reverse(Expressions) ++ Output);
0
     NewExpression ->
0
@@ -83,251 +82,4 @@ dynamic_expression(Expression) ->
0
 static([{module, Line, Name, Functions}]) ->
0
   [{attribute, Line, module, Name}|Functions];
0
 static(_) ->
0
-  throw({error, "Statically compiled modules must contain one and only one module declaration"}).
0
-
0
-%% Module declarations
0
-forms({module, Line, {constant, _, Name}, Functions}) ->
0
-  {module, Line, Name, group_clauses([forms(Function) || Function <- Functions])};
0
-
0
-%% Class declarations
0
-forms({class, Line, {constant, _, Name}, Functions}) ->
0
-  {class, Line, Name, group_clauses([forms(Function) || Function <- Functions])};
0
-  
0
-%% Functions
0
-forms({function, Line, {identifier, _, Name}, Arguments, Expressions}) ->
0
-  {function, Line, Name, erlang:length(Arguments), [{clause, Line, 
0
-    [forms(Argument) || Argument <- Arguments],
0
-    [],
0
-    [forms(Expression) || Expression <- Expressions]
0
-  }]};
0
-  
0
-%% Pattern matching
0
-forms({match, Line, In1, In2}) ->
0
-  {match, Line, forms(In1), forms(In2)};
0
-  
0
-%% Variables
0
-forms({identifier, Line, Name}) ->
0
-  {var, Line, Name};
0
-
0
-%% Primitives
0
-forms({nil, Line}) ->
0
-  {atom, Line, nil};
0
-forms({true, Line}) ->
0
-  {atom, Line, true};
0
-forms({false, Line}) ->
0
-  {atom, Line, false};
0
-  
0
-%% Numerical types
0
-forms(Ast = {integer, _, _}) ->
0
-  Ast;
0
-forms(Ast = {float, _, _}) ->
0
-  Ast;
0
-  
0
-%% Atoms
0
-forms(Ast = {atom, _, _}) ->
0
-  Ast;
0
-  
0
-%% Constants
0
-forms({constant, Line, Name}) ->
0
-  {tuple, Line, [{atom, Line, constant}, {atom, Line, Name}]};
0
-  
0
-%% Strings
0
-forms({string, Line, String}) ->
0
-  {tuple, Line, [
0
-    {atom, Line, string},
0
-    {bin, Line, [{bin_element, Line, {string, Line, String}, default, default}]}
0
-  ]};
0
-  
0
-%% Regexes
0
-forms({regexp, Line, Pattern}) ->
0
-  {tuple, Line, [
0
-    {atom, Line, regexp}, 
0
-    {bin, Line, [{bin_element, Line, {string, Line, Pattern}, default, default}]}
0
-  ]};
0
-
0
-%% Lists
0
-forms({list, Line, Elements}) ->
0
-  Result = {tuple, Line, [
0
-    {atom, Line, list},
0
-    {tuple, Line, [
0
-      list_to_forms([], Line),
0
-      list_to_forms(Elements, Line)
0
-    ]}
0
-  ]},
0
-  Result;
0
-  
0
-%% Tuples
0
-forms({tuple, Line, Elements}) ->
0
-  {tuple, Line, [
0
-    {atom, Line, tuple},
0
-    {tuple, Line, [forms(Element) || Element <- Elements]}
0
-  ]};
0
-  
0
-%% Dicts
0
-forms({dict, Line, Elements}) ->
0
-  {tuple, Line, [
0
-    {atom, Line, dict},
0
-    {call, Line,
0
-      {remote, Line, {atom, Line, dict}, {atom, Line, from_list}},
0
-      [dict_elements_forms(Elements, Line)]
0
-    }
0
-  ]};
0
-  
0
-%% Binaries
0
-forms({binary, Line, String = {string, _, _}}) ->
0
-  {bin, Line, [{bin_element, Line, String, default, default}]};
0
-  
0
-%% Lambdas
0
-forms({lambda, Line, Args, Statements}) ->
0
-  {'fun', Line, 
0
-    {clauses,[{clause, Line, [forms(Arg) || Arg <- Args], [], [forms(Statement) || Statement <- Statements]}]}
0
-  };
0
-  
0
-%% Ranges
0
-forms({range, Line, Begin, End}) ->
0
-  {tuple, Line, [
0
-    {atom, Line, list},
0
-    {tuple, Line, [
0
-      list_to_forms([], Line),
0
-      {call, Line,
0
-        {remote, Line, {atom, Line, lists}, {atom, Line, seq}},
0
-        [forms(Begin), forms(End)]
0
-      }
0
-    ]}
0
-  ]};
0
-  
0
-%% Operators
0
-forms({op, Line, Op, In}) ->
0
-  reia_operators:forms(Op, Line, forms(In));
0
-forms({op, Line, Op, In1, In2}) ->
0
-  reia_operators:forms(Op, Line, forms(In1), forms(In2));
0
-  
0
-%% Reia function calls
0
-forms({funcall, Line, {identifier, _, Method}, Arguments}) ->
0
-  {call, Line, {atom, Line, Method}, [forms(Argument) || Argument <- Arguments]};
0
-forms({funcall, Line, {var, _, Var}, Arguments}) ->
0
-  {call, Line, forms({identifier, Line, Var}), [forms(Argument) || Argument <- Arguments]};
0
-forms({funcall, Line, Receiver, {identifier, _, Method}, Arguments}) ->
0
-  {call, Line,
0
-    {remote, Line, {atom, Line, reia_dispatch}, {atom, Line, funcall}},
0
-    [forms(Receiver), {atom, Line, Method}, list_to_forms(Arguments, Line)]
0
-  };
0
-  
0
-%% Reia function calls with pseudo-blocks
0
-forms({funcall, Line, Receiver, {identifier, _, Method}, Arguments, Block}) ->
0
-  {call, Line,
0
-    {remote, Line, {atom, Line, reia_dispatch}, {atom, Line, funcall}},
0
-    [forms(Receiver), {atom, Line, Method}, list_to_forms(Arguments, Line), forms(Block)]
0
-  };
0
-    
0
-%% Erlang function calls
0
-forms({erl_funcall, Line, {identifier, _, Module}, {identifier, _, Function}, Arguments}) ->
0
-  {call, Line,
0
-    {remote, Line, {atom, Line, reia_erl}, {atom, Line, erl_funcall}},
0
-    [{atom, Line, Module}, {atom, Line, Function}, list_to_forms(Arguments, Line)]
0
-  };
0
-  
0
-%% Embedded literal Erlang function calls (emitted by earlier compiler passes)
0
-forms({call, Line, Function, Arguments}) ->
0
-  {call, Line, Function, [forms(Argument) || Argument <- Arguments]};
0
-  
0
-%% Begin/end blocks
0
-forms({block, Line, Expressions}) ->
0
-  {block, Line, [forms(Expression) || Expression <- Expressions]};
0
-  
0
-%% Case expressions
0
-forms({'case', Line, Expression, Clauses}) ->
0
-  forms({'case', Line, Expression, Clauses, {else_clause, Line, [{atom, Line, nil}]}});
0
-forms({'case', Line, Expression, Clauses, ElseClause}) ->
0
-  {'case', Line, forms(Expression), [forms(Clause) || Clause <- Clauses ++ [ElseClause]]};
0
-    
0
-forms({clause, Line, Expression, Statements}) ->
0
-  {clause, Line, [forms(Expression)], [], [forms(Statement) || Statement <- Statements]};
0
-  
0
-forms({else_clause, Line, Statements}) ->
0
-  {clause, Line, [{var, Line, '_'}], [], [forms(Statement) || Statement <- Statements]};
0
-  
0
-%% If statements
0
-forms({'if', Line, Expression, Statements}) ->
0
-  forms({'if', Line, Expression, Statements, {else_clause, Line, [{atom, Line, nil}]}});
0
-
0
-forms({'if', Line, Expression, Statements, {else_clause, ElseLine, ElseStatements}}) ->
0
-  ElseForms = [forms(Statement) || Statement <- ElseStatements],
0
-  {'case', Line, forms(Expression),
0
-    [
0
-      {clause, ElseLine, [{atom, Line, false}], [], ElseForms},
0
-      {clause, ElseLine, [{atom, Line, nil}],   [], ElseForms},
0
-      {clause, Line, [{var, Line, '_'}], [], [forms(Statement) || Statement <- Statements]}
0
-    ]
0
-  };
0
-  
0
-%% Try statements
0
-forms({'try', Line, Statements, CatchClauses}) ->
0
-  {'try', Line, 
0
-    [forms(Statement) || Statement <- Statements],
0
-    [],
0
-    [forms(CatchClause) || CatchClause <- CatchClauses],
0
-    []
0
-  };
0
-
0
-%% Catch clauses
0
-forms({'catch', Line, Pattern, Statements}) ->
0
-  {clause, Line, 
0
-    [{tuple, Line, [{var, Line, 'ExceptionType'}, {var, Line, 'ExceptionReason'}, {var, Line, '_Lint'}]}], 
0
-    [],
0
-    [
0
-      {match, Line, forms(Pattern), {tuple, Line, [
0
-        {atom, Line, exception},
0
-        {tuple, Line, [
0
-          {var, Line, 'ExceptionType'},
0
-          {var, Line, 'ExceptionReason'}
0
-        ]}
0
-      ]}}|[forms(Statement) || Statement <- Statements]
0
-    ]
0
-  };
0
-  
0
-%% Throw statements
0
-forms({throw, Line, Term}) ->
0
-  {call, Line, {atom, Line, throw}, [forms(Term)]};
0
-  
0
-%% List comprehensions
0
-forms({'lc', Line, Transform, Expressions}) ->
0
-  {lc, Line, forms(Transform), [forms(Expression) || Expression <- Expressions]};
0
-  
0
-%% List comprehension generators
0
-forms({'generate', Line, Term, List}) ->
0
-  {generate, Line, forms(Term), 
0
-    {call, Line, {remote, Line, {atom, Line, reia_list}, {atom, Line, to_erl}}, [forms(List)]}
0
-  };
0
-  
0
-%% Erlang forms generated by earlier stages of the compiler which should be
0
-%% used verbatim
0
-forms({erl_forms, _Line, Forms}) ->
0
-  Forms.
0
-    
0
-%% Group clauses of functions with the same name and arity
0
-group_clauses(Functions) ->
0
-  group_clauses(Functions, dict:new()).
0
-
0
-group_clauses([], Dict) ->
0
-  [{function, Line, Name, Arity, lists:reverse(Clauses)} || {{Name, Arity},{Line, Clauses}} <- dict:to_list(Dict)];
0
-group_clauses([Function|Rest], Dict) ->
0
-  {function, Line, Name, Arity, [Clause]} = Function,
0
-  case dict:find({Name, Arity}, Dict) of
0
-    {ok, {Line2, Clauses}} ->
0
-      group_clauses(Rest, dict:store({Name, Arity}, {Line2, [Clause|Clauses]}, Dict));
0
-    error ->
0
-      group_clauses(Rest, dict:store({Name, Arity}, {Line, [Clause]}, Dict))
0
-  end.
0
-
0
-%% Generate AST representing lists
0
-list_to_forms([], Line) ->
0
-  {nil, Line};
0
-list_to_forms([Element|Rest], Line) ->
0
-  {cons, Line, forms(Element), list_to_forms(Rest, Line)}.
0
-  
0
-%% Generate AST representing dict elements
0
-dict_elements_forms([], Line) ->
0
-  {nil, Line};
0
-dict_elements_forms([{Key,Value}|Rest], Line) ->
0
-  {cons, Line, {tuple, Line, [forms(Key), forms(Value)]}, dict_elements_forms(Rest, Line)}.
0
\ No newline at end of file
0
+  throw({error, "Statically compiled modules must contain one and only one module declaration"}).
0
\ No newline at end of file