ic_java_type.erl

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

    ".read_char()".





%%-----------------------------------------------------------------
%% Func: getFullType/4 - /3
%%
%% Note : Similar to the getType/3 with the major difference 
%%        thet on arrays and sequences it will also declare
%%        their sizes. Used for "new" declarations
%%
%%-----------------------------------------------------------------


getFullType(G, N, X, T) when record(X, typedef), record(T, array) -> 
    FullDim = 
	tk2FullType(G,N,X,ic_forms:get_tk(X)) ++
	getFullDim(G,N,T#array.size),
    fixArrayDims(FullDim);

getFullType(G, N, X, T) when record(X, member), record(T, array) -> 
    FullDim = 
	getFullType(G, N, ic_forms:get_type(X)) ++ 
	getFullDim(G,N,T#array.size),
    fixArrayDims(FullDim);

getFullType(G, N, X, T) when record(X, case_dcl), record(T, array) -> 
    FullDim = 
	getFullType(G, N, ic_forms:get_type(X)) ++ 
	getFullDim(G,N,T#array.size),
    fixArrayDims(FullDim);

getFullType(G, N, _X, T)  ->
    getFullType(G, N, T).



getFullType(G, N, T) when record(T, scoped_id) ->
    {FullScopedName, _, TK, _} = ic_symtab:get_full_scoped_name(G, N, T),
    case TK of
	{tk_array,_,_} ->
	    tk2FullType(G,N,T,TK);
	{tk_sequence,_,_} ->
	    tk2FullType(G,N,T,TK);
	_ ->
	    case isBasicType(G,N,TK) of
		true ->
		    tk2FullType(G,N,T,TK);
		false ->
		    %% Other types
		    ic_code:get_basetype(G, ic_util:to_dot(G,FullScopedName)) 
	    end
    end;

getFullType(G, N, T) when record(T, sequence) ->
    fixSeqDims(getType(G,N,T),"_length");

getFullType(G, N, T)  ->
    getType(G, N, T).



%% In order to make a legal declaration 
%% of an assignable array, the dimensions 
%% of empty array sequences are swifted to 
%% the end of the type
fixArrayDims(Cs) ->
    fixArrayDims(Cs,[],[]).

fixArrayDims([],Fulls,Emptys) ->
    lists:reverse(Fulls) ++ Emptys;
fixArrayDims([91,93|Rest],Fulls,Emptys) ->
    fixArrayDims(Rest,Fulls,[91,93|Emptys]);
fixArrayDims([C|Rest],Fulls,Emptys) ->
    fixArrayDims(Rest,[C|Fulls],Emptys).


%% In order to make a legal declaration 
%% of an assignable array, the dimensions 
%% of empty array of sequences are swifted 
%% to the end of the type
fixSeqDims(Cs,Length) ->
    fixSeqDims(Cs,Length,[]).

fixSeqDims([],_Length,Found) ->
    lists:reverse(Found);
fixSeqDims([91,93|Rest],Length,Found) when list(Length) ->
    lists:reverse([93|lists:reverse(Length)] ++ 
		  [91|Found]) ++ Rest;
fixSeqDims([C|Rest],Length,Found) ->
    fixSeqDims(Rest,Length,[C|Found]).


  
%%-----------------------------------------------------------------
%% Func: inlinedTypes/2
%%-----------------------------------------------------------------
inlinedTypes(PkgName, Type) when record(Type, struct) ->
    "_" ++ PkgName ++ ".";
inlinedTypes(PkgName, Type) when record(Type, union) ->
    "_" ++ PkgName ++ ".";
inlinedTypes(PkgName, Type) when record(Type, enum) ->
    "_" ++ PkgName ++ ".";
inlinedTypes(_, _) ->
    "".

%%-----------------------------------------------------------------
%% Func: marshalFun/4
%%-----------------------------------------------------------------
marshalFun(G, N, X, Type) ->
    case isBasicType(G, N, Type) of
	true ->
	    ".write_" ++ getMarshalType(G, N, X, Type);
	_ ->
	    getMarshalType(G, N, X, Type) ++ ".marshal"
    end.


%%-----------------------------------------------------------------
%% Func: isBasicType/3
%%-----------------------------------------------------------------
isBasicType(G, N, S) when element(1, S) == scoped_id -> 
    {_, _, TK, _} = ic_symtab:get_full_scoped_name(G, N, S),
    isBasicType(ictype:fetchType(TK));

isBasicType(G, N, X) when record(X, member) ->
    if record(hd(element(3,X)), array) ->
	    false;
       true ->
	    isBasicType(G, N, element(2,X))
    end;

isBasicType(_G, _N, {unsigned, {long, _}} ) -> 
    true;

isBasicType(_G, _N, {unsigned, {short, _}} ) -> 
    true;

isBasicType(_G, _N, {unsigned, {'long long', _}} ) -> 
    true;

isBasicType(_G, _N, {'long long', _} ) -> 
    true;

isBasicType(_G, _N, {Type, _} ) -> 
    isBasicType(Type);

isBasicType(_G, _N, Type) ->
    isBasicType(Type).


%%-----------------------------------------------------------------
%% Func: isBasicType/1
%%-----------------------------------------------------------------

isBasicType( Type ) ->
    lists:member(Type,
		 [tk_short,short,
		  tk_long,long,
		  tk_longlong,longlong,  %% LLONG
		  tk_ushort,ushort,
		  tk_ulong,ulong,
		  tk_ulonglong,ulonglong,  %% ULLONG
		  tk_float,float,
		  tk_double,double,
		  tk_boolean,boolean,
		  tk_char,char,
		  tk_wchar,wchar,         %% WCHAR
		  tk_octet,octet,
		  tk_wstring,wstring,     %% WSTRING
		  tk_string,string]).

%% returns true if the Type is a java elementary type
isJavaElementaryType( Type ) ->
    lists:member(Type,
		 [byte, char, wchar, boolean, 
		  int, short, long, 'long long', float, double]).

%%-----------------------------------------------------------------
%% Func: isIntegerType/3
%%-----------------------------------------------------------------
isIntegerType(G, N, S) when element(1, S) == scoped_id -> 
    {_, _, TK, _} = ic_symtab:get_full_scoped_name(G, N, S),
    isIntegerType(ictype:fetchType(TK));
isIntegerType(_G, _N, {unsigned, {long, _}} ) -> 
    true;
isIntegerType(_G, _N, {unsigned, {short, _}} ) -> 
    true;
isIntegerType(_G, _N, {unsigned, {'long long', _}} ) -> 
    true;
isIntegerType(_G, _N, {'long long', _} ) -> 
    true;
isIntegerType(_G, _N, {Type, _} ) -> 
    isIntegerType(Type);
isIntegerType(_G, _N, Type) ->
    isIntegerType(Type).

%%-----------------------------------------------------------------
%% Func: isIntegerType/1
%%-----------------------------------------------------------------

isIntegerType( Type ) ->
    lists:member(Type,
		 [tk_short,short,
		  tk_long,long,
		  tk_longlong,longlong,    %% LLONG
		  tk_ushort,ushort,
		  tk_ulong,ulong,
		  tk_ulonglong,ulonglong,  %% ULLONG
		  tk_char,char,
		  tk_wchar,wchar,          %% WCHAR 
		  tk_octet,octet]).



%%-----------------------------------------------------------------
%% Func: isTerm/3
%%-----------------------------------------------------------------
isTermType(G, N, T) ->
    case getType(G,N,T) of
	"com.ericsson.otp.ic.Term" ->
	    true;
	_ ->
	    false
    end.




%%-----------------------------------------------------------------
%% Internal functions
%%-----------------------------------------------------------------


%% Changes the typecode to the 
%% corresponding "basic" type
tk2type(_G,_N,_X,{'tk_struct', _IFRId, "port", _ElementList}) ->
    ?ICPACKAGE ++ "Port";
tk2type(_G,_N,_X,{'tk_struct', _IFRId, "pid", _ElementList}) ->
    ?ICPACKAGE ++ "Pid";
tk2type(_G,_N,_X,{'tk_struct', _IFRId, "ref", _ElementList}) ->
    ?ICPACKAGE ++ "Ref";
tk2type(_G,_N,_X,{'tk_struct', _IFRId, "term", _ElementList}) ->
    ?ICPACKAGE ++ "Term";
tk2type(_G,_N,_X,{'tk_string', _}) -> 
    "java.lang.String";
tk2type(_G,_N,_X,{'tk_wstring', _}) ->  %% WSTRING 
    "java.lang.String";
tk2type(G,N,X,{'tk_array', ElemTC, Dim}) -> 
    tkarr2decl(G,N,X,{'tk_array', ElemTC, Dim});
tk2type(G,N,X,{'tk_sequence', ElemTC, MaxLsextractength}) -> 
    tkseq2decl(G,N,X,{'tk_sequence', ElemTC, MaxLsextractength});
tk2type(G,N,_X,{'tk_struct', IFRId, Name, _ElementList}) ->
    ScopedId=
	lists:reverse(string:tokens(lists:nth(2,string:tokens(IFRId,":")),"/")),

    case ic_forms:clean_up_scope([Name|N]) of
	ScopedId ->
	    %% Right path, use N instead
	    ic_util:to_dot(G,[Name|N]);
	_ ->
	    %% Ugly work arround 
	    ic_util:to_dot(G,ScopedId)
    end;
tk2type(G,N,_X,{'tk_union', IFRId, Name, _, _, _ElementList}) ->
    ScopedId=
	lists:reverse(string:tokens(lists:nth(2,string:tokens(IFRId,":")),"/")),

    case ic_forms:clean_up_scope([Name|N]) of
	ScopedId ->
	    %% Right path, use N instead
	    ic_util:to_dot(G,[Name|N]);
	_ ->
	    %% Ugly work arround 
	    ic_util:to_dot(G,ScopedId)
    end;
tk2type(_G,_N,_X,{'tk_enum', _Id, Name, _ElementList}) -> 
    Name;
tk2type(_G,_N,_X,tk_void) ->
    "void";
tk2type(_G,_N,_X,tk_long) ->
    "int";
tk2type(_G,_N,_X,tk_longlong) ->  %% LLONG
    "long";
tk2type(_G,_N,_X,tk_short) ->
    "short";
tk2type(_G,_N,_X,tk_ulong) ->
    "int";
tk2type(_G,_N,_X,tk_ulonglong) ->  %% ULLONG
    "long";
tk2type(_G,_N,_X,tk_ushort) ->
    "short";
tk2type(_G,_N,_X,tk_float) ->
    "float";
tk2type(_G,_N,_X,tk_double) ->
    "double";
tk2type(_G,_N,_X,tk_boolean) ->
    "boolean";
tk2type(_G,_N,_X,tk_char) ->
    "char";
tk2type(_G,_N,_X,tk_wchar) ->   %% WCHAR
    "char";
tk2type(_G,_N,_X,tk_octet) ->
    "byte";
tk2type(_G,_N,_X,tk_string) ->
    "java.lang.String";
tk2type(_G,_N,_X,tk_wstring) ->  %% WSTRING
    "java.lang.String";
tk2type(_G,_N,_X,tk_any) ->
    ?ICPACKAGE ++ "Any";
tk2type(_G,_N,_X,tk_term) ->     %% Term
    ?ICPACKAGE ++ "Term".

%% Changes the sequence typecode to the 
%% corresponding "basic" structure
tkseq2decl(G,N,X,TKSeq) ->
    tkseq2decl2(G,N,X,TKSeq,[],[]).

tkseq2decl2(G,N,X,{tk_sequence,E,D},[],Ds) ->
    tkseq2decl2(G,N,X,E,[],[D|Ds]);
tkseq2decl2(G,N,X,TkEl,[],Ds) ->
    ElName = tk2type(G,N,X,TkEl),
    ElName ++ getdim(Ds).

%% Changes the array typecode to the 
%% corresponding "basic" structure
tkarr2decl(G,N,X,TKArr) ->
    tkarr2decl2(G,N,X,TKArr,[],[]).

tkarr2decl2(G,N,X,{tk_array,E,D},[],Ds) ->
    tkarr2decl2(G,N,X,E,[],[D|Ds]);
tkarr2decl2(G,N,X,TkEl,[],Ds) ->
    ElName = tk2type(G,N,X,TkEl),
    ElName ++ getdim(Ds).

getdim([]) ->
    "";
getdim([_D|Ds]) ->
    getdim(Ds) ++ "[]".



%% Changes the typecode to the corresponding "basic" type
%% used for variable declarations where arrays and sequences 
%% are declared with there full dimensions 
tk2FullType(G,N,X,{'tk_array', ElemTC, Dim}) -> 
    tkarr2FullDecl(G,N,X,{'tk_array', ElemTC, Dim});
tk2FullType(G,N,X,{'tk_sequence', ElemTC, MaxLsextractength}) -> 
    tkseq2FullDecl(G,N,X,{'tk_sequence', ElemTC, MaxLsextractength});
tk2FullType(G,N,X,TK) ->
    tk2type(G,N,X,TK).


%% Changes the sequence typecode to the 
%% corresponding "basic" structure here
%% arrays and sequences are declared with 
%% their full dimensions 
tkseq2FullDecl(G,N,X,TKSeq) ->
    tkseq2FullDecl2(G,N,X,TKSeq,[],[]).

tkseq2FullDecl2(G,N,X,{tk_sequence,E,D},[],Ds) ->
    tkseq2FullDecl2(G,N,X,E,[],[D|Ds]);
tkseq2FullDecl2(G,N,X,TkEl,[],Ds) ->
    ElName = tk2FullType(G,N,X,TkEl),
    ElName ++ getdim(Ds).

%% Changes the array typecode to the 
%% corresponding "basic" structure
tkarr2FullDecl(G,N,X,TKArr) ->
    tkarr2FullDecl2(G,N,X,TKArr,[],[]).

tkarr2FullDecl2(G,N,X,{tk_array,E,D},[],Ds) ->
    tkarr2FullDecl2(G,N,X,E,[],[D|Ds]);
tkarr2FullDecl2(G,N,X,TkEl,[],Ds) ->
    ElName = tk2FullType(G,N,X,TkEl),
    ElName ++ getFullDim(G,N,Ds).

getFullDim(_G,_N,[]) ->
    "";
getFullDim(G,N,[D|Ds]) when record(D,scoped_id) ->
    {FSN, _, _, _} = ic_symtab:get_full_scoped_name(G, N, D),
    "[" ++ ic_util:to_dot(G,FSN) ++ "]" ++ getFullDim(G,N,Ds);
getFullDim(G,N,[D|Ds]) when integer(D) ->
    "[" ++ integer_to_list(D) ++ "]" ++ getFullDim(G,N,Ds);
getFullDim(G,N,[D|Ds]) when tuple(D) ->
    "[" ++ ic_util:eval_java(G,N,D) ++ "]" ++ getFullDim(G,N,Ds).



%% Constructs an array empty dimension string
%% used for array variable declaration
arrayEmptyDim(X) ->
    arrayEmptyDim2(X#array.size).

arrayEmptyDim2([_D]) ->
    "[]";
arrayEmptyDim2([_D |Ds]) ->
    "[]" ++ arrayEmptyDim2(Ds).