struct.py

  1#!/usr/bin/env python3
  2# ex: set filetype=python:
  3
  4"""Generate code to handle XDR struct types"""
  5
  6from jinja2 import Environment
  7
  8from generators import SourceGenerator, kernel_c_type
  9from generators import create_jinja2_environment, get_jinja2_template
 10
 11from xdr_ast import _XdrBasic, _XdrString
 12from xdr_ast import _XdrFixedLengthOpaque, _XdrVariableLengthOpaque
 13from xdr_ast import _XdrFixedLengthArray, _XdrVariableLengthArray
 14from xdr_ast import _XdrOptionalData, _XdrStruct, _XdrDeclaration
 15from xdr_ast import public_apis, get_header_name
 16
 17
 18def emit_struct_declaration(environment: Environment, node: _XdrStruct) -> None:
 19    """Emit one declaration pair for an XDR struct type"""
 20    if node.name in public_apis:
 21        template = get_jinja2_template(environment, "declaration", "close")
 22        print(template.render(name=node.name))
 23
 24
 25def emit_struct_member_definition(
 26    environment: Environment, field: _XdrDeclaration
 27) -> None:
 28    """Emit a definition for one field in an XDR struct"""
 29    if isinstance(field, _XdrBasic):
 30        template = get_jinja2_template(environment, "definition", field.template)
 31        print(
 32            template.render(
 33                name=field.name,
 34                type=kernel_c_type(field.spec),
 35                classifier=field.spec.c_classifier,
 36            )
 37        )
 38    elif isinstance(field, _XdrFixedLengthOpaque):
 39        template = get_jinja2_template(environment, "definition", field.template)
 40        print(
 41            template.render(
 42                name=field.name,
 43                size=field.size,
 44            )
 45        )
 46    elif isinstance(field, _XdrVariableLengthOpaque):
 47        template = get_jinja2_template(environment, "definition", field.template)
 48        print(template.render(name=field.name))
 49    elif isinstance(field, _XdrString):
 50        template = get_jinja2_template(environment, "definition", field.template)
 51        print(template.render(name=field.name))
 52    elif isinstance(field, _XdrFixedLengthArray):
 53        template = get_jinja2_template(environment, "definition", field.template)
 54        print(
 55            template.render(
 56                name=field.name,
 57                type=kernel_c_type(field.spec),
 58                size=field.size,
 59            )
 60        )
 61    elif isinstance(field, _XdrVariableLengthArray):
 62        template = get_jinja2_template(environment, "definition", field.template)
 63        print(
 64            template.render(
 65                name=field.name,
 66                type=kernel_c_type(field.spec),
 67                classifier=field.spec.c_classifier,
 68            )
 69        )
 70    elif isinstance(field, _XdrOptionalData):
 71        template = get_jinja2_template(environment, "definition", field.template)
 72        print(
 73            template.render(
 74                name=field.name,
 75                type=kernel_c_type(field.spec),
 76                classifier=field.spec.c_classifier,
 77            )
 78        )
 79
 80
 81def emit_struct_definition(environment: Environment, node: _XdrStruct) -> None:
 82    """Emit one definition for an XDR struct type"""
 83    template = get_jinja2_template(environment, "definition", "open")
 84    print(template.render(name=node.name))
 85
 86    for field in node.fields:
 87        emit_struct_member_definition(environment, field)
 88
 89    template = get_jinja2_template(environment, "definition", "close")
 90    print(template.render(name=node.name))
 91
 92
 93def emit_struct_member_decoder(
 94    environment: Environment, field: _XdrDeclaration
 95) -> None:
 96    """Emit a decoder for one field in an XDR struct"""
 97    if isinstance(field, _XdrBasic):
 98        template = get_jinja2_template(environment, "decoder", field.template)
 99        print(
100            template.render(
101                name=field.name,
102                type=field.spec.type_name,
103                classifier=field.spec.c_classifier,
104            )
105        )
106    elif isinstance(field, _XdrFixedLengthOpaque):
107        template = get_jinja2_template(environment, "decoder", field.template)
108        print(
109            template.render(
110                name=field.name,
111                size=field.size,
112            )
113        )
114    elif isinstance(field, _XdrVariableLengthOpaque):
115        template = get_jinja2_template(environment, "decoder", field.template)
116        print(
117            template.render(
118                name=field.name,
119                maxsize=field.maxsize,
120            )
121        )
122    elif isinstance(field, _XdrString):
123        template = get_jinja2_template(environment, "decoder", field.template)
124        print(
125            template.render(
126                name=field.name,
127                maxsize=field.maxsize,
128            )
129        )
130    elif isinstance(field, _XdrFixedLengthArray):
131        template = get_jinja2_template(environment, "decoder", field.template)
132        print(
133            template.render(
134                name=field.name,
135                type=field.spec.type_name,
136                size=field.size,
137                classifier=field.spec.c_classifier,
138            )
139        )
140    elif isinstance(field, _XdrVariableLengthArray):
141        template = get_jinja2_template(environment, "decoder", field.template)
142        print(
143            template.render(
144                name=field.name,
145                type=field.spec.type_name,
146                maxsize=field.maxsize,
147                classifier=field.spec.c_classifier,
148            )
149        )
150    elif isinstance(field, _XdrOptionalData):
151        template = get_jinja2_template(environment, "decoder", field.template)
152        print(
153            template.render(
154                name=field.name,
155                type=field.spec.type_name,
156                classifier=field.spec.c_classifier,
157            )
158        )
159
160
161def emit_struct_decoder(environment: Environment, node: _XdrStruct) -> None:
162    """Emit one decoder function for an XDR struct type"""
163    template = get_jinja2_template(environment, "decoder", "open")
164    print(template.render(name=node.name))
165
166    for field in node.fields:
167        emit_struct_member_decoder(environment, field)
168
169    template = get_jinja2_template(environment, "decoder", "close")
170    print(template.render())
171
172
173def emit_struct_member_encoder(
174    environment: Environment, field: _XdrDeclaration
175) -> None:
176    """Emit an encoder for one field in an XDR struct"""
177    if isinstance(field, _XdrBasic):
178        template = get_jinja2_template(environment, "encoder", field.template)
179        print(
180            template.render(
181                name=field.name,
182                type=field.spec.type_name,
183            )
184        )
185    elif isinstance(field, _XdrFixedLengthOpaque):
186        template = get_jinja2_template(environment, "encoder", field.template)
187        print(
188            template.render(
189                name=field.name,
190                size=field.size,
191            )
192        )
193    elif isinstance(field, _XdrVariableLengthOpaque):
194        template = get_jinja2_template(environment, "encoder", field.template)
195        print(
196            template.render(
197                name=field.name,
198                maxsize=field.maxsize,
199            )
200        )
201    elif isinstance(field, _XdrString):
202        template = get_jinja2_template(environment, "encoder", field.template)
203        print(
204            template.render(
205                name=field.name,
206                maxsize=field.maxsize,
207            )
208        )
209    elif isinstance(field, _XdrFixedLengthArray):
210        template = get_jinja2_template(environment, "encoder", field.template)
211        print(
212            template.render(
213                name=field.name,
214                type=field.spec.type_name,
215                size=field.size,
216            )
217        )
218    elif isinstance(field, _XdrVariableLengthArray):
219        template = get_jinja2_template(environment, "encoder", field.template)
220        print(
221            template.render(
222                name=field.name,
223                type=field.spec.type_name,
224                maxsize=field.maxsize,
225            )
226        )
227    elif isinstance(field, _XdrOptionalData):
228        template = get_jinja2_template(environment, "encoder", field.template)
229        print(
230            template.render(
231                name=field.name,
232                type=field.spec.type_name,
233                classifier=field.spec.c_classifier,
234            )
235        )
236
237
238def emit_struct_encoder(environment: Environment, node: _XdrStruct) -> None:
239    """Emit one encoder function for an XDR struct type"""
240    template = get_jinja2_template(environment, "encoder", "open")
241    print(template.render(name=node.name))
242
243    for field in node.fields:
244        emit_struct_member_encoder(environment, field)
245
246    template = get_jinja2_template(environment, "encoder", "close")
247    print(template.render())
248
249
250def emit_struct_maxsize(environment: Environment, node: _XdrStruct) -> None:
251    """Emit one maxsize macro for an XDR struct type"""
252    macro_name = get_header_name().upper() + "_" + node.name + "_sz"
253    template = get_jinja2_template(environment, "maxsize", "struct")
254    print(
255        template.render(
256            macro=macro_name,
257            width=" + ".join(node.symbolic_width()),
258        )
259    )
260
261
262class XdrStructGenerator(SourceGenerator):
263    """Generate source code for XDR structs"""
264
265    def __init__(self, language: str, peer: str):
266        """Initialize an instance of this class"""
267        self.environment = create_jinja2_environment(language, "struct")
268        self.peer = peer
269
270    def emit_declaration(self, node: _XdrStruct) -> None:
271        """Emit one declaration pair for an XDR struct type"""
272        emit_struct_declaration(self.environment, node)
273
274    def emit_definition(self, node: _XdrStruct) -> None:
275        """Emit one definition for an XDR struct type"""
276        emit_struct_definition(self.environment, node)
277
278    def emit_decoder(self, node: _XdrStruct) -> None:
279        """Emit one decoder function for an XDR struct type"""
280        emit_struct_decoder(self.environment, node)
281
282    def emit_encoder(self, node: _XdrStruct) -> None:
283        """Emit one encoder function for an XDR struct type"""
284        emit_struct_encoder(self.environment, node)
285
286    def emit_maxsize(self, node: _XdrStruct) -> None:
287        """Emit one maxsize macro for an XDR struct type"""
288        emit_struct_maxsize(self.environment, node)