tools/net/sunrpc/xdrgen/generators/struct.py

   1 #!/usr/bin/env python3
   2 # ex: set filetype=python:
   3
   4 """Generate code to handle XDR struct types"""
   5
   6 from jinja2 import Environment
   7
   8 from generators import SourceGenerator, kernel_c_type
   9 from generators import create_jinja2_environment, get_jinja2_template
  10
  11 from xdr_ast import _XdrBasic, _XdrString
  12 from xdr_ast import _XdrFixedLengthOpaque, _XdrVariableLengthOpaque
  13 from xdr_ast import _XdrFixedLengthArray, _XdrVariableLengthArray
  14 from xdr_ast import _XdrOptionalData, _XdrStruct, _XdrDeclaration
  15 from xdr_ast import public_apis, get_header_name
  16
  17
  18 def 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
  25 def 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
  81 def 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
  93 def 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
 161 def 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
 173 def 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
 238 def 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
 250 def 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
 262 class 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)