ic_java_type.erl

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

%% ``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_java_type).


-include("icforms.hrl").
-include("ic.hrl").
-include("ic_debug.hrl").
%%-----------------------------------------------------------------
%% External exports
%%-----------------------------------------------------------------
-export([getType/3, getHolderType/3,
	 getParamType/4, inlinedTypes/2,
	 marshalFun/4, unMarshalFun/4, getFullType/4, 
	 getFullType/3, getMarshalType/4, getUnmarshalType/4,
	 getdim/1]).
-export([isBasicType/3, isBasicType/1]).
-export([isIntegerType/3, isIntegerType/1]).
-export([isTermType/3]).

%%-----------------------------------------------------------------
%% Internal exports
%%-----------------------------------------------------------------
-export([]).

%%-----------------------------------------------------------------
%% External functions
%%-----------------------------------------------------------------
%%-----------------------------------------------------------------
%% Func: getType/3
%%-----------------------------------------------------------------
getType(G, N, T) when record(T, scoped_id) ->
    {FullScopedName, _, TK, _} = ic_symtab:get_full_scoped_name(G, N, T),
    BT = ic_code:get_basetype(G, ic_util:to_dot(G,FullScopedName)), 
    case BT of
	"erlang.pid" ->
	    ?ICPACKAGE ++ "Pid";
	"erlang.port" ->
	    ?ICPACKAGE ++ "Port";
	"erlang.ref" ->
	    ?ICPACKAGE ++ "Ref";
	"erlang.term" ->
	    ?ICPACKAGE ++ "Term";
	{enum, Type} ->
	    getType(G, N, Type);
	Type -> 
	    case TK of
		{tk_array,_,_} ->
		    tk2type(G,N,T,TK);
		{tk_sequence,_,_} ->
		    tk2type(G,N,T,TK);
		tk_any ->
		    ?ICPACKAGE ++ "Any";
		_ ->
		    case isBasicType(G,N,TK) of
			true ->
			    tk2type(G,N,T,TK);
			false ->
			    Type %% Other types
		    end
	    end
    end;

getType(_G, _N, S) when list(S) ->
    S;

getType(_G, _N, T) when record(T, string) ->
    "java.lang.String";

getType(_G, _N, T) when record(T, wstring) ->  %% WSTRING
    "java.lang.String";

getType(G, N, T) when record(T, struct) ->
    ic_util:to_dot(G,[ic_forms:get_id2(T)|N]);

getType(G, N, T) when record(T, union) ->
    ic_util:to_dot(G,[ic_forms:get_id2(T)|N]);

getType(G, N, T) when record(T, sequence) ->
    getType(G, N, ic_forms:get_type(T)) ++ "[]";

getType(G, N, T) when record(T, enum) ->
    ic_util:to_dot(G,[ic_forms:get_id2(T)|N]);

%% NOTE i am using the new isJavaElementaryType
%% to avoid members declared as keywords (except
%% all java elementary types) to be used as a 
%% class
getType(G, N, T) when record(T, member) ->
    Type = tk2type(G,N,T,ic_forms:get_type_code(G, N, T)),
    case isJavaElementaryType(list_to_atom(Type)) of
	true ->
	    Type;
	false ->
	    Prefix = list_to_atom(lists:flatten(string:tokens(Type,"[]"))),
	    case isJavaElementaryType(Prefix) of %% Checks if Type is an array
		                                 %% of elementary java types
		true ->
		    Type;
		false -> 
		    ic_forms:get_java_id(getType(G,N,ic_forms:get_type(T))) ++
			if record(hd(T#member.id),array) ->
				arrayEmptyDim(hd(T#member.id));
			   true ->
				""
			end
	    end
    end;

getType(_G, _N, {boolean, _}) ->
    "boolean";

getType(_G, _N, {octet, _}) ->
    "byte";

getType(_G, _N, {void, _}) ->
    "void";

getType(_G, _N, {unsigned, U}) ->
    case U of
	{short,_} ->
	    "short";
	{long,_} ->
	    "int";
	{'long long',_} ->
	    "long"
    end;

getType(_G, _N, {char, _}) ->
    "char";

getType(_G, _N, {wchar, _}) ->  %% WCHAR 
    "char";

getType(_G, _N, {short, _}) ->
    "short";

getType(_G, _N, {long, _}) ->
    "int";

getType(_G, _N, {'long long', _}) ->
    "long";

getType(_G, _N, {float, _}) ->
    "float";

getType(_G, _N, {double, _}) ->
    "double";
    
getType(_G, _N, {any, _}) ->
    ?ICPACKAGE ++ "Any".






%%-----------------------------------------------------------------
%% Func: getHolderType/3
%%-----------------------------------------------------------------
getHolderType(G, N, T) when element(1, T) == scoped_id ->
    {FullScopedName, _, TK, _} = ic_symtab:get_full_scoped_name(G, N, T),
    BT = ic_code:get_basetype(G, ic_util:to_dot(G,FullScopedName)), 
    case BT of
	"erlang.pid" ->
	    ?ICPACKAGE ++ "PidHolder";
	"erlang.port" ->
	    ?ICPACKAGE ++ "PortHolder";
	"erlang.ref" ->
	    ?ICPACKAGE ++ "RefHolder";
	"erlang.term" ->
	    ?ICPACKAGE ++ "TermHolder";
	{enum, Type} ->
	    getHolderType(G, N, Type);
	
	Type ->
	    case TK of
		{'tk_struct', _, _, _} ->
		    Type ++ "Holder";

		{'tk_union', _, _, _, _, _} ->
		    Type ++ "Holder";

		{'tk_array', _ , _} ->
		    Type ++ "Holder";

		{'tk_sequence', _ , _} ->
		    Type ++ "Holder";

		{'tk_string', _} ->
		    ?ICPACKAGE ++ "StringHolder";

		{'tk_wstring', _} ->  %% WSTRING
		    ?ICPACKAGE ++ "StringHolder";

		{'tk_enum', _, _, _} ->
		    Type ++ "Holder";

		'tk_boolean' ->
		    ?ICPACKAGE ++ "BooleanHolder";
		
		'tk_octet' ->
		    ?ICPACKAGE ++ "ByteHolder";
		
		'tk_ushort' ->
		    ?ICPACKAGE ++ "ShortHolder";
		
		'tk_ulong' ->
		    ?ICPACKAGE ++ "IntHolder";
		
		'tk_ulonglong' ->               %% ULLONG
		    ?ICPACKAGE ++ "LongHolder";
		
		'tk_short' ->
		    ?ICPACKAGE ++ "ShortHolder";
		
		'tk_long' ->
		    ?ICPACKAGE ++ "IntHolder";

		'tk_longlong' ->
		    ?ICPACKAGE ++ "LongHolder"; %% LLONG
		
		'tk_float' ->
		    ?ICPACKAGE ++ "FloatHolder";
		
		'tk_double' ->
		    ?ICPACKAGE ++ "DoubleHolder";
		
		'tk_char' ->
		    ?ICPACKAGE ++ "CharHolder";

		'tk_wchar' ->                    %% WCHAR
		    ?ICPACKAGE ++ "CharHolder";

		'tk_any' ->
		    ?ICPACKAGE ++ "AnyHolder";

		_ ->
		    case isBasicType(G,N,TK) of
			true ->
			    %% Faked the type !
			    getHolderType(G, N, {list_to_atom(tk2type(G,N,T,TK)), -1}); 
			false ->
			    %%io:format("TK = ~p, Type = ~p\n",[TK,Type]),
			    ic_util:to_dot(G,FullScopedName) ++ "Holder"
		    end
	    end
    end;

getHolderType(G, N, S) when list(S) ->
    ic_util:to_dot(G,[S|N]) ++ "Holder";

getHolderType(_G, _N, T) when record(T, string) ->
    ?ICPACKAGE ++"StringHolder";

getHolderType(_G, _N, T) when record(T, wstring) ->  %% WSTRING
    ?ICPACKAGE ++"StringHolder";

getHolderType(G, N, T) when record(T, struct) ->
    ic_util:to_dot(G,[ic_forms:get_id2(T)|N]) ++ "Holder";

getHolderType(G, N, T) when record(T, union) ->
    ic_util:to_dot(G,[ic_forms:get_id2(T)|N]) ++ "Holder";

getHolderType(G, N, T) when record(T, array) ->
    ic_util:to_dot(G,[ic_forms:get_id2(T)|N]) ++ "Holder";

getHolderType(G, N, T) when record(T, sequence) ->
    getType(G, N, ic_forms:get_type(T)) ++ "Holder[]";

getHolderType(G, N, T) when record(T, enum) ->
    ic_util:to_dot(G,[ic_forms:get_id2(T)|N]) ++ "Holder";

getHolderType(_G, _N, {boolean, _}) ->
    ?ICPACKAGE ++"BooleanHolder";

getHolderType(_G, _N, {octet, _}) ->
    ?ICPACKAGE ++"ByteHolder";

getHolderType(_G, _N, {void, _}) ->
    "void";

getHolderType(_G, _N, {unsigned, U}) ->
    case U of
	{short,_} ->
	    ?ICPACKAGE ++"ShortHolder";
	{long,_} ->
	    ?ICPACKAGE ++"IntHolder";
	{'long long',_} ->
	    ?ICPACKAGE ++"LongHolder"
    end;

getHolderType(_G, _N, {char, _}) ->
    ?ICPACKAGE ++"CharHolder";

getHolderType(_G, _N, {wchar, _}) ->  %% WCHAR
    ?ICPACKAGE ++"CharHolder";

getHolderType(_G, _N, {short, _}) ->
    ?ICPACKAGE ++"ShortHolder";

getHolderType(_G, _N, {long, _}) ->
    ?ICPACKAGE ++"IntHolder";

getHolderType(_G, _N, {'long long', _}) ->
    ?ICPACKAGE ++"LongHolder";

getHolderType(_G, _N, {float, _}) ->
    ?ICPACKAGE ++"FloatHolder";

getHolderType(_G, _N, {double, _}) ->
    ?ICPACKAGE ++"DoubleHolder";

getHolderType(_G, _N, {any,_}) ->
    ?ICPACKAGE ++ "AnyHolder".


%%-----------------------------------------------------------------
%% Func: getParamType/4
%%-----------------------------------------------------------------
getParamType(G, N, S, in) ->
    getType(G, N, S);
getParamType(G, N, S, ret) ->
    getType(G, N, S);
getParamType(G, N, S, out) ->
    getHolderType(G, N, S);
getParamType(G, N, S, inout) ->
    getHolderType(G, N, S).


%%-----------------------------------------------------------------
%% Func: getUnmarshalType/4
%%-----------------------------------------------------------------
getUnmarshalType(G, N, X, T) when element(1, T) == scoped_id ->
    {FullScopedName, _, TK, _} = ic_symtab:get_full_scoped_name(G, N, T),
    BT = ic_code:get_basetype(G, ic_util:to_dot(G,FullScopedName)), 
    case BT of
	"erlang.pid" ->
	    ?ICPACKAGE ++ "PidHelper";
	"erlang.port" ->
	    ?ICPACKAGE ++ "PortHelper";
	"erlang.ref" ->
	    ?ICPACKAGE ++ "RefHelper";
	"erlang.term" ->
	    ?ICPACKAGE ++ "TermHelper";
	{enum, Type} ->
	    getUnmarshalType(G, N, X, Type);
	Type ->
	    case TK of
		{'tk_struct', _, _, _} ->
		    Type ++ "Helper";

		{'tk_union', _, _, _, _, _} ->
		    Type ++ "Helper";

		{'tk_sequence', _ , _} ->
		    Type ++ "Helper";

		{'tk_array', _ , _} ->
		    Type ++ "Helper";

		{'tk_enum', _, _, _} ->
		    Type ++ "Helper";

		{'tk_string',_} ->
		    ?ERLANGPACKAGE ++ "OtpErlangString";

		{'tk_wstring',_} ->                     %% WSTRING
		    ?ERLANGPACKAGE ++ "OtpErlangString";

		'tk_char' ->
		    ?ERLANGPACKAGE ++ "OtpErlangLong";

		'tk_wchar' ->                           %% WCHAR
		    ?ERLANGPACKAGE ++ "OtpErlangLong";

		'tk_octet' ->
		    ?ERLANGPACKAGE ++ "OtpErlangLong";
		
		'tk_ushort' ->
		    ?ERLANGPACKAGE ++ "OtpErlangLong";

		'tk_ulong' ->
		    ?ERLANGPACKAGE ++ "OtpErlangLong";

		'tk_ulonglong' ->                       %% ULLONG
		    ?ERLANGPACKAGE ++ "OtpErlangLong";