ic_jbe.erl

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

	true ->
	    ic_codegen:emit(Fd, "          ~s ~s = __is~s;  // In value\n",
			    [ic_java_type:getType(G,N,Type),
			     Arg,
			     ic_java_type:unMarshalFun(G,N,X,Type)]); 
	false -> 
	    ic_codegen:emit(Fd, "          ~s ~s = ~s.unmarshal(__is);  // In value\n",
			    [ic_java_type:getType(G,N,Type), 
			     Arg, 
			     ic_java_type:getUnmarshalType(G,N,X,Type)])
    end,
    emit_server_unmarshal_loop(G, N, X, Types, Args, Counter+1, Fd);
emit_server_unmarshal_loop(G, N, X, [Type|Types],[{inout, Arg}|Args], Counter, Fd) -> 
    Holder = ic_java_type:getHolderType(G,N,Type),
    case ic_java_type:isBasicType(G,N,Type) of
	true ->
%	    OtpEncVar = ic_java_type:getUnmarshalType(G,N,X,Type),
	    ic_codegen:emit(Fd, "          ~s _~s = __is~s;\n",
			    [ic_java_type:getType(G,N,Type),
			     Arg,
			     ic_java_type:unMarshalFun(G,N,X,Type)]),
	    ic_codegen:emit(Fd, "          ~s ~s = new ~s(_~s);  // InOut value\n",
			    [Holder, 
			     Arg, 
			     Holder,
			     Arg]);
	false ->
	    ic_codegen:emit(Fd, "          ~s ~s = new ~s();  // InOut value\n",
			    [Holder, 
			     Arg, 
			     Holder]),
	    ic_codegen:emit(Fd, "          ~s._unmarshal(__is);\n",
			    [Arg])
    end,
    emit_server_unmarshal_loop(G, N, X, Types, Args, Counter+1, Fd);
emit_server_unmarshal_loop(G, N, X, [Type|Types],[{out, Arg}|Args], Counter, Fd) ->
    Holder = ic_java_type:getHolderType(G,N,Type),
    ic_codegen:emit(Fd, "          ~s ~s = new ~s();  // Out value\n", [Holder, Arg, Holder]),
    emit_server_unmarshal_loop(G, N, X, Types, Args, Counter, Fd).


emit_server_marshal_loop(_,_,_,_,[],_,_Fd) ->
    ok;
emit_server_marshal_loop(G, N, X, [_Type|Types],[{in, _Arg}|Args], Counter, Fd) ->
    emit_server_marshal_loop(G, N, X, Types, Args, Counter, Fd);
emit_server_marshal_loop(G, N, X, [Type|Types],[{_, Arg}|Args], Counter, Fd) -> 
%    Holder = ic_java_type:getHolderType(G,N,Type),
    case ic_java_type:isBasicType(G,N,Type) of
	true ->
	    ic_codegen:emit(Fd, "          __os~s(~s.value);  // Out/InOut value\n", 
			    [ic_java_type:marshalFun(G,N,X,Type),Arg]);
	false ->
	    ic_codegen:emit(Fd, "          ~s._marshal(__os);  // Out/InOut value\n", 
			    [Arg])
    end,
    emit_server_marshal_loop(G, N, X, Types, Args, Counter+1, Fd).





%%%----------------------------------------------------
%%%
%%%   Utilities
%%%
%%%----------------------------------------------------

extract_info(_G, N, X) when record(X, op) ->
    Name	=  ic_util:to_undersc([ic_forms:get_id2(X) | N]),
    Args	= X#op.params,
    ArgNames	= mk_c_vars(Args),
    TypeList	= {ic_forms:get_type(X),
		   lists:map(fun(Y) -> ic_forms:get_type(Y) end, Args),
		   []
		  },
    {Name, ArgNames, TypeList};
extract_info(_G, N, X) ->
    Name	=  ic_util:to_undersc([ic_forms:get_id2(X) | N]),
    {Name, [], []}.

%% Input is a list of parameters (in parse form) and output is a list
%% of parameter attribute and variable names.
mk_c_vars(Params) ->
    lists:map(fun(P) -> {A, _} = P#param.inout,
			{A, ic_forms:get_id(P#param.id)}
	      end,
	      Params).

%%
handle_preproc(G, _N, line_nr, X) ->
    Id = ic_forms:get_java_id(X),
    Flags = X#preproc.aux,
    case Flags of
	[] -> ic_genobj:push_file(G, Id);
	_ ->
	    lists:foldr(fun({_, _, "1"}, Gprim) -> ic_genobj:push_file(Gprim, Id);
			   ({_, _, "2"}, Gprim) -> ic_genobj:pop_file(Gprim, Id);
			   ({_, _, "3"}, Gprim) -> ic_genobj:sys_file(Gprim, Id) end,
			G, Flags)
    end;
handle_preproc(G, _N, _Other, _X) ->
    G.


%%
gen_par_list(_, _, _, [], []) ->
    [];
gen_par_list(G, N, X, [Type |Types], [{Attr, Arg}|Args]) ->
    JType = ic_java_type:getParamType(G, N, Type, Attr),
    [JType ++ " " ++ Arg | 
     gen_par_list(G, N, X, Types, Args)].


gen_marshal_par_list(_, _, _, [], []) ->
    [];
gen_marshal_par_list(G, N, X, [_Type |Types], [{out, _Arg}|Args]) ->
    gen_marshal_par_list(G, N, X, Types, Args);
gen_marshal_par_list(G, N, X, [Type |Types], [{Attr, Arg}|Args]) ->
    JType = ic_java_type:getParamType(G, N, Type, Attr),
    [JType ++ " " ++ Arg | 
     gen_marshal_par_list(G, N, X, Types, Args)].


gen_unmarshal_par_list(_, _, _, [], []) ->
    [];
gen_unmarshal_par_list(G, N, X, [_Type |Types], [{in, _Arg}|Args]) ->
    gen_unmarshal_par_list(G, N, X, Types, Args);
gen_unmarshal_par_list(G, N, X, [Type |Types], [{Attr, Arg}|Args]) ->
    JType = ic_java_type:getParamType(G, N, Type, Attr),
    [JType ++ " " ++ Arg | 
     gen_unmarshal_par_list(G, N, X, Types, Args)].


%%
gen_client_marshal_call_par_list([]) ->
    [];
gen_client_marshal_call_par_list([{out, _Arg}|Args]) ->
    gen_client_marshal_call_par_list(Args);
gen_client_marshal_call_par_list([{_Attr, Arg}|Args]) ->
    [Arg | gen_client_marshal_call_par_list(Args)].


gen_client_unmarshal_call_par_list([]) ->
    [];
gen_client_unmarshal_call_par_list([{in, _Arg}|Args]) ->
    gen_client_unmarshal_call_par_list(Args);
gen_client_unmarshal_call_par_list([{_Attr, Arg}|Args]) ->
    [Arg | gen_client_unmarshal_call_par_list(Args)].



count_client_receive(ArgNames) ->
    count_client_receive(ArgNames,0).

count_client_receive([],C) ->
    C;
count_client_receive([{in, _Arg}|Args],C) ->
    count_client_receive(Args,C);
count_client_receive([_|Args],C) ->
    count_client_receive(Args,C+1).



count_client_send(ArgNames) ->
    count_client_send(ArgNames,0).

count_client_send([],C) ->
    C;
count_client_send([{out, _Arg}|Args],C) ->
    count_client_send(Args,C);
count_client_send([_|Args],C) ->
    count_client_send(Args,C+1).


gen_cb_arg_list([]) ->
    [];
gen_cb_arg_list([{_Attr, Arg}|Args]) ->
    [Arg | gen_cb_arg_list(Args)].


count_server_receive(ArgNames) ->
    count_server_receive(ArgNames,0).

count_server_receive([],C) ->
    C;
count_server_receive([_|Args],C) ->
    count_server_receive(Args,C+1).


count_server_send(ArgNames) ->
    count_server_send(ArgNames,0).

count_server_send([],C) ->
    C;
count_server_send([{in, _Arg}|Args],C) ->
    count_server_send(Args,C);
count_server_send([_|Args],C) ->
    count_server_send(Args,C+1).





%%%-------------------------------------------------------


emit_type_function(G, N, X, Fd) ->

    TC = ic_forms:get_type_code(G, N, X),

    %%io:format("X = ~p\nTC = ~p\n",[X,TC]),

    ic_codegen:emit(Fd, "   private static ~sTypeCode _tc;\n",[?ICPACKAGE]),
    ic_codegen:emit(Fd, "   synchronized public static ~sTypeCode type() {\n\n",[?ICPACKAGE]),

    ic_codegen:emit(Fd, "     if (_tc != null)\n"),
    ic_codegen:emit(Fd, "       return _tc;\n\n"),

    emit_type_function(TC, 0, Fd),
    
    ic_codegen:emit(Fd, "\n     _tc = _tc0;\n"),

    ic_codegen:emit(Fd, "\n     return _tc0;\n"),
    ic_codegen:emit(Fd, "   }\n\n").
    

	
emit_type_function({tk_struct, ID, Name, ML}, C, Fd) -> %% struct
    ic_codegen:emit(Fd, "     ~sTypeCode _tc~p =\n",[?ICPACKAGE,C]),
    ic_codegen:emit(Fd, "       new ~sTypeCode();\n", [?ICPACKAGE]),
    ic_codegen:emit(Fd, "     _tc~p.kind(~sTCKind.tk_struct);\n", [C,?ICPACKAGE]),
    ic_codegen:emit(Fd, "     _tc~p.id(~p);\n", [C,ID]),
    ic_codegen:emit(Fd, "     _tc~p.name(~p);\n", [C,Name]),
    ic_codegen:emit(Fd, "     _tc~p.member_count(~p);\n", [C,length(ML)]),
    emit_struct_members(ML, C, C+1, 0, Fd);

emit_type_function({tk_enum, ID, Name, MNames}, C, Fd) -> %% enum
    ic_codegen:emit(Fd, "     ~sTypeCode _tc~p =\n",[?ICPACKAGE,C]),
    ic_codegen:emit(Fd, "       new ~sTypeCode();\n", [?ICPACKAGE]),
    ic_codegen:emit(Fd, "     _tc~p.kind(~sTCKind.tk_enum);\n", [C,?ICPACKAGE]),
    ic_codegen:emit(Fd, "     _tc~p.id(~p);\n", [C,ID]),
    ic_codegen:emit(Fd, "     _tc~p.name(~p);\n", [C,Name]),
    ic_codegen:emit(Fd, "     _tc~p.member_count(~p);\n", [C,length(MNames)]),
    emit_enum_members(MNames, C, 0, Fd),
    C+1;

emit_type_function({tk_array, ET, L}, C, Fd) -> %% array
    ic_codegen:emit(Fd, "     ~sTypeCode _tc~p =\n",[?ICPACKAGE,C]),
    ic_codegen:emit(Fd, "       new ~sTypeCode();\n", [?ICPACKAGE]),
    ic_codegen:emit(Fd, "     _tc~p.kind(~sTCKind.tk_array);\n", [C,?ICPACKAGE]),
    ic_codegen:emit(Fd, "     _tc~p.id(id());\n",[C]),
    ic_codegen:emit(Fd, "     _tc~p.length(~p);\n", [C,L]),
    C1 = C+1,
    C2 = emit_type_function(ET, C1, Fd),
    ic_codegen:emit(Fd, "     _tc~p.content_type(_tc~p);\n", [C,C1]),
    C2;

emit_type_function({tk_sequence, ET, L}, C, Fd) -> %% sequence 
    ic_codegen:emit(Fd, "     ~sTypeCode _tc~p =\n",[?ICPACKAGE,C]),
    ic_codegen:emit(Fd, "       new ~sTypeCode();\n", [?ICPACKAGE]),
    ic_codegen:emit(Fd, "     _tc~p.kind(~sTCKind.tk_sequence);\n", [C,?ICPACKAGE]),
    ic_codegen:emit(Fd, "     _tc~p.id(id());\n",[C]),
    ic_codegen:emit(Fd, "     _tc~p.length(~p);\n", [C,L]),
    C1 = C+1,
    C2 = emit_type_function(ET, C1, Fd),
    ic_codegen:emit(Fd, "     _tc~p.content_type(_tc~p);\n", [C,C1]),
    C2;

emit_type_function({tk_string, L}, C, Fd) -> %% string
    ic_codegen:emit(Fd, "     ~sTypeCode _tc~p =\n",[?ICPACKAGE,C]),
    ic_codegen:emit(Fd, "       new ~sTypeCode();\n", [?ICPACKAGE]),
    ic_codegen:emit(Fd, "     _tc~p.kind(~sTCKind.tk_string);\n", [C,?ICPACKAGE]),
    ic_codegen:emit(Fd, "     _tc~p.length(~p);\n", [C,L]),
    C+1;	     

emit_type_function({tk_union, ID, Name, DT, DI, LL}, C, Fd) -> %% union
    
    ic_codegen:emit(Fd, "     ~sTypeCode _tc~p =\n",[?ICPACKAGE,C]),
    ic_codegen:emit(Fd, "       new ~sTypeCode();\n", [?ICPACKAGE]),
    ic_codegen:emit(Fd, "     _tc~p.kind(~sTCKind.tk_union);\n", [C,?ICPACKAGE]),
    ic_codegen:emit(Fd, "     _tc~p.id(~p);\n", [C,ID]),
    ic_codegen:emit(Fd, "     _tc~p.name(~p);\n", [C,Name]),
    
    C1 = C+1,
    C2 = emit_type_function(DT, C1, Fd),

    ic_codegen:emit(Fd, "     _tc~p.discriminator_type(_tc~p);\n", [C,C1]),
    ic_codegen:emit(Fd, "     _tc~p.default_index(~p);\n", [C,DI]),
    ic_codegen:emit(Fd, "     _tc~p.member_count(~p);\n", [C,length(LL)]),

    emit_union_labels(LL, C, DT, C2, 0, Fd);

emit_type_function(tk_term, C, Fd) -> %% term, must change it to tk_any
    ic_codegen:emit(Fd, "     ~sTypeCode _tc~p =\n",[?ICPACKAGE,C]),
    ic_codegen:emit(Fd, "       new ~sTypeCode();\n", [?ICPACKAGE]),
    ic_codegen:emit(Fd, "     _tc~p.kind(~sTCKind.tk_any);\n", [C,?ICPACKAGE]),
    C+1;

emit_type_function(TC, C, Fd) -> %% other 
    ic_codegen:emit(Fd, "     ~sTypeCode _tc~p =\n",[?ICPACKAGE,C]),
    ic_codegen:emit(Fd, "       new ~sTypeCode();\n", [?ICPACKAGE]),
    ic_codegen:emit(Fd, "     _tc~p.kind(~sTCKind.~p);\n", [C,?ICPACKAGE,TC]),
    C+1.



emit_struct_members([], _, TCtr, _, _Fd) -> 
    TCtr;
emit_struct_members([{Name,MT}|Rest], BTCtr, TCtr, I, Fd) ->
    ic_codegen:emit(Fd, "     _tc~p.member_name(~p,~p);\n", [BTCtr,I,Name]),
    TCtr2 = emit_type_function(MT, TCtr, Fd),
    ic_codegen:emit(Fd, "     _tc~p.member_type(~p,_tc~p);\n", [BTCtr,I,TCtr]),
    emit_struct_members(Rest, BTCtr, TCtr2, I+1, Fd).

emit_enum_members([], _, _, _Fd) -> 
    ok;
emit_enum_members([Name|Names], BTCtr, I, Fd) ->
    ic_codegen:emit(Fd, "     _tc~p.member_name(~p,~p);\n", [BTCtr,I,Name]),
    emit_enum_members(Names, BTCtr, I+1, Fd).


emit_union_labels([], _, _, TCtr, _, _) -> 
    TCtr;
emit_union_labels([{L, LN, LT}|Rest], BTCtr, DT, TCtr, I, Fd) ->
    ic_codegen:emit(Fd, "     ~sAny _any~p =\n",[?ICPACKAGE,TCtr]),
    ic_codegen:emit(Fd, "       new ~sAny();\n", [?ICPACKAGE]),
    TCtr1 = TCtr+1,
    TCtr2 = emit_type_function(LT, TCtr1,Fd),
    ic_codegen:emit(Fd, "     _any~p.type(_tc~p);\n",[TCtr,TCtr1]),

    case L of
	default ->
	    ic_codegen:emit(Fd, "     _any~p.insert_atom(\"default\");\n", [TCtr]);
	_ ->
	    case DT of
		tk_boolean ->
		    ic_codegen:emit(Fd, "     _any~p.insert_boolean(~p);\n",[TCtr,L]);
		tk_char ->
		    Default = if integer(L) ->
				      [L];
				 true ->
				      L
			      end,
		    ic_codegen:emit(Fd, "     _any~p.insert_char('~s');\n",[TCtr,Default]);
		tk_ushort ->
		    ic_codegen:emit(Fd, "     _any~p.insert_ushort(~p);\n",[TCtr,L]);
		tk_ulong ->
		    ic_codegen:emit(Fd, "     _any~p.insert_ulong(~p);\n",[TCtr,L]);
		tk_short ->
		    ic_codegen:emit(Fd, "     _any~p.insert_short(~p);\n",[TCtr,L]);
		tk_long ->
		    ic_codegen:emit(Fd, "     _any~p.insert_long(~p);\n",[TCtr,L]);
		_ ->
		    ic_codegen:emit(Fd, "     _any~p.insert_string(~p);\n", [TCtr,L])
	    end
    end,
    ic_codegen:emit(Fd, "     _tc~p.member_label(~p,_any~p);\n", [BTCtr,I,TCtr]),
    ic_codegen:emit(Fd, "     _tc~p.member_name(~p,~p);\n", [BTCtr,I,LN]),
    TCtr3 = emit_type_function(LT, TCtr2, Fd),
    ic_codegen:emit(Fd, "     _tc~p.member_type(~p,_tc~p);\n", [BTCtr,I,TCtr2]),
    emit_union_labels(Rest, BTCtr, DT, TCtr3, I+1, Fd).