PDL: Move GenBounds to GenGetter am: ac2d60d3f2 (fdf87751) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/packet/parser/fields/array_field.cc

+36 −71

Original line number	Diff line number	Diff line
		@@ -15,25 +15,26 @@
		*/

		#include "fields/array_field.h"

		#include "util.h"

		const std::string ArrayField::kFieldType = "ArrayField";

		ArrayField::ArrayField(std::string name, int element_size, int fixed_size, ParseLocation loc)
		: PacketField(name, loc), element_size_(element_size), fixed_size_(fixed_size) {
		if (element_size_ > 64 \|\| element_size_ < 0)
		ERROR(this) << __func__ << ": Not implemented for element size = " << element_size_;
		// Make sure the element_size is a multiple of 8.
		ArrayField::ArrayField(std::string name, int element_size, int array_size, ParseLocation loc)
		: PacketField(name, loc), element_field_(new ScalarField("val", element_size, loc)), element_size_(element_size),
		array_size_(array_size) {
		if (element_size > 64 \|\| element_size < 0)
		ERROR(this) << __func__ << ": Not implemented for element size = " << element_size;
		if (element_size % 8 != 0) {
		ERROR(this) << "Can only have arrays with elements that are byte aligned (" << element_size << ")";
		}
		}

		ArrayField::ArrayField(std::string name, TypeDef* type_def, int fixed_size, ParseLocation loc)
		: PacketField(name, loc), element_size_(type_def->size_), type_def_(type_def), fixed_size_(fixed_size) {
		// If the element type is not variable sized, make sure that it is byte aligned.
		if (type_def_->size_ != -1 && type_def_->size_ % 8 != 0) {
		ERROR(this) << "Can only have arrays with elements that are byte aligned (" << type_def_->size_ << ")";
		ArrayField::ArrayField(std::string name, TypeDef* type_def, int array_size, ParseLocation loc)
		: PacketField(name, loc), element_field_(type_def->GetNewField("val", loc)),
		element_size_(element_field_->GetSize()), array_size_(array_size) {
		if (!element_size_.empty() && element_size_.bits() % 8 != 0) {
		ERROR(this) << "Can only have arrays with elements that are byte aligned (" << element_size_ << ")";
		}
		}

		@@ -42,16 +43,15 @@ const std::string& ArrayField::GetFieldType() const {
		}

		Size ArrayField::GetSize() const {
		if (element_size_ != -1) {
		return Size(fixed_size_ * element_size_);
		if (!element_size_.empty() && !element_size_.has_dynamic()) {
		return Size(array_size_ * element_size_.bits());
		}
		return Size();
		}

		Size ArrayField::GetBuilderSize() const {
		if (element_size_ != -1) {
		std::string ret = "(" + std::to_string(fixed_size_) + " * " + std::to_string(element_size_) + ")";
		return ret;
		if (!element_size_.empty() && !element_size_.has_dynamic()) {
		return GetSize();
		} else {
		std::string ret = "[this](){ size_t length = 0; for (const auto& elem : " + GetName() +
		"_) { length += elem.size() * 8; } return length; }()";
		@@ -60,27 +60,21 @@ Size ArrayField::GetBuilderSize() const {
		}

		std::string ArrayField::GetDataType() const {
		if (type_def_ != nullptr) {
		return "std::array<" + type_def_->name_ + "," + std::to_string(fixed_size_) + ">";
		}
		return "std::array<" + util::GetTypeForSize(element_size_) + "," + std::to_string(fixed_size_) + ">";
		return "std::array<" + element_field_->GetDataType() + "," + std::to_string(array_size_) + ">";
		}

		void ArrayField::GenExtractor(std::ostream& s, Size start_offset, Size end_offset) const {
		GenBounds(s, start_offset, end_offset, GetSize());

		s << "auto it = begin_it + field_begin;";

		s << GetDataType() << " value;";
		std::string type = (type_def_ != nullptr) ? type_def_->name_ : util::GetTypeForSize(element_size_);
		s << GetDataType() << "::iterator ret_it = value.begin();";
		if (element_size_ != -1) {
		s << "while (it + sizeof(" << type << ") <= begin_it + field_end && ret_it < value.end()) {";
		s << "*ret_it = it.extract<" << type << ">();";
		void ArrayField::GenExtractor(std::ostream& s, int num_leading_bits) const {
		s << GetDataType() << "::iterator ret_it = " << GetName() << "_ptr->begin();";
		s << "auto " << element_field_->GetName() << "_it = " << GetName() << "_it;";
		if (!element_size_.empty() && !element_size_.has_dynamic()) {
		s << "while (" << element_field_->GetName() << "_it.NumBytesRemaining() >= " << element_size_.bytes();
		s << " && ret_it < " << GetName() << "_ptr->end()) {";
		} else {
		s << "while (it < begin_it + field_end && ret_it < value.end()) {";
		s << "it = " << type_def_->name_ << "::Parse(ret_it, it);";
		s << "while (" << element_field_->GetName() << "_it.NumBytesRemaining() > 0 ";
		s << " && ret_it < " << GetName() << "_ptr->end()) {";
		}
		s << element_field_->GetDataType() << "* " << element_field_->GetName() << "_ptr = ret_it;";
		element_field_->GenExtractor(s, num_leading_bits);
		s << "ret_it++;";
		s << "}";
		}
		@@ -90,29 +84,24 @@ void ArrayField::GenGetter(std::ostream& s, Size start_offset, Size end_offset)
		s << " Get" << util::UnderscoreToCamelCase(GetName()) << "() {";
		s << "ASSERT(was_validated_);";
		s << "size_t end_index = size();";
		s << "auto begin_it = begin();";
		s << "auto to_bound = begin();";

		GenExtractor(s, start_offset, end_offset);
		int num_leading_bits = GenBounds(s, start_offset, end_offset);
		s << GetDataType() << " " << GetName() << "_value;";
		s << GetDataType() << "* " << GetName() << "_ptr = &" << GetName() << "_value;";
		GenExtractor(s, num_leading_bits);

		s << "return value;";
		s << "return " << GetName() << "_value;";
		s << "}\n";
		}

		bool ArrayField::GenBuilderParameter(std::ostream& s) const {
		if (type_def_ != nullptr) {
		s << "const std::array<" << type_def_->GetTypeName() << "," << fixed_size_ << ">& " << GetName();
		} else {
		s << "const std::array<" << util::GetTypeForSize(element_size_) << "," << fixed_size_ << ">& " << GetName();
		}
		s << "const std::array<" << element_field_->GetDataType() << "," << array_size_ << ">& " << GetName();
		return true;
		}

		bool ArrayField::GenBuilderMember(std::ostream& s) const {
		if (type_def_ != nullptr) {
		s << "std::array<" << type_def_->GetTypeName() << "," << fixed_size_ << "> " << GetName();
		} else {
		s << "std::array<" << util::GetTypeForSize(element_size_) << "," << fixed_size_ << "> " << GetName();
		}
		s << "std::array<" << element_field_->GetDataType() << "," << array_size_ << "> " << GetName();
		return true;
		}

		@@ -125,20 +114,8 @@ void ArrayField::GenParameterValidator(std::ostream&) const {
		}

		void ArrayField::GenInserter(std::ostream& s) const {
		s << "for (const auto& val : " << GetName() << "_) {";
		if (IsEnumArray()) {
		s << "insert(static_cast<" << util::GetTypeForSize(type_def_->size_) << ">(val), i, " << type_def_->size_ << ");";
		} else if (IsCustomFieldArray()) {
		if (type_def_->size_ == -1) {
		s << "val.Serialize(i);";
		} else {
		s << "insert(val, i);";
		}
		} else if (IsStructArray()) {
		s << "val.Serialize(i);";
		} else {
		s << "insert(val, i, " << element_size_ << ");";
		}
		s << "for (const auto& val_ : " << GetName() << "_) {";
		element_field_->GenInserter(s);
		s << "}\n";
		}

		@@ -149,15 +126,3 @@ void ArrayField::GenValidator(std::ostream&) const {
		// Other than that there is nothing that arrays need to be validated on other than length so nothing needs to
		// be done here.
		}

		bool ArrayField::IsEnumArray() const {
		return type_def_ != nullptr && type_def_->GetDefinitionType() == TypeDef::Type::ENUM;
		}

		bool ArrayField::IsCustomFieldArray() const {
		return type_def_ != nullptr && type_def_->GetDefinitionType() == TypeDef::Type::CUSTOM;
		}

		bool ArrayField::IsStructArray() const {
		return type_def_ != nullptr && type_def_->GetDefinitionType() == TypeDef::Type::STRUCT;
		}

system/gd/packet/parser/fields/array_field.h

+7 −16

Original line number	Diff line number	Diff line
		@@ -16,12 +16,9 @@

		#pragma once

		#include "custom_field_def.h"
		#include "enum_def.h"
		#include "fields/count_field.h"
		#include "fields/packet_field.h"
		#include "fields/size_field.h"
		#include "fields/all_fields.h"
		#include "parse_location.h"
		#include "type_def.h"

		class ArrayField : public PacketField {
		public:
		@@ -39,7 +36,7 @@ class ArrayField : public PacketField {

		virtual std::string GetDataType() const override;

		virtual void GenExtractor(std::ostream& s, Size start_offset, Size end_offset) const override;
		virtual void GenExtractor(std::ostream& s, int num_leading_bits) const override;

		virtual void GenGetter(std::ostream& s, Size start_offset, Size end_offset) const override;

		@@ -55,17 +52,11 @@ class ArrayField : public PacketField {

		virtual void GenValidator(std::ostream&) const override;

		bool IsEnumArray() const;

		bool IsCustomFieldArray() const;

		bool IsStructArray() const;

		const std::string name_;

		const int element_size_{-1}; // in bits
		const TypeDef* type_def_{nullptr};
		const PacketField* element_field_{nullptr};

		const Size element_size_{};

		// Fixed size array or dynamic size, size is always in bytes, unless it is count.
		const int fixed_size_{-1};
		const int array_size_{-1};
		};

system/gd/packet/parser/fields/body_field.cc

+1 −1

Original line number	Diff line number	Diff line
		@@ -33,7 +33,7 @@ std::string BodyField::GetDataType() const {
		return "BodyType";
		}

		void BodyField::GenExtractor(std::ostream&, Size, Size) const {}
		void BodyField::GenExtractor(std::ostream&, int) const {}

		void BodyField::GenGetter(std::ostream&, Size, Size) const {}

system/gd/packet/parser/fields/body_field.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -32,7 +32,7 @@ class BodyField : public PacketField {

		virtual std::string GetDataType() const override;

		virtual void GenExtractor(std::ostream& s, Size start_offset, Size end_offset) const override;
		virtual void GenExtractor(std::ostream& s, int num_leading_bits) const override;

		virtual void GenGetter(std::ostream&, Size, Size) const override;

system/gd/packet/parser/fields/checksum_field.cc

+1 −1

Original line number	Diff line number	Diff line
		@@ -30,7 +30,7 @@ std::string ChecksumField::GetDataType() const {
		return type_name_;
		}

		void ChecksumField::GenExtractor(std::ostream&, Size, Size) const {}
		void ChecksumField::GenExtractor(std::ostream&, int) const {}

		void ChecksumField::GenGetter(std::ostream&, Size, Size) const {}