ic_jbe.erl

来自「OTP是开放电信平台的简称」· ERL 代码 · 共 1,486 行 · 第 1/4 页

%% ``The contents of this file are subject to the Erlang Public License,
%% Version 1.1, (the "License"); you may not use this file except in
%% compliance with the License. You should have received a copy of the
%% Erlang Public License along with this software. If not, it can be
%% retrieved via the world wide web at http://www.erlang.org/.
%% 
%% Software distributed under the License is distributed on an "AS IS"
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
%% the License for the specific language governing rights and limitations
%% under the License.
%% 
%% The Initial Developer of the Original Code is Ericsson Utvecklings AB.
%% Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
%% AB. All Rights Reserved.''
%% 
%%     $Id$
%%


-module(ic_jbe).


-export([do_gen/3, gen/3, emit_type_function/4]).



-include("icforms.hrl").
-include("ic.hrl").
-include("ic_debug.hrl").
-include_lib("stdlib/include/erl_compile.hrl").



%%------------------------------------------------------------
%%
%% Entry point
%%
%%------------------------------------------------------------

do_gen(G, _File, Form) -> 
    gen(G, [], Form).


%%------------------------------------------------------------
%%
%% Generate the client side C stubs.
%%
%% Each module is generated to a separate file.
%%
%% Each function needs to generate a function head and
%% a body. IDL parameters must be converted into C parameters.
%%
%%------------------------------------------------------------

gen(G, N, [X|Xs]) when record(X, preproc) ->
    NewG = handle_preproc(G, N, X#preproc.cat, X),
    gen(NewG, N, Xs);

gen(G, N, [X|Xs]) when record(X, module) ->
    gen_module(G, N, X),
    gen(G, N, Xs);

gen(G, N, [X|Xs]) when record(X, interface) ->
    gen_interface(G, N, X),
    gen(G, N, Xs);

gen(G, N, [X|Xs]) when record(X, const) ->
    ic_constant_java:gen(G, N, X),
    gen(G, N, Xs);

gen(G, N, [X|Xs]) when record(X, op) ->
    gen(G, N, Xs);

gen(G, N, [X|Xs]) when record(X, attr) ->
    gen(G, N, Xs);

gen(G, N, [X|Xs]) when record(X, except) ->
    gen_exception(G, N, X),
    gen(G, N, Xs);

gen(G, N, [X|Xs]) when record(X, enum) ->
    ic_enum_java:gen(G, N, X),
    gen(G, N, Xs);

gen(G, N, [X|Xs]) when record(X, struct) ->
    ic_struct_java:gen(G, N, X),
    gen(G, N, Xs);

gen(G, N, [X|Xs]) when record(X, union) ->
    ic_union_java:gen(G, N, X),
    gen(G, N, Xs);

gen(G, N, [X|Xs]) when record(X, typedef) ->
    gen_typedef(G, N, X),
    gen(G, N, Xs);

gen(G, N, [X|Xs]) when record(X, member) ->
    %%?PRINTDEBUG2("gen member: ~p\n",[ic_forms:get_type(X)]),
    gen_member(G, N, X),
    gen(G, N, Xs);

gen(G, N, [X|Xs]) when record(X, case_dcl) ->
    %%?PRINTDEBUG2("gen case decl: ~p\n",[ic_forms:get_type(X)]),
    gen(G, N, [ic_forms:get_type(X)]),
    gen(G, N, Xs);

gen(G, N, [_|Xs]) ->
    gen(G, N, Xs);

gen(_G, _N, []) -> 
    ok.


%%%--------------------------------------------
%%%
%%%   Just generates the directory to host 
%%%   the module files
%%%
%%%--------------------------------------------

gen_module(G, N, X) ->
    case ic_genobj:do_gen(G) of

	true -> %% Generate & register
	    N1 = [ic_forms:get_id2(X) | N],
	    %% Create directory
	    ic_file:createJavaDirectory(G, N1),
	    gen(G, N1, ic_forms:get_body(X));

	false -> %% Register only
	    N1 = [ic_forms:get_id2(X) | N],
	    reg(G, N1, ic_forms:get_body(X))
    end.

reg(G, N, [X|_Xs]) when record(X, module) ->
    reg(G, [ic_forms:get_id2(X) | N], ic_forms:get_body(X));

reg(G, N, [X|_Xs]) when record(X, interface) ->
    reg(G, [ic_forms:get_id2(X) | N], ic_forms:get_body(X));

reg(G, N, [X|Xs]) when record(X, typedef) ->
    Name = ic_util:to_dot(G,[ic_forms:get_java_id(X) | N]),
    case X#typedef.type of 
	{scoped_id,_,_,_} ->
	    {FullScopedName, _, _, _} = 
		ic_symtab:get_full_scoped_name(G, N, X#typedef.type),
	    Type = ic_code:get_basetype(G, ic_util:to_dot(G,FullScopedName)), 
	    ic_code:insert_typedef(G, Name, Type);
	_ ->
	    ok
    end,
    reg(G, N, Xs);

reg(G, N, [_|Xs]) ->
    reg(G, N, Xs);

reg(_G, _N, []) -> 
    ok.



    
%%%----------------------------------------------
%%%
%%%   Generates the interface code
%%%
%%%----------------------------------------------

gen_interface(G, N, X) ->
    case ic_genobj:do_gen(G) of
	true ->
 	    G1 = ic_file:javaInterfaceFilePush(G, N, X),

	    %% Generate Interface file
	    InterfaceFd = ic_genobj:interfacefiled(G1),
	    emit_interface(G1, N, X, InterfaceFd),

	    %% Generate Helper file
	    HelperFd = ic_genobj:helperfiled(G1),
	    emit_helper(G1, N, X, HelperFd),

	    %% Generate Holder file
	    HolderFd = ic_genobj:holderfiled(G1),
	    emit_holder(G1, N, X, HolderFd),

	    %% Generate Stub file
	    StubFd = ic_genobj:stubfiled(G1),
	    emit_stub(G1,N,X,StubFd),  %<--------------------------------------------------- 1

	    %% Generate Skeleton file
	    SkelFd = ic_genobj:skelfiled(G1),
	    emit_skel(G1, N, X, SkelFd),

	    ic_file:javaInterfaceFilePop(G1);
	false ->
	    ok
    end.
	



%%%--------------------------------------------
%%%
%%%   Typedef redirection
%%%
%%%--------------------------------------------

gen_typedef(G, N, X) ->
    Name = ic_util:to_dot(G,[ic_forms:get_java_id(X) | N]),
    case X#typedef.type of 
	{scoped_id,_,_,_} ->
	    {FullScopedName, _, _, _} = 
		ic_symtab:get_full_scoped_name(G, N, X#typedef.type),
	    Type = ic_code:get_basetype(G, ic_util:to_dot(G,FullScopedName)), 
	    ic_code:insert_typedef(G, Name, Type);
	_ ->
	    ok
    end,
    gen_typedef_1(G, N, X, ic_forms:get_body(X)).

gen_typedef_1(G, N, X, Type) when record(Type, sequence) ->
    ic_sequence_java:gen(G, N, Type, ic_forms:get_java_id(X));
gen_typedef_1(G, N, X, Type) when record(Type, array) ->
    ic_array_java:gen(G, N, X, Type);
gen_typedef_1(G, N, X, _Type) ->
    gen_typedef_2(G, N, X, X#typedef.id), 
    ok.

gen_typedef_2(G, N, X, Type) when record(Type, array) ->
    gen_typedef_1(G, N, X, Type);
gen_typedef_2(G, N, X, Type) when list(Type) ->
    case Type of
	[] ->
	    ok;
	_ ->
	    gen_typedef_2(G, N, X, hd(Type)),
	    gen_typedef_2(G, N, X, tl(Type))
    end;
%gen_typedef_2(G, N, X, Type) -> %% Generating Helpers for typedef
%                                %% Stoped due to compatibility problems
%                                %% with erl_genserv backend
%    case ic_java_type:isBasicType(G,N,X#typedef.type) of
%	true ->
%	    ok;
%	false ->
%	    case ic_forms:get_type_code(G,N,X#typedef.type) of
%		{'tk_struct', _, _, _} ->
%		    ic_struct_java:gen(G, N, X);
%		{'tk_sequence',_,_} ->
%		    ic_sequence_java:gen(G, N, X, ic_forms:get_java_id(X)),
%		    ok;
%		_ ->
%		    ok
%	    end
%    end;
gen_typedef_2(_G, _N, _X, _Type) ->
    ok.



%%%--------------------------------------------
%%%
%%%   Member redirection
%%%
%%%--------------------------------------------

gen_member(G, N, X) ->
    gen_member_1(G, N, X, [X#member.type]),
    gen_member_2(G, N, X, X#member.id).


gen_member_1(_G, _N, _X, []) ->
    ok;

gen_member_1(G, N, X, [T|Ts]) when record(T, sequence) ->
    ic_sequence_java:gen(G, N, T, ic_forms:get_java_id(X)),
    gen_member_1(G, N, X, Ts);

gen_member_1(G, N, X, [T|Ts]) ->
    gen(G,N,[T]),
    gen_member_1(G,N,X,Ts).


gen_member_2(_G, _N, _X, []) ->
    ok;

gen_member_2(G, N, X, [T|Ts]) when record(T, array) -> %% BUG !
    ic_array_java:gen(G, N, X, T),
    gen_member_2(G, N, X, Ts);

gen_member_2(G, N, X, [_T|Ts]) ->
    gen_member_2(G, N, X, Ts).



gen_exception(_G, N, X) ->
    io:format("Warning : Exceptions not supported for java mapping, ~p ignored\n",
	     [ic_util:to_colon([ic_forms:get_java_id(X)|N])]),
    ok.



%%%-----------------------------------------------------
%%%
%%%  Interface file generation
%%%
%%%-----------------------------------------------------

emit_interface(G, N, X, Fd) ->
    Interface = ic_forms:get_java_id(X), %% Java Interface Name
    IFCName = ic_forms:get_id2(X), %% Internal Interface Name 

    ic_codegen:emit(Fd, "public interface ~s {\n\n",[Interface]),
    Body = ic_forms:get_body(X),

    %% Generate type declarations inside interface
    gen(G, [IFCName |N], Body),
    
    lists:foreach(fun({_Name, Body1}) ->
			  emit_interface_prototypes(G, [IFCName|N], Body1, Fd) end,
		  [{x, Body} | X#interface.inherit_body]),
	    
    ic_codegen:emit(Fd, "}\n\n").


emit_interface_prototypes(G, N, [X |Xs], Fd) when record(X, op) ->

    {_, ArgNames, TypeList} = extract_info(G, N, X),
    {R, ParameterTypes, _} = TypeList,

    OpName = ic_forms:get_java_id(X),
    RT = ic_java_type:getParamType(G,N,R,ret),
    PL = ic_util:mk_list(gen_par_list(G, N, X, ParameterTypes,ArgNames)),

    ic_codegen:emit(Fd, "/*\n"),
    ic_codegen:emit(Fd, " * Operation ~p interface functions \n", [ic_util:to_colon([OpName|N])]),
    ic_codegen:emit(Fd, " */\n\n"),

    ic_codegen:emit(Fd, "~s ~s(~s)\n",[RT, OpName, PL]),
    ic_codegen:emit(Fd, "     throws java.lang.Exception;\n\n\n"),

    emit_interface_prototypes(G, N, Xs, Fd);
emit_interface_prototypes(G, N, [X |Xs], Fd) when record(X, attr) ->
    ic_attribute_java:emit_attribute_prototype(G, N, X, Fd),
    emit_interface_prototypes(G, N, Xs, Fd);
emit_interface_prototypes(G, N, [_X|Xs], Fd) ->
    emit_interface_prototypes(G, N, Xs, Fd);
emit_interface_prototypes(_G, _N, [], _Fd) -> ok.




%%%-----------------------------------------------------
%%%
%%%  Holder file generation
%%%
%%%-----------------------------------------------------

emit_holder(_G, N, X, Fd) ->
    InterfaceName = ic_forms:get_java_id(X),
    FullInterfaceName = ic_util:to_dot([InterfaceName|N]),

    ic_codegen:emit(Fd, "public final class ~sHolder {\n\n",[InterfaceName]),
    
    ic_codegen:emit(Fd, "    // Instance variable\n"),
    ic_codegen:emit(Fd, "    public ~s value;\n\n",[FullInterfaceName]),

    ic_codegen:emit(Fd, "    // Constructors\n"),
    ic_codegen:emit(Fd, "    public ~sHolder() {\n",[InterfaceName]),
    ic_codegen:emit(Fd, "        this(null);\n"),
    ic_codegen:emit(Fd, "    }\n\n"),