You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
346 lines
11 KiB
346 lines
11 KiB
include yslt.yml2
|
|
|
|
tstylesheet {
|
|
include ./textutils.ysl2
|
|
include ./types_java.ysl2
|
|
|
|
template "/namespace[@name='pEp']" apply "interface", 0;
|
|
|
|
template "interface" {
|
|
const "cname" call "toJava" with "type", "@name";
|
|
document("foundation/pEp/jniadapter/{$cname}.java", "text")
|
|
||
|
|
package foundation.pEp.jniadapter;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Vector;
|
|
|
|
final public class «$cname» extends AbstractEngine {
|
|
public «$cname»() throws pEpException { }
|
|
|
|
`` apply "method", mode=plain
|
|
`` apply "basic"
|
|
}
|
|
|
|
||
|
|
}
|
|
|
|
template "basic" {
|
|
const "itype" call "toIntermediate" with "type", "@type";
|
|
const "jtype" call "toJava" with "type", "@type";
|
|
|
|
choose {
|
|
when "name(parm/*[1])='bytearray|identitylist'"
|
|
||
|
|
public native «$itype» «@name»(`apply "parm/*", mode=basic_iparm`);
|
|
|
|
||
|
|
otherwise {
|
|
||
|
|
private native «$itype» _«@name»(`apply "parm/*", mode=basic_iparm`);
|
|
|
|
public «$jtype» «@name»(`apply "parm/*", mode=basic_parm`) {
|
|
||
|
|
apply "parm/*", mode=basic_parm_set;
|
|
choose {
|
|
when "@type = 'void'"
|
|
|> _«@name»(`apply "parm/*", mode=basic_parm_name`);
|
|
when "@type = 'identity'"
|
|
|> return new Identity(_«@name»(`apply "parm/*", mode=basic_parm_name`));
|
|
when "@type = 'bool'"
|
|
|> return new Boolean(_«@name»(`apply "parm/*", mode=basic_parm_name`));
|
|
when "@type = 'identitylist'" {
|
|
||
|
|
Vector<_Identity> glist = _«@name»(`apply "parm/*", mode=basic_parm_name`);
|
|
Vector<Identity> ret = new Vector<Identity>();
|
|
if(glist != null) {
|
|
for (_Identity i : glist) {
|
|
ret.add(new Identity(i));
|
|
}
|
|
}
|
|
return ret;
|
|
||
|
|
} otherwise
|
|
|> return AbstractEngine.toUTF16(_«@name»(`apply "parm/*", mode=basic_parm_name`));
|
|
}
|
|
||
|
|
}
|
|
|
|
||
|
|
}
|
|
}
|
|
}
|
|
|
|
template "*", mode=basic_parm_name choose {
|
|
when "position() mod 2" {
|
|
if "position() = 1 and name(.)='int'"
|
|
> 23,
|
|
if "position() > 1" > ,
|
|
}
|
|
otherwise {
|
|
> _«name(.)»
|
|
}
|
|
}
|
|
|
|
template "*", mode=basic_parm choose {
|
|
when "position() mod 2" {
|
|
if "position() > 1" > ,
|
|
choose {
|
|
when "name(.) = 'string'"
|
|
> String
|
|
when "name(.) = 'identity'"
|
|
> Identity
|
|
when "name(.) = 'identitylist'"
|
|
> IdentityList
|
|
when "name(.) = 'bool'"
|
|
> Boolean
|
|
when "name(.) = 'bytearray'"
|
|
> byte[]
|
|
otherwise
|
|
> «name(.)»
|
|
}
|
|
}
|
|
otherwise {
|
|
> «name(.)»
|
|
}
|
|
}
|
|
|
|
template "*", mode=basic_iparm choose {
|
|
when "position() mod 2" {
|
|
const "pitype" call "toIntermediate" with "type", "name(.)";
|
|
if "position() = 1 and name(.)='int'"
|
|
> int dummy,
|
|
if "position() > 1" > ,
|
|
> «$pitype»
|
|
}
|
|
otherwise {
|
|
> «name(.)»
|
|
}
|
|
}
|
|
|
|
template "*", mode=basic_parm_set {
|
|
const "ptype", "name(preceding-sibling::*[1])";
|
|
const "pname", "name(.)";
|
|
const "pitype" call "toIntermediate" with "type", "$ptype";
|
|
|
|
if "not(position() mod 2)" choose {
|
|
when "$ptype = 'string'"
|
|
| «$pitype» _«$pname» = AbstractEngine.toUTF8(«$pname»);
|
|
when "$ptype = 'bool'"
|
|
| «$pitype» _«$pname» = «$pname».booleanValue();
|
|
when "$ptype = 'bytearray'"
|
|
| «$pitype» _«$pname» = «$pname».clone();
|
|
when "$ptype = 'int'"
|
|
| «$pitype» _«$pname» = «$pname»;
|
|
when "ancestor::namespace/child::enum[@name=$ptype]"
|
|
| «$pitype» _«$pname» = «$pname».value;
|
|
otherwise
|
|
| «$pitype» _«$pname» = new «$pitype»(«$pname»);
|
|
}
|
|
}
|
|
|
|
function "returnJava" {
|
|
const "returning", "count(parm/creates|parm/returns)";
|
|
const "returntype" call "toJava" with "type", "name(parm[creates|returns]/*[2])";
|
|
|
|
choose {
|
|
when "$returning = 0" > void
|
|
when "$returning = 1" > «$returntype»
|
|
otherwise > «@name»_Return
|
|
}
|
|
}
|
|
|
|
function "returnInter" {
|
|
const "returning", "count(parm/creates|parm/returns)";
|
|
const "returntype" call "toIntermediate" with "type", "name(parm[creates|returns]/*[2])";
|
|
|
|
choose {
|
|
when "$returning = 0" > void
|
|
when "$returning = 1" > «$returntype»
|
|
otherwise > _«@name»_Return
|
|
}
|
|
}
|
|
|
|
template "method", mode=plain {
|
|
const "convert", "count(parm/stringlist|parm/stringpairlist|parm/string|parm/identity|parm/identitylist) > 0";
|
|
const "singlereturn", "count(parm/creates|parm/returns|parm/inout[../int]) = 1";
|
|
const "multireturn", "count(parm/creates|parm/returns|parm/inout[../int]) > 1";
|
|
|
|
if "$multireturn" {
|
|
if "$convert"
|
|
||
|
|
private class _«@name»_Return {
|
|
`` apply "parm[creates|returns|inout[../int]]", 1, mode=intermediate with "public", 1;
|
|
}
|
|
|
|
||
|
|
|
|
||
|
|
public class «@name»_Return {
|
|
`` apply "parm[creates|returns|inout[../int]]", 1, mode=java with "public", 1;
|
|
}
|
|
|
|
||
|
|
}
|
|
|
|
if "$convert"
|
|
||
|
|
private native `call "returnInter"` _«@name»(
|
|
`` apply "parm[in|inout]", 2, mode=intermediate
|
|
) throws pEpException;
|
|
|
|
||
|
|
|
|
||
|
|
public `if "not($convert)" > native ``call "returnJava"` «@name»(
|
|
`` apply "parm[in|inout]", 2, mode=java
|
|
) throws pEpException`if "not($convert)" > ;`
|
|
||
|
|
|
|
if "$convert" {
|
|
| {
|
|
apply "parm", mode=convertIn;
|
|
|
|
if "$singlereturn" choose {
|
|
|
|
// TODO factorize type conversion with multireturn and gen_java_message.java
|
|
|
|
when "count(parm[returns][stringlist|string|sstring]) > 0"
|
|
|> return AbstractEngine.toUTF16(_«@name»(`apply "parm[in]", mode=call;`));
|
|
when "count(parm[returns]/stringpairlist) > 0"
|
|
||
|
|
ArrayList<Pair<byte[], byte[]>> glist = _«@name»(`apply "parm[in]", mode=call;`);
|
|
if(glist != null){
|
|
ArrayList<Pair<String, String>> list = new ArrayList<Pair<String, String>>();
|
|
for (Pair<byte[],byte[]> i : glist)
|
|
list.add(new Pair<String, String>(AbstractEngine.toUTF16(i.first), AbstractEngine.toUTF16(i.second)));
|
|
return list;
|
|
}
|
|
return null;
|
|
||
|
|
|
|
when "count(parm[returns]/identity) > 0"
|
|
|> return new Identity(_«@name»(`apply "parm[in]", mode=call;`));
|
|
when "count(parm[returns]/identitylist) > 0"
|
|
||
|
|
Vector<_Identity> glist = _«@name»(`apply "parm[in]", mode=call;`);
|
|
if(glist != null){
|
|
Vector<Identity> list = new Vector<Identity>();
|
|
for (_Identity i : glist)
|
|
list.add(new Identity(i));
|
|
return list;
|
|
}
|
|
return null;
|
|
||
|
|
otherwise
|
|
|> return _«@name»(`apply "parm[in]", mode=call;`);
|
|
}
|
|
|
|
if "$multireturn"
|
|
||
|
|
_«@name»_Return _result = _«@name»(`apply "parm[in|inout]", mode=call;`);
|
|
«@name»_Return result = new «@name»_Return();
|
|
`` apply "parm[creates|returns|inout[../int]]", mode=convertOut;
|
|
return result;
|
|
||
|
|
|
|
if "not($singlereturn) and not($multireturn)"
|
|
||
|
|
_«@name»(`apply "parm[in]", mode=call;`);
|
|
return;
|
|
||
|
|
|
|
||
|
|
}
|
|
||
|
|
}
|
|
||
|
|
|
|
||
|
|
}
|
|
|
|
template "parm", mode=java {
|
|
param "public", 0;
|
|
const "dir", "name(*[1])";
|
|
const "type", "name(*[2])";
|
|
const "name", "name(*[3])";
|
|
|
|
indent(0);
|
|
|
|
if "$public" > public
|
|
call "toJava" with "type", "$type";
|
|
> «translate($name,'-','_')»
|
|
choose {
|
|
when "$public" > ;
|
|
otherwise if "position()!=last()" > ,
|
|
}
|
|
> \n
|
|
}
|
|
|
|
template "parm", mode=intermediate {
|
|
param "public", 0;
|
|
const "dir", "name(*[1])";
|
|
const "type", "name(*[2])";
|
|
const "name", "name(*[3])";
|
|
|
|
indent(0);
|
|
|
|
if "$public" > public
|
|
call "toIntermediate" with "type", "$type", with "dir", "$dir";
|
|
> «translate($name,'-','_')»
|
|
choose {
|
|
when "$public" > ;
|
|
otherwise if "position()!=last()" > ,
|
|
}
|
|
> \n
|
|
}
|
|
|
|
template "parm", mode=convertIn {
|
|
const "dir", "name(*[1])";
|
|
const "type", "name(*[2])";
|
|
const "name" call "lcase" with "text", "name(*[3])";
|
|
|
|
if "$dir = 'in' or $dir = 'inout'" choose {
|
|
when "$type = 'string' or $type = 'stringlist'"
|
|
| ¡$type _«$name» = AbstractEngine.toUTF8(«$name»);
|
|
when "$type = 'identity'"
|
|
||
|
|
_Identity _«$name» = null;
|
|
if («$name» != null) {
|
|
_«$name» = new _Identity(«$name»);
|
|
}
|
|
||
|
|
when "$type = 'identitylist'"
|
|
||
|
|
Vector<_Identity> _«$name» = new Vector<_Identity>();
|
|
for (Identity i : «$name»)
|
|
_«$name».add(new _Identity(i));
|
|
||
|
|
}
|
|
}
|
|
|
|
template "parm", mode=convertOut {
|
|
const "dir", "name(*[1])";
|
|
const "type", "name(*[2])";
|
|
const "name" call "lcase" with "text", "name(*[3])";
|
|
|
|
if "$dir != 'in'" choose {
|
|
when "$type = 'string' or $type = 'stringlist'"
|
|
| result.«$name» = AbstractEngine.toUTF16(_result.«$name»);
|
|
when "$type = 'identity'"
|
|
| result.«$name» = Identity(«$name»);
|
|
otherwise
|
|
| result.«$name» = _result.«$name»;
|
|
}
|
|
}
|
|
|
|
template "parm", mode=call {
|
|
const "type", "name(*[2])";
|
|
const "name" call "lcase" with "text", "name(*[3])";
|
|
|
|
if "$type = 'string' or $type = 'stringlist' or $type = 'identity' or $type = 'identitylist'"
|
|
> _
|
|
> «$name»`if "position()!=last()" > , `
|
|
}
|
|
}
|
|
|
|
|