Merge "Remove RPC interface Type" (02bc5488) · Commits · e / os / android_frameworks_base

tools/aidl/Android.mk

+0 −1

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

tools/aidl/Type.cpp

+38 −235

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

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

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

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

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

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

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

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

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

		STRING_TYPE = new StringType();
		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);

		CHAR_SEQUENCE_TYPE = new CharSequenceType();
		@@ -92,7 +88,7 @@ register_base_types()
		LIST_TYPE = new ListType();
		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);

		REMOTE_EXCEPTION_TYPE = new RemoteExceptionType();
		@@ -119,19 +115,9 @@ register_base_types()
		PARCELABLE_INTERFACE_TYPE = new ParcelableInterfaceType();
		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);

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

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

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

		string
		Type::InstantiableName() const
		{
		@@ -281,26 +258,6 @@ Type::ReadArrayFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
		+ 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
		Type::SetQualifiedName(const string& qualified)
		{
		@@ -324,20 +281,13 @@ Type::BuildWriteToParcelFlags(int flags)

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

		@@ -378,24 +328,10 @@ BasicType::ReadArrayFromParcel(StatementBlock* addTo, Variable* v, Variable* par
		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()
		: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));
		}

		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()
		: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));
		}

		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()
		: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));
		}

		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()
		: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()
		: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()
		: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()
		: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()
		: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()
		: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()
		: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()
		: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()
		: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()
		: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()
		: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));
		}

		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,
		bool builtIn, bool canWriteToParcel, bool canWriteToRpcData,
		bool builtIn, bool canWriteToParcel,
		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)
		{
		}
		@@ -918,12 +798,6 @@ UserDataType::CreatorName() const
		return QualifiedName() + ".CREATOR";
		}

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

		void
		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)));
		}

		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,
		bool builtIn, bool oneway,
		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)
		,m_oneway(oneway)
		{
		@@ -1075,7 +932,7 @@ InterfaceType::CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* pa

		GenericType::GenericType(const string& package, const string& name,
		const vector<Type*>& args)
		:Type(package, name, BUILT_IN, true, true, true)
		:Type(package, name, BUILT_IN, true, true)
		{
		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()
		: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	Diff line number	Diff line
		@@ -25,9 +25,9 @@ public:
		};

		Type(const string& name, int kind, bool canWriteToParcel,
		bool canWriteToRpcData, bool canBeOut);
		bool canBeOut);
		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);
		virtual ~Type();

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

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

		virtual void WriteToParcel(StatementBlock* addTo, Variable* v,
		@@ -62,11 +60,6 @@ public:
		virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
		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:
		void SetQualifiedName(const string& qualified);
		Expression* BuildWriteToParcelFlags(int flags);
		@@ -82,7 +75,6 @@ private:
		int m_declLine;
		int m_kind;
		bool m_canWriteToParcel;
		bool m_canWriteToRpcData;
		bool m_canBeOut;
		};

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

		virtual void WriteToParcel(StatementBlock* addTo, Variable* v,
		Variable* parcel, int flags);
		@@ -115,22 +102,12 @@ public:
		virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
		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:
		string m_marshallParcel;
		string m_unmarshallParcel;
		string m_writeArrayParcel;
		string m_createArrayParcel;
		string m_readArrayParcel;
		string m_marshallRpc;
		string m_unmarshallRpc;
		string m_writeArrayRpc;
		string m_createArrayRpc;
		string m_readArrayRpc;
		};

		class BooleanType : public Type
		@@ -151,11 +128,6 @@ public:
		Variable* parcel, Variable** cl);
		virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
		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
		@@ -176,11 +148,6 @@ public:
		Variable* parcel, Variable** cl);
		virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
		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);
		};


		@@ -204,11 +171,6 @@ public:
		Variable* parcel, Variable** cl);
		virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
		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
		@@ -345,22 +307,16 @@ public:
		Variable* parcel, Variable** cl);
		virtual void ReadFromParcel(StatementBlock* addTo, Variable* v,
		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
		{
		public:
		UserDataType(const string& package, const string& name,
		bool builtIn, bool canWriteToParcel, bool canWriteToRpcData,
		bool builtIn, bool canWriteToParcel,
		const string& declFile = "", int declLine = -1);

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

		virtual void WriteToParcel(StatementBlock* addTo, Variable* v,
		Variable* parcel, int flags);
		@@ -377,11 +333,6 @@ public:
		Variable* parcel, Variable** cl);
		virtual void ReadArrayFromParcel(StatementBlock* addTo, Variable* v,
		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
		@@ -427,17 +378,6 @@ private:
		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
		{
		public:
		@@ -460,11 +400,6 @@ public:
		virtual void ReadFromParcel(StatementBlock* addTo, Variable* v,
		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:
		string m_creator;
		};
		@@ -527,11 +462,6 @@ extern Type* PARCELABLE_INTERFACE_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* THIS_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	Diff line number	Diff line
		@@ -68,8 +68,7 @@ typedef struct method_type {

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

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


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

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

		typedef struct interface_type {