| #!/usr/bin/env python |
| # Copyright (c) 2022 Project CHIP Authors |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| import enum |
| import logging |
| import re |
| |
| from idl.generators import CodeGenerator, GeneratorStorage |
| from idl.matter_idl_types import Idl, Field, Attribute, Cluster, ClusterSide |
| from idl import matter_idl_types |
| from idl.generators.types import (ParseDataType, BasicString, BasicInteger, FundamentalType, |
| IdlType, IdlEnumType, IdlBitmapType, TypeLookupContext) |
| from typing import Union, List, Set |
| |
| |
| def camel_to_const(s): |
| return re.sub("([a-z])([A-Z])", lambda y: y.group(1) + "_" + y.group(2), s).upper() |
| |
| |
| def create_lookup_context(idl: Idl, cluster: Cluster) -> TypeLookupContext: |
| """ |
| A filter to mark a lookup context to be within a specific cluster. |
| |
| This is used to specify how structure/enum/other names are looked up. |
| Generally one looks up within the specific cluster then if cluster does |
| not contain a definition, we loop at global namespacing. |
| """ |
| return TypeLookupContext(idl, cluster) |
| |
| |
| def get_field_info(definition: Field, cluster: Cluster, idl: Idl): |
| context = create_lookup_context(idl, cluster) |
| actual = ParseDataType(definition.data_type, context) |
| |
| if type(actual) == IdlEnumType or type(actual) == IdlBitmapType: |
| actual = actual.base_type |
| |
| if type(actual) == BasicString: |
| return 'OctetString', 'char', actual.max_length, \ |
| 'ZCL_%s_ATTRIBUTE_TYPE' % actual.idl_name.upper() |
| |
| if type(actual) == BasicInteger: |
| name = actual.idl_name.upper() |
| ty = "int%d_t" % actual.power_of_two_bits |
| if not actual.is_signed: |
| ty = "u" + ty |
| return "", ty, actual.byte_count, "ZCL_%s_ATTRIBUTE_TYPE" % name |
| if type(actual) == FundamentalType: |
| if actual == FundamentalType.BOOL: |
| return "", "bool", 1, "ZCL_BOOLEAN_ATTRIBUTE_TYPE" |
| if actual == FundamentalType.FLOAT: |
| return "", "float", 4, "ZCL_SINGLE_ATTRIBUTE_TYPE" |
| if actual == FundamentalType.DOUBLE: |
| return "", "double", 8, "ZCL_DOUBLE_ATTRIBUTE_TYPE" |
| logging.warn('Unknown fundamental type: %r' % actual) |
| return None |
| if type(actual) == IdlType: |
| return '', actual.idl_name, 'sizeof(%s)' % actual.idl_name, \ |
| 'ZCL_STRUCT_ATTRIBUTE_TYPE' |
| logging.warn('Unknown type: %r' % actual) |
| return None |
| |
| |
| def get_raw_size_and_type(attr: Attribute, cluster: Cluster, idl: Idl): |
| container, cType, size, matterType = get_field_info(attr.definition, cluster, idl) |
| if attr.definition.is_list: |
| return 'ZCL_ARRAY_ATTRIBUTE_TYPE, {}'.format(size) |
| return '{}, {}'.format(matterType, size) |
| |
| |
| def get_field_type(definition: Field, cluster: Cluster, idl: Idl): |
| container, cType, size, matterType = get_field_info(definition, cluster, idl) |
| if container == 'OctetString': |
| return 'std::string' |
| if definition.is_list: |
| cType = 'std::vector<{}>'.format(cType) |
| if definition.is_nullable: |
| cType = '::chip::app::DataModel::Nullable<{}>'.format(cType) |
| if definition.is_nullable: |
| cType = '::chip::Optional<{}>'.format(cType) |
| return cType |
| |
| |
| def get_attr_type(attr: Attribute, cluster: Cluster, idl: Idl): |
| return get_field_type(attr.definition, cluster, idl) |
| |
| |
| def get_attr_init(attr: Attribute, cluster: Cluster, idl: Idl): |
| if attr.definition.name == 'clusterRevision': |
| return ', ZCL_' + camel_to_const(cluster.name) + '_CLUSTER_REVISION' |
| return '' |
| |
| |
| def get_attr_mask(attr: Attribute, cluster: Cluster, idl: Idl): |
| masks = [] |
| if attr.is_writable: |
| masks.append('ATTRIBUTE_MASK_WRITABLE') |
| if masks: |
| return ' | '.join(masks) |
| return '0' |
| |
| |
| def get_dynamic_endpoint(idl: Idl): |
| for ep in idl.endpoints: |
| if ep.number == 2: |
| return ep |
| |
| |
| def is_dynamic_cluster(cluster: Cluster, idl: Idl): |
| ep = get_dynamic_endpoint(idl) |
| if not ep: |
| return True |
| for c in ep.server_clusters: |
| if cluster.name == c.name: |
| return True |
| return False |
| |
| |
| class BridgeGenerator(CodeGenerator): |
| """ |
| Generation of bridge cpp code for matter. |
| """ |
| |
| def __init__(self, storage: GeneratorStorage, idl: Idl): |
| """ |
| Inintialization is specific for cpp generation and will add |
| filters as required by the cpp .jinja templates to function. |
| """ |
| super().__init__(storage, idl) |
| |
| self.jinja_env.filters['getType'] = get_attr_type |
| self.jinja_env.filters['getRawSizeAndType'] = get_raw_size_and_type |
| self.jinja_env.filters['getField'] = get_field_type |
| self.jinja_env.filters['getMask'] = get_attr_mask |
| self.jinja_env.filters['getInit'] = get_attr_init |
| self.jinja_env.filters['dynamicCluster'] = is_dynamic_cluster |
| # constcase will transform ID to I_D which is not what we want |
| # instead make the requirement a transition from lower to upper |
| self.jinja_env.filters['cameltoconst'] = camel_to_const |
| |
| def internal_render_all(self): |
| """ |
| Renders C++ |
| """ |
| for cluster in self.idl.clusters: |
| if not is_dynamic_cluster(cluster, self.idl): |
| continue |
| |
| if cluster.side != ClusterSide.SERVER: |
| output_file_name = "bridge/%sServer.h" % cluster.name |
| else: |
| output_file_name = "bridge/%s.h" % cluster.name |
| |
| self.internal_render_one_output( |
| template_path="bridge/BridgeClustersCpp.jinja", |
| output_file_name=output_file_name, |
| vars={ |
| 'cluster': cluster, |
| 'idl': self.idl, |
| } |
| ) |
| |
| self.internal_render_one_output( |
| template_path="bridge/BridgeClustersCommon.jinja", |
| output_file_name="bridge/BridgeClustersImpl.h", |
| vars={ |
| 'clusters': self.idl.clusters, |
| 'idl': self.idl, |
| } |
| ) |
| |
| self.internal_render_one_output( |
| template_path="bridge/BridgeClustersGlobalStructs.jinja", |
| output_file_name="bridge/BridgeGlobalStructs.h", |
| vars={ |
| 'idl': self.idl, |
| 'structs': self.idl.structs, |
| } |
| ) |
