am bad130ee: am 02bc5488: Merge "Remove RPC interface Type" (1ef20d62) · Commits · e / os / android_frameworks_base

tools/aidl/Android.mk

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -31,7 +31,6 @@ LOCAL_SRC_FILES := \
	aidl_language_y.y \		aidl_language_y.y \
	generate_java.cpp \		generate_java.cpp \
	generate_java_binder.cpp \		generate_java_binder.cpp \
	generate_java_rpc.cpp \
	options.cpp \		options.cpp \
	search_path.cpp \		search_path.cpp \

tools/aidl/Type.cpp

+38 −235

Original line number	Original line	Diff line number	Diff line
	@@ -28,9 +28,6 @@ Type* CONTEXT_TYPE;
	Type* MAP_TYPE;		Type* MAP_TYPE;
	Type* LIST_TYPE;		Type* LIST_TYPE;
	Type* CLASSLOADER_TYPE;		Type* CLASSLOADER_TYPE;
	Type* RPC_DATA_TYPE;
	Type* RPC_ERROR_TYPE;
	Type* EVENT_FAKE_TYPE;

	Expression* NULL_VALUE;		Expression* NULL_VALUE;
	Expression* THIS_VALUE;		Expression* THIS_VALUE;
	@@ -42,7 +39,6 @@ void
	register_base_types()		register_base_types()
	{		{
	VOID_TYPE = new BasicType("void",		VOID_TYPE = new BasicType("void",
	"XXX", "XXX", "XXX", "XXX", "XXX",
	"XXX", "XXX", "XXX", "XXX", "XXX");		"XXX", "XXX", "XXX", "XXX", "XXX");
	NAMES.Add(VOID_TYPE);		NAMES.Add(VOID_TYPE);

	@@ -50,37 +46,37 @@ register_base_types()
	NAMES.Add(BOOLEAN_TYPE);		NAMES.Add(BOOLEAN_TYPE);

	BYTE_TYPE = new BasicType("byte",		BYTE_TYPE = new BasicType("byte",
	"writeByte", "readByte", "writeByteArray", "createByteArray", "readByteArray",		"writeByte", "readByte", "writeByteArray", "createByteArray",
	"putByte", "getByte", "putByteArray", "createByteArray", "getByteArray");		"readByteArray");
	NAMES.Add(BYTE_TYPE);		NAMES.Add(BYTE_TYPE);

	CHAR_TYPE = new CharType();		CHAR_TYPE = new CharType();
	NAMES.Add(CHAR_TYPE);		NAMES.Add(CHAR_TYPE);

	INT_TYPE = new BasicType("int",		INT_TYPE = new BasicType("int",
	"writeInt", "readInt", "writeIntArray", "createIntArray", "readIntArray",		"writeInt", "readInt", "writeIntArray", "createIntArray",
	"putInteger", "getInteger", "putIntegerArray", "createIntegerArray", "getIntegerArray");		"readIntArray");
	NAMES.Add(INT_TYPE);		NAMES.Add(INT_TYPE);

	LONG_TYPE = new BasicType("long",		LONG_TYPE = new BasicType("long",
	"writeLong", "readLong", "writeLongArray", "createLongArray", "readLongArray",		"writeLong", "readLong", "writeLongArray", "createLongArray",
	"putLong", "getLong", "putLongArray", "createLongArray", "getLongArray");		"readLongArray");
	NAMES.Add(LONG_TYPE);		NAMES.Add(LONG_TYPE);

	FLOAT_TYPE = new BasicType("float",		FLOAT_TYPE = new BasicType("float",
	"writeFloat", "readFloat", "writeFloatArray", "createFloatArray", "readFloatArray",		"writeFloat", "readFloat", "writeFloatArray", "createFloatArray",
	"putFloat", "getFloat", "putFloatArray", "createFloatArray", "getFloatArray");		"readFloatArray");
	NAMES.Add(FLOAT_TYPE);		NAMES.Add(FLOAT_TYPE);

	DOUBLE_TYPE = new BasicType("double",		DOUBLE_TYPE = new BasicType("double",
	"writeDouble", "readDouble", "writeDoubleArray", "createDoubleArray", "readDoubleArray",		"writeDouble", "readDouble", "writeDoubleArray",
	"putDouble", "getDouble", "putDoubleArray", "createDoubleArray", "getDoubleArray");		"createDoubleArray", "readDoubleArray");
	NAMES.Add(DOUBLE_TYPE);		NAMES.Add(DOUBLE_TYPE);

	STRING_TYPE = new StringType();		STRING_TYPE = new StringType();
	NAMES.Add(STRING_TYPE);		NAMES.Add(STRING_TYPE);

	OBJECT_TYPE = new Type("java.lang", "Object", Type::BUILT_IN, false, false, false);		OBJECT_TYPE = new Type("java.lang", "Object", Type::BUILT_IN, false, false);
	NAMES.Add(OBJECT_TYPE);		NAMES.Add(OBJECT_TYPE);

	CHAR_SEQUENCE_TYPE = new CharSequenceType();		CHAR_SEQUENCE_TYPE = new CharSequenceType();
	@@ -92,7 +88,7 @@ register_base_types()
	LIST_TYPE = new ListType();		LIST_TYPE = new ListType();
	NAMES.Add(LIST_TYPE);		NAMES.Add(LIST_TYPE);

	TEXT_UTILS_TYPE = new Type("android.text", "TextUtils", Type::BUILT_IN, false, false, false);		TEXT_UTILS_TYPE = new Type("android.text", "TextUtils", Type::BUILT_IN, false, false);
	NAMES.Add(TEXT_UTILS_TYPE);		NAMES.Add(TEXT_UTILS_TYPE);

	REMOTE_EXCEPTION_TYPE = new RemoteExceptionType();		REMOTE_EXCEPTION_TYPE = new RemoteExceptionType();
	@@ -119,19 +115,9 @@ register_base_types()
	PARCELABLE_INTERFACE_TYPE = new ParcelableInterfaceType();		PARCELABLE_INTERFACE_TYPE = new ParcelableInterfaceType();
	NAMES.Add(PARCELABLE_INTERFACE_TYPE);		NAMES.Add(PARCELABLE_INTERFACE_TYPE);

	CONTEXT_TYPE = new Type("android.content", "Context", Type::BUILT_IN, false, false, false);		CONTEXT_TYPE = new Type("android.content", "Context", Type::BUILT_IN, false, false);
	NAMES.Add(CONTEXT_TYPE);		NAMES.Add(CONTEXT_TYPE);

	RPC_DATA_TYPE = new RpcDataType();
	NAMES.Add(RPC_DATA_TYPE);

	RPC_ERROR_TYPE = new UserDataType("android.support.place.rpc", "RpcError",
	true, __FILE__, __LINE__);
	NAMES.Add(RPC_ERROR_TYPE);

	EVENT_FAKE_TYPE = new Type("event", Type::BUILT_IN, false, false, false);
	NAMES.Add(EVENT_FAKE_TYPE);

	CLASSLOADER_TYPE = new ClassLoaderType();		CLASSLOADER_TYPE = new ClassLoaderType();
	NAMES.Add(CLASSLOADER_TYPE);		NAMES.Add(CLASSLOADER_TYPE);

	@@ -158,30 +144,27 @@ make_generic_type(const string& package, const string& name,

	// ================================================================		// ================================================================

	Type::Type(const string& name, int kind, bool canWriteToParcel, bool canWriteToRpcData,		Type::Type(const string& name, int kind, bool canWriteToParcel, bool canBeOut)
	bool canBeOut)
	:m_package(),		:m_package(),
	m_name(name),		m_name(name),
	m_declFile(""),		m_declFile(""),
	m_declLine(-1),		m_declLine(-1),
	m_kind(kind),		m_kind(kind),
	m_canWriteToParcel(canWriteToParcel),		m_canWriteToParcel(canWriteToParcel),
	m_canWriteToRpcData(canWriteToRpcData),
	m_canBeOut(canBeOut)		m_canBeOut(canBeOut)
	{		{
	m_qualifiedName = name;		m_qualifiedName = name;
	}		}

	Type::Type(const string& package, const string& name,		Type::Type(const string& package, const string& name,
	int kind, bool canWriteToParcel, bool canWriteToRpcData,		int kind, bool canWriteToParcel, bool canBeOut,
	bool canBeOut, const string& declFile, int declLine)		const string& declFile, int declLine)
	:m_package(package),		:m_package(package),
	m_name(name),		m_name(name),
	m_declFile(declFile),		m_declFile(declFile),
	m_declLine(declLine),		m_declLine(declLine),
	m_kind(kind),		m_kind(kind),
	m_canWriteToParcel(canWriteToParcel),		m_canWriteToParcel(canWriteToParcel),
	m_canWriteToRpcData(canWriteToRpcData),
	m_canBeOut(canBeOut)		m_canBeOut(canBeOut)
	{		{
	if (package.length() > 0) {		if (package.length() > 0) {
	@@ -213,12 +196,6 @@ Type::CreatorName() const
	return "";		return "";
	}		}

	string
	Type::RpcCreatorName() const
	{
	return "";
	}

	string		string
	Type::InstantiableName() const		Type::InstantiableName() const
	{		{
	@@ -281,26 +258,6 @@ Type::ReadArrayFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
	+ m_qualifiedName + " */"));		+ m_qualifiedName + " */"));
	}		}

	void
	Type::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags)
	{
	fprintf(stderr, "aidl:internal error %s:%d qualifiedName=%s\n",
	__FILE__, __LINE__, m_qualifiedName.c_str());
	addTo->Add(new LiteralExpression("/* WriteToRpcData error "
	+ m_qualifiedName + " */"));
	}

	void
	Type::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v, Variable* data,
	Variable** cl)
	{
	fprintf(stderr, "aidl:internal error %s:%d qualifiedName=%s\n",
	__FILE__, __LINE__, m_qualifiedName.c_str());
	addTo->Add(new LiteralExpression("/* ReadFromRpcData error "
	+ m_qualifiedName + " */"));
	}

	void		void
	Type::SetQualifiedName(const string& qualified)		Type::SetQualifiedName(const string& qualified)
	{		{
	@@ -324,20 +281,13 @@ Type::BuildWriteToParcelFlags(int flags)

	BasicType::BasicType(const string& name, const string& marshallParcel,		BasicType::BasicType(const string& name, const string& marshallParcel,
	const string& unmarshallParcel, const string& writeArrayParcel,		const string& unmarshallParcel, const string& writeArrayParcel,
	const string& createArrayParcel, const string& readArrayParcel,		const string& createArrayParcel, const string& readArrayParcel)
	const string& marshallRpc, const string& unmarshallRpc,		:Type(name, BUILT_IN, true, false),
	const string& writeArrayRpc, const string& createArrayRpc, const string& readArrayRpc)
	:Type(name, BUILT_IN, true, true, false),
	m_marshallParcel(marshallParcel),		m_marshallParcel(marshallParcel),
	m_unmarshallParcel(unmarshallParcel),		m_unmarshallParcel(unmarshallParcel),
	m_writeArrayParcel(writeArrayParcel),		m_writeArrayParcel(writeArrayParcel),
	m_createArrayParcel(createArrayParcel),		m_createArrayParcel(createArrayParcel),
	m_readArrayParcel(readArrayParcel),		m_readArrayParcel(readArrayParcel)
	m_marshallRpc(marshallRpc),
	m_unmarshallRpc(unmarshallRpc),
	m_writeArrayRpc(writeArrayRpc),
	m_createArrayRpc(createArrayRpc),
	m_readArrayRpc(readArrayRpc)
	{		{
	}		}

	@@ -378,24 +328,10 @@ BasicType::ReadArrayFromParcel(StatementBlock* addTo, Variable* v, Variable* par
	addTo->Add(new MethodCall(parcel, m_readArrayParcel, 1, v));		addTo->Add(new MethodCall(parcel, m_readArrayParcel, 1, v));
	}		}

	void
	BasicType::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags)
	{
	addTo->Add(new MethodCall(data, m_marshallRpc, 2, k, v));
	}

	void
	BasicType::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v, Variable* data,
	Variable** cl)
	{
	addTo->Add(new Assignment(v, new MethodCall(data, m_unmarshallRpc, 1, k)));
	}

	// ================================================================		// ================================================================

	BooleanType::BooleanType()		BooleanType::BooleanType()
	:Type("boolean", BUILT_IN, true, true, false)		:Type("boolean", BUILT_IN, true, false)
	{		{
	}		}

	@@ -439,24 +375,10 @@ BooleanType::ReadArrayFromParcel(StatementBlock* addTo, Variable* v, Variable* p
	addTo->Add(new MethodCall(parcel, "readBooleanArray", 1, v));		addTo->Add(new MethodCall(parcel, "readBooleanArray", 1, v));
	}		}

	void
	BooleanType::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags)
	{
	addTo->Add(new MethodCall(data, "putBoolean", 2, k, v));
	}

	void
	BooleanType::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v, Variable* data,
	Variable** cl)
	{
	addTo->Add(new Assignment(v, new MethodCall(data, "getBoolean", 1, k)));
	}

	// ================================================================		// ================================================================

	CharType::CharType()		CharType::CharType()
	:Type("char", BUILT_IN, true, true, false)		:Type("char", BUILT_IN, true, false)
	{		{
	}		}

	@@ -498,24 +420,10 @@ CharType::ReadArrayFromParcel(StatementBlock* addTo, Variable* v, Variable* parc
	addTo->Add(new MethodCall(parcel, "readCharArray", 1, v));		addTo->Add(new MethodCall(parcel, "readCharArray", 1, v));
	}		}

	void
	CharType::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags)
	{
	addTo->Add(new MethodCall(data, "putChar", 2, k, v));
	}

	void
	CharType::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v, Variable* data,
	Variable** cl)
	{
	addTo->Add(new Assignment(v, new MethodCall(data, "getChar", 1, k)));
	}

	// ================================================================		// ================================================================

	StringType::StringType()		StringType::StringType()
	:Type("java.lang", "String", BUILT_IN, true, true, false)		:Type("java.lang", "String", BUILT_IN, true, false)
	{		{
	}		}

	@@ -562,24 +470,10 @@ StringType::ReadArrayFromParcel(StatementBlock* addTo, Variable* v, Variable* pa
	addTo->Add(new MethodCall(parcel, "readStringArray", 1, v));		addTo->Add(new MethodCall(parcel, "readStringArray", 1, v));
	}		}

	void
	StringType::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags)
	{
	addTo->Add(new MethodCall(data, "putString", 2, k, v));
	}

	void
	StringType::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, Variable**)
	{
	addTo->Add(new Assignment(v, new MethodCall(data, "getString", 1, k)));
	}

	// ================================================================		// ================================================================

	CharSequenceType::CharSequenceType()		CharSequenceType::CharSequenceType()
	:Type("java.lang", "CharSequence", BUILT_IN, true, true, false)		:Type("java.lang", "CharSequence", BUILT_IN, true, false)
	{		{
	}		}

	@@ -639,7 +533,7 @@ CharSequenceType::CreateFromParcel(StatementBlock* addTo, Variable* v,
	// ================================================================		// ================================================================

	RemoteExceptionType::RemoteExceptionType()		RemoteExceptionType::RemoteExceptionType()
	:Type("android.os", "RemoteException", BUILT_IN, false, false, false)		:Type("android.os", "RemoteException", BUILT_IN, false, false)
	{		{
	}		}

	@@ -658,7 +552,7 @@ RemoteExceptionType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variab
	// ================================================================		// ================================================================

	RuntimeExceptionType::RuntimeExceptionType()		RuntimeExceptionType::RuntimeExceptionType()
	:Type("java.lang", "RuntimeException", BUILT_IN, false, false, false)		:Type("java.lang", "RuntimeException", BUILT_IN, false, false)
	{		{
	}		}

	@@ -678,7 +572,7 @@ RuntimeExceptionType::CreateFromParcel(StatementBlock* addTo, Variable* v, Varia
	// ================================================================		// ================================================================

	IBinderType::IBinderType()		IBinderType::IBinderType()
	:Type("android.os", "IBinder", BUILT_IN, true, false, false)		:Type("android.os", "IBinder", BUILT_IN, true, false)
	{		{
	}		}

	@@ -717,7 +611,7 @@ IBinderType::ReadArrayFromParcel(StatementBlock* addTo, Variable* v, Variable* p
	// ================================================================		// ================================================================

	IInterfaceType::IInterfaceType()		IInterfaceType::IInterfaceType()
	:Type("android.os", "IInterface", BUILT_IN, false, false, false)		:Type("android.os", "IInterface", BUILT_IN, false, false)
	{		{
	}		}

	@@ -737,7 +631,7 @@ IInterfaceType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* p
	// ================================================================		// ================================================================

	BinderType::BinderType()		BinderType::BinderType()
	:Type("android.os", "Binder", BUILT_IN, false, false, false)		:Type("android.os", "Binder", BUILT_IN, false, false)
	{		{
	}		}

	@@ -758,7 +652,7 @@ BinderType::CreateFromParcel(StatementBlock* addTo, Variable* v,
	// ================================================================		// ================================================================

	BinderProxyType::BinderProxyType()		BinderProxyType::BinderProxyType()
	:Type("android.os", "BinderProxy", BUILT_IN, false, false, false)		:Type("android.os", "BinderProxy", BUILT_IN, false, false)
	{		{
	}		}

	@@ -779,7 +673,7 @@ BinderProxyType::CreateFromParcel(StatementBlock* addTo, Variable* v,
	// ================================================================		// ================================================================

	ParcelType::ParcelType()		ParcelType::ParcelType()
	:Type("android.os", "Parcel", BUILT_IN, false, false, false)		:Type("android.os", "Parcel", BUILT_IN, false, false)
	{		{
	}		}

	@@ -798,7 +692,7 @@ ParcelType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parce
	// ================================================================		// ================================================================

	ParcelableInterfaceType::ParcelableInterfaceType()		ParcelableInterfaceType::ParcelableInterfaceType()
	:Type("android.os", "Parcelable", BUILT_IN, false, false, false)		:Type("android.os", "Parcelable", BUILT_IN, false, false)
	{		{
	}		}

	@@ -817,7 +711,7 @@ ParcelableInterfaceType::CreateFromParcel(StatementBlock* addTo, Variable* v, Va
	// ================================================================		// ================================================================

	MapType::MapType()		MapType::MapType()
	:Type("java.util", "Map", BUILT_IN, true, false, true)		:Type("java.util", "Map", BUILT_IN, true, true)
	{		{
	}		}

	@@ -857,7 +751,7 @@ MapType::ReadFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel, Va
	// ================================================================		// ================================================================

	ListType::ListType()		ListType::ListType()
	:Type("java.util", "List", BUILT_IN, true, true, true)		:Type("java.util", "List", BUILT_IN, true, true)
	{		{
	}		}

	@@ -888,26 +782,12 @@ ListType::ReadFromParcel(StatementBlock* addTo, Variable* v,
	addTo->Add(new MethodCall(parcel, "readList", 2, v, *cl));		addTo->Add(new MethodCall(parcel, "readList", 2, v, *cl));
	}		}

	void
	ListType::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags)
	{
	addTo->Add(new MethodCall(data, "putList", 2, k, v));
	}

	void
	ListType::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v, Variable* data,
	Variable** cl)
	{
	addTo->Add(new Assignment(v, new MethodCall(data, "getList", 1, k)));
	}

	// ================================================================		// ================================================================

	UserDataType::UserDataType(const string& package, const string& name,		UserDataType::UserDataType(const string& package, const string& name,
	bool builtIn, bool canWriteToParcel, bool canWriteToRpcData,		bool builtIn, bool canWriteToParcel,
	const string& declFile, int declLine)		const string& declFile, int declLine)
	:Type(package, name, builtIn ? BUILT_IN : USERDATA, canWriteToParcel, canWriteToRpcData,		:Type(package, name, builtIn ? BUILT_IN : USERDATA, canWriteToParcel,
	true, declFile, declLine)		true, declFile, declLine)
	{		{
	}		}
	@@ -918,12 +798,6 @@ UserDataType::CreatorName() const
	return QualifiedName() + ".CREATOR";		return QualifiedName() + ".CREATOR";
	}		}

	string
	UserDataType::RpcCreatorName() const
	{
	return QualifiedName() + ".RPC_CREATOR";
	}

	void		void
	UserDataType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)		UserDataType::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel, int flags)
	{		{
	@@ -1014,29 +888,12 @@ UserDataType::ReadArrayFromParcel(StatementBlock* addTo, Variable* v, Variable*
	v, new LiteralExpression(creator)));		v, new LiteralExpression(creator)));
	}		}

	void
	UserDataType::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags)
	{
	// data.putFlattenable(k, v);
	addTo->Add(new MethodCall(data, "putFlattenable", 2, k, v));
	}

	void
	UserDataType::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, Variable** cl)
	{
	// data.getFlattenable(k, CLASS.RPC_CREATOR);
	addTo->Add(new Assignment(v, new MethodCall(data, "getFlattenable", 2, k,
	new FieldVariable(v->type, "RPC_CREATOR"))));
	}

	// ================================================================		// ================================================================

	InterfaceType::InterfaceType(const string& package, const string& name,		InterfaceType::InterfaceType(const string& package, const string& name,
	bool builtIn, bool oneway,		bool builtIn, bool oneway,
	const string& declFile, int declLine)		const string& declFile, int declLine)
	:Type(package, name, builtIn ? BUILT_IN : INTERFACE, true, false, false,		:Type(package, name, builtIn ? BUILT_IN : INTERFACE, true, false,
	declFile, declLine)		declFile, declLine)
	,m_oneway(oneway)		,m_oneway(oneway)
	{		{
	@@ -1075,7 +932,7 @@ InterfaceType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* pa

	GenericType::GenericType(const string& package, const string& name,		GenericType::GenericType(const string& package, const string& name,
	const vector<Type*>& args)		const vector<Type*>& args)
	:Type(package, name, BUILT_IN, true, true, true)		:Type(package, name, BUILT_IN, true, true)
	{		{
	m_args = args;		m_args = args;

	@@ -1200,65 +1057,11 @@ GenericListType::ReadFromParcel(StatementBlock* addTo, Variable* v,
	}		}
	}		}

	void
	GenericListType::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags)
	{
	Type* generic = GenericArgumentTypes()[0];
	if (generic == RPC_DATA_TYPE) {
	addTo->Add(new MethodCall(data, "putRpcDataList", 2, k, v));
	} else if (generic->RpcCreatorName() != "") {
	addTo->Add(new MethodCall(data, "putFlattenableList", 2, k, v));
	} else {
	addTo->Add(new MethodCall(data, "putList", 2, k, v));
	}
	}

	void
	GenericListType::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, Variable** cl)
	{
	Type* generic = GenericArgumentTypes()[0];
	if (generic == RPC_DATA_TYPE) {
	addTo->Add(new Assignment(v, new MethodCall(data, "getRpcDataList", 2, k)));
	} else if (generic->RpcCreatorName() != "") {
	addTo->Add(new Assignment(v, new MethodCall(data, "getFlattenableList", 2, k,
	new LiteralExpression(generic->RpcCreatorName()))));
	} else {
	string classArg = GenericArgumentTypes()[0]->QualifiedName();
	classArg += ".class";
	addTo->Add(new Assignment(v, new MethodCall(data, "getList", 2, k,
	new LiteralExpression(classArg))));
	}
	}


	// ================================================================

	RpcDataType::RpcDataType()
	:UserDataType("android.support.place.rpc", "RpcData", true, true, true)
	{
	}

	void
	RpcDataType::WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags)
	{
	addTo->Add(new MethodCall(data, "putRpcData", 2, k, v));
	}

	void
	RpcDataType::CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v, Variable* data,
	Variable** cl)
	{
	addTo->Add(new Assignment(v, new MethodCall(data, "getRpcData", 1, k)));
	}


	// ================================================================		// ================================================================

	ClassLoaderType::ClassLoaderType()		ClassLoaderType::ClassLoaderType()
	:Type("java.lang", "ClassLoader", BUILT_IN, false, false, false)		:Type("java.lang", "ClassLoader", BUILT_IN, false, false)
	{		{
	}		}

tools/aidl/Type.h

+4 −74

Original line number	Original line	Diff line number	Diff line
	@@ -24,9 +24,9 @@ public:
	};		};

	Type(const string& name, int kind, bool canWriteToParcel,		Type(const string& name, int kind, bool canWriteToParcel,
	bool canWriteToRpcData, bool canBeOut);		bool canBeOut);
	Type(const string& package, const string& name,		Type(const string& package, const string& name,
	int kind, bool canWriteToParcel, bool canWriteToRpcData, bool canBeOut,		int kind, bool canWriteToParcel, bool canBeOut,
	const string& declFile = "", int declLine = -1);		const string& declFile = "", int declLine = -1);
	virtual ~Type();		virtual ~Type();

	@@ -37,12 +37,10 @@ public:
	inline string DeclFile() const { return m_declFile; }		inline string DeclFile() const { return m_declFile; }
	inline int DeclLine() const { return m_declLine; }		inline int DeclLine() const { return m_declLine; }
	inline bool CanWriteToParcel() const { return m_canWriteToParcel; }		inline bool CanWriteToParcel() const { return m_canWriteToParcel; }
	inline bool CanWriteToRpcData() const { return m_canWriteToRpcData; }
	inline bool CanBeOutParameter() const { return m_canBeOut; }		inline bool CanBeOutParameter() const { return m_canBeOut; }

	virtual string ImportType() const;		virtual string ImportType() const;
	virtual string CreatorName() const;		virtual string CreatorName() const;
	virtual string RpcCreatorName() const;
	virtual string InstantiableName() const;		virtual string InstantiableName() const;

	virtual void WriteToParcel(StatementBlock* addTo, Variable* v,		virtual void WriteToParcel(StatementBlock* addTo, Variable* v,
	@@ -61,11 +59,6 @@ public:
	virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,		virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
	Variable* parcel, Variable** cl);		Variable* parcel, Variable** cl);

	virtual void WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags);
	virtual void CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, Variable** cl);

	protected:		protected:
	void SetQualifiedName(const string& qualified);		void SetQualifiedName(const string& qualified);
	Expression* BuildWriteToParcelFlags(int flags);		Expression* BuildWriteToParcelFlags(int flags);
	@@ -81,7 +74,6 @@ private:
	int m_declLine;		int m_declLine;
	int m_kind;		int m_kind;
	bool m_canWriteToParcel;		bool m_canWriteToParcel;
	bool m_canWriteToRpcData;
	bool m_canBeOut;		bool m_canBeOut;
	};		};

	@@ -93,12 +85,7 @@ public:
	const string& unmarshallParcel,		const string& unmarshallParcel,
	const string& writeArrayParcel,		const string& writeArrayParcel,
	const string& createArrayParcel,		const string& createArrayParcel,
	const string& readArrayParcel,		const string& readArrayParcel);
	const string& marshallRpc,
	const string& unmarshallRpc,
	const string& writeArrayRpc,
	const string& createArrayRpc,
	const string& readArrayRpc);

	virtual void WriteToParcel(StatementBlock* addTo, Variable* v,		virtual void WriteToParcel(StatementBlock* addTo, Variable* v,
	Variable* parcel, int flags);		Variable* parcel, int flags);
	@@ -114,22 +101,12 @@ public:
	virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,		virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
	Variable* parcel, Variable** cl);		Variable* parcel, Variable** cl);

	virtual void WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags);
	virtual void CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, Variable** cl);

	private:		private:
	string m_marshallParcel;		string m_marshallParcel;
	string m_unmarshallParcel;		string m_unmarshallParcel;
	string m_writeArrayParcel;		string m_writeArrayParcel;
	string m_createArrayParcel;		string m_createArrayParcel;
	string m_readArrayParcel;		string m_readArrayParcel;
	string m_marshallRpc;
	string m_unmarshallRpc;
	string m_writeArrayRpc;
	string m_createArrayRpc;
	string m_readArrayRpc;
	};		};

	class BooleanType : public Type		class BooleanType : public Type
	@@ -150,11 +127,6 @@ public:
	Variable* parcel, Variable** cl);		Variable* parcel, Variable** cl);
	virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,		virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
	Variable* parcel, Variable** cl);		Variable* parcel, Variable** cl);

	virtual void WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags);
	virtual void CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, Variable** cl);
	};		};

	class CharType : public Type		class CharType : public Type
	@@ -175,11 +147,6 @@ public:
	Variable* parcel, Variable** cl);		Variable* parcel, Variable** cl);
	virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,		virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
	Variable* parcel, Variable** cl);		Variable* parcel, Variable** cl);

	virtual void WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags);
	virtual void CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, Variable** cl);
	};		};


	@@ -203,11 +170,6 @@ public:
	Variable* parcel, Variable** cl);		Variable* parcel, Variable** cl);
	virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,		virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
	Variable* parcel, Variable** cl);		Variable* parcel, Variable** cl);

	virtual void WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags);
	virtual void CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, Variable** cl);
	};		};

	class CharSequenceType : public Type		class CharSequenceType : public Type
	@@ -344,22 +306,16 @@ public:
	Variable* parcel, Variable** cl);		Variable* parcel, Variable** cl);
	virtual void ReadFromParcel(StatementBlock* addTo, Variable* v,		virtual void ReadFromParcel(StatementBlock* addTo, Variable* v,
	Variable* parcel, Variable** cl);		Variable* parcel, Variable** cl);

	virtual void WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags);
	virtual void CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, Variable** cl);
	};		};

	class UserDataType : public Type		class UserDataType : public Type
	{		{
	public:		public:
	UserDataType(const string& package, const string& name,		UserDataType(const string& package, const string& name,
	bool builtIn, bool canWriteToParcel, bool canWriteToRpcData,		bool builtIn, bool canWriteToParcel,
	const string& declFile = "", int declLine = -1);		const string& declFile = "", int declLine = -1);

	virtual string CreatorName() const;		virtual string CreatorName() const;
	virtual string RpcCreatorName() const;

	virtual void WriteToParcel(StatementBlock* addTo, Variable* v,		virtual void WriteToParcel(StatementBlock* addTo, Variable* v,
	Variable* parcel, int flags);		Variable* parcel, int flags);
	@@ -376,11 +332,6 @@ public:
	Variable* parcel, Variable** cl);		Variable* parcel, Variable** cl);
	virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,		virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
	Variable* parcel, Variable** cl);		Variable* parcel, Variable** cl);

	virtual void WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags);
	virtual void CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, Variable** cl);
	};		};

	class InterfaceType : public Type		class InterfaceType : public Type
	@@ -426,17 +377,6 @@ private:
	vector<Type*> m_args;		vector<Type*> m_args;
	};		};

	class RpcDataType : public UserDataType
	{
	public:
	RpcDataType();

	virtual void WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags);
	virtual void CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, Variable** cl);
	};

	class ClassLoaderType : public Type		class ClassLoaderType : public Type
	{		{
	public:		public:
	@@ -459,11 +399,6 @@ public:
	virtual void ReadFromParcel(StatementBlock* addTo, Variable* v,		virtual void ReadFromParcel(StatementBlock* addTo, Variable* v,
	Variable* parcel, Variable** cl);		Variable* parcel, Variable** cl);

	virtual void WriteToRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, int flags);
	virtual void CreateFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
	Variable* data, Variable** cl);

	private:		private:
	string m_creator;		string m_creator;
	};		};
	@@ -526,11 +461,6 @@ extern Type* PARCELABLE_INTERFACE_TYPE;

	extern Type* CONTEXT_TYPE;		extern Type* CONTEXT_TYPE;

	extern Type* RPC_DATA_TYPE;
	extern Type* RPC_ERROR_TYPE;
	extern Type* RPC_CONTEXT_TYPE;
	extern Type* EVENT_FAKE_TYPE;

	extern Expression* NULL_VALUE;		extern Expression* NULL_VALUE;
	extern Expression* THIS_VALUE;		extern Expression* THIS_VALUE;
	extern Expression* SUPER_VALUE;		extern Expression* SUPER_VALUE;

tools/aidl/aidl.cpp

+19 −86

File changed.

Preview size limit exceeded, changes collapsed.

tools/aidl/aidl_language.h

+2 −9

Original line number	Original line	Diff line number	Diff line
	@@ -68,8 +68,7 @@ typedef struct method_type {

	enum {		enum {
	USER_DATA_TYPE = 12,		USER_DATA_TYPE = 12,
	INTERFACE_TYPE_BINDER,		INTERFACE_TYPE_BINDER
	INTERFACE_TYPE_RPC
	};		};

	typedef struct document_item_type {		typedef struct document_item_type {
	@@ -78,19 +77,13 @@ typedef struct document_item_type {
	} document_item_type;		} document_item_type;


	// for user_data_type.flattening_methods
	enum {
	PARCELABLE_DATA = 0x1,
	RPC_DATA = 0x2
	};

	typedef struct user_data_type {		typedef struct user_data_type {
	document_item_type document_item;		document_item_type document_item;
	buffer_type keyword_token; // only the first one		buffer_type keyword_token; // only the first one
	char* package;		char* package;
	buffer_type name;		buffer_type name;
	buffer_type semicolon_token;		buffer_type semicolon_token;
	int flattening_methods;		bool parcelable;
	} user_data_type;		} user_data_type;

	typedef struct interface_type {		typedef struct interface_type {