Checkpoint adding @home RPC support to aidl (fdfe2ff8) · Commits · e / os / android_frameworks_base

tools/aidl/AST.cpp

+45 −1

Original line number	Diff line number	Diff line
		@@ -111,6 +111,21 @@ LiteralExpression::Write(FILE* to)
		fprintf(to, "%s", this->value.c_str());
		}

		StringLiteralExpression::StringLiteralExpression(const string& v)
		:value(v)
		{
		}

		StringLiteralExpression::~StringLiteralExpression()
		{
		}

		void
		StringLiteralExpression::Write(FILE* to)
		{
		fprintf(to, "\"%s\"", this->value.c_str());
		}

		Variable::Variable()
		:type(NULL),
		name(),
		@@ -277,6 +292,17 @@ MethodCall::MethodCall(const string& n)
		{
		}

		MethodCall::MethodCall(const string& n, int argc = 0, ...)
		:obj(NULL),
		clazz(NULL),
		name(n)
		{
		va_list args;
		va_start(args, argc);
		init(argc, args);
		va_end(args);
		}

		MethodCall::MethodCall(Expression* o, const string& n)
		:obj(o),
		clazz(NULL),
		@@ -367,10 +393,28 @@ NewExpression::NewExpression(Type* t)
		{
		}

		NewExpression::NewExpression(Type* t, int argc = 0, ...)
		:type(t)
		{
		va_list args;
		va_start(args, argc);
		init(argc, args);
		va_end(args);
		}

		NewExpression::~NewExpression()
		{
		}

		void
		NewExpression::init(int n, va_list args)
		{
		for (int i=0; i<n; i++) {
		Expression* expression = (Expression)va_arg(args, void);
		this->arguments.push_back(expression);
		}
		}

		void
		NewExpression::Write(FILE* to)
		{
		@@ -678,7 +722,7 @@ Method::Write(FILE* to)
		fprintf(to, "%s\n", this->comment.c_str());
		}

		WriteModifiers(to, this->modifiers, SCOPE_MASK \| STATIC \| FINAL \| OVERRIDE);
		WriteModifiers(to, this->modifiers, SCOPE_MASK \| STATIC \| ABSTRACT \| FINAL \| OVERRIDE);

		if (this->returnType != NULL) {
		string dim;

tools/aidl/AST.h

+15 −0

Original line number	Diff line number	Diff line
		@@ -54,6 +54,16 @@ struct LiteralExpression : public Expression
		virtual void Write(FILE* to);
		};

		// TODO: also escape the contents. not needed for now
		struct StringLiteralExpression : public Expression
		{
		string value;

		StringLiteralExpression(const string& value);
		virtual ~StringLiteralExpression();
		virtual void Write(FILE* to);
		};

		struct Variable : public Expression
		{
		Type* type;
		@@ -146,6 +156,7 @@ struct MethodCall : public Expression
		vector<string> exceptions;

		MethodCall(const string& name);
		MethodCall(const string& name, int argc, ...);
		MethodCall(Expression* obj, const string& name);
		MethodCall(Type* clazz, const string& name);
		MethodCall(Expression* obj, const string& name, int argc, ...);
		@@ -174,8 +185,12 @@ struct NewExpression : public Expression
		vector<Expression*> arguments;

		NewExpression(Type* type);
		NewExpression(Type* type, int argc, ...);
		virtual ~NewExpression();
		virtual void Write(FILE* to);

		private:
		void init(int n, va_list args);
		};

		struct NewArrayExpression : public Expression

tools/aidl/Android.mk

+3 −1

Original line number	Diff line number	Diff line
		@@ -17,7 +17,9 @@ LOCAL_SRC_FILES := \
		search_path.cpp \
		AST.cpp \
		Type.cpp \
		generate_java.cpp
		generate_java.cpp \
		generate_java_binder.cpp \
		generate_java_rpc.cpp

		LOCAL_CFLAGS := -g
		LOCAL_MODULE := aidl

tools/aidl/Type.cpp

+89 −0

Original line number	Diff line number	Diff line
		@@ -11,6 +11,7 @@ Type* LONG_TYPE;
		Type* FLOAT_TYPE;
		Type* DOUBLE_TYPE;
		Type* STRING_TYPE;
		Type* OBJECT_TYPE;
		Type* CHAR_SEQUENCE_TYPE;
		Type* TEXT_UTILS_TYPE;
		Type* REMOTE_EXCEPTION_TYPE;
		@@ -21,9 +22,17 @@ Type* BINDER_NATIVE_TYPE;
		Type* BINDER_PROXY_TYPE;
		Type* PARCEL_TYPE;
		Type* PARCELABLE_INTERFACE_TYPE;
		Type* CONTEXT_TYPE;
		Type* MAP_TYPE;
		Type* LIST_TYPE;
		Type* CLASSLOADER_TYPE;
		Type* RPC_SERVICE_BASE_TYPE;
		Type* RPC_DATA_TYPE;
		Type* RPC_BROKER_TYPE;
		Type* RPC_ENDPOINT_INFO_TYPE;
		Type* RPC_RESULT_HANDLER_TYPE;
		Type* RPC_ERROR_TYPE;
		Type* RPC_ERROR_LISTENER_TYPE;

		Expression* NULL_VALUE;
		Expression* THIS_VALUE;
		@@ -66,6 +75,10 @@ register_base_types()
		STRING_TYPE = new StringType();
		NAMES.Add(STRING_TYPE);

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

		CHAR_SEQUENCE_TYPE = new CharSequenceType();
		NAMES.Add(CHAR_SEQUENCE_TYPE);

		@@ -103,6 +116,38 @@ 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);
		NAMES.Add(CONTEXT_TYPE);

		RPC_SERVICE_BASE_TYPE = new Type("com.android.athome.service", "AndroidAtHomeService",
		Type::BUILT_IN, false, false);
		NAMES.Add(RPC_SERVICE_BASE_TYPE);

		RPC_DATA_TYPE = new Type("com.android.athome.rpc", "RpcData",
		Type::BUILT_IN, false, false);
		NAMES.Add(RPC_DATA_TYPE);

		RPC_BROKER_TYPE = new Type("com.android.athome.utils", "AndroidAtHomeBroker",
		Type::BUILT_IN, false, false);
		NAMES.Add(RPC_BROKER_TYPE);

		RPC_ENDPOINT_INFO_TYPE = new ParcelableType("com.android.athome.rpc", "EndpointInfo",
		true, __FILE__, __LINE__);
		NAMES.Add(RPC_ENDPOINT_INFO_TYPE);

		RPC_RESULT_HANDLER_TYPE = new ParcelableType("com.android.athome.rpc", "RpcResultHandler",
		true, __FILE__, __LINE__);
		NAMES.Add(RPC_RESULT_HANDLER_TYPE);

		RPC_ERROR_TYPE = new ParcelableType("com.android.athome.rpc", "RpcError",
		true, __FILE__, __LINE__);
		NAMES.Add(RPC_ERROR_TYPE);

		RPC_ERROR_LISTENER_TYPE = new Type("com.android.athome.rpc", "RpcErrorHandler",
		Type::BUILT_IN, false, false);
		NAMES.Add(RPC_ERROR_LISTENER_TYPE);

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

		@@ -243,6 +288,36 @@ 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=%sn",
		__FILE__, __LINE__, m_qualifiedName.c_str());
		addTo->Add(new LiteralExpression("/* WriteToRpcData error "
		+ m_qualifiedName + " */"));
		}

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

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

		void
		Type::SetQualifiedName(const string& qualified)
		{
		@@ -458,6 +533,20 @@ 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()

tools/aidl/Type.h

+25 −0

Original line number	Diff line number	Diff line
		@@ -59,6 +59,14 @@ 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);
		virtual void ReadFromRpcData(StatementBlock* addTo, Expression* k, Variable* v,
		Variable* data, Variable** cl);


		protected:
		void SetQualifiedName(const string& qualified);
		Expression* BuildWriteToParcelFlags(int flags);
		@@ -169,6 +177,11 @@ 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
		@@ -438,11 +451,13 @@ extern Namespace NAMES;

		extern Type* VOID_TYPE;
		extern Type* BOOLEAN_TYPE;
		extern Type* BYTE_TYPE;
		extern Type* CHAR_TYPE;
		extern Type* INT_TYPE;
		extern Type* LONG_TYPE;
		extern Type* FLOAT_TYPE;
		extern Type* DOUBLE_TYPE;
		extern Type* OBJECT_TYPE;
		extern Type* STRING_TYPE;
		extern Type* CHAR_SEQUENCE_TYPE;
		extern Type* TEXT_UTILS_TYPE;
		@@ -455,6 +470,16 @@ extern Type* BINDER_PROXY_TYPE;
		extern Type* PARCEL_TYPE;
		extern Type* PARCELABLE_INTERFACE_TYPE;

		extern Type* CONTEXT_TYPE;

		extern Type* RPC_SERVICE_BASE_TYPE;
		extern Type* RPC_DATA_TYPE;
		extern Type* RPC_BROKER_TYPE;
		extern Type* RPC_ENDPOINT_INFO_TYPE;
		extern Type* RPC_RESULT_HANDLER_TYPE;
		extern Type* RPC_ERROR_TYPE;
		extern Type* RPC_ERROR_LISTENER_TYPE;

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