| #!/usr/bin/env python3 | |
| # ex: set filetype=python: | |
| """Generate code to handle XDR struct types""" | |
| from jinja2 import Environment | |
| from generators import SourceGenerator, kernel_c_type | |
| from generators import create_jinja2_environment, get_jinja2_template | |
| from xdr_ast import _XdrBasic, _XdrString | |
| from xdr_ast import _XdrFixedLengthOpaque, _XdrVariableLengthOpaque | |
| from xdr_ast import _XdrFixedLengthArray, _XdrVariableLengthArray | |
| from xdr_ast import _XdrOptionalData, _XdrStruct, _XdrDeclaration | |
| from xdr_ast import public_apis, get_header_name, aggregate_members | |
| from xdr_ast import pages_members, pages_member_maxsize, pages_member_is_decoded | |
| def aggregate_hook_base(struct_name: str) -> str: | |
| """Return the application hook base name for a struct's aggregate members. | |
| The pragma header name prefixes it so two programs that share a | |
| type name (nfs_acl2 vs nfs_acl3) derive distinct external hook | |
| symbols. All marked members of one struct share a hook set; the | |
| cursor's member_id tells them apart. | |
| """ | |
| return "_".join((get_header_name(), struct_name)) | |
| def aggregate_member_symbol(struct_name: str, member_name: str) -> str: | |
| """Return the symbolic member id for one marked aggregate member. | |
| The generated framing sets the cursor's member_id to this constant | |
| and the hooks compare against it. The enum in aggregate_hooks.j2 | |
| assigns the values implicitly in field order, so a hook that | |
| compared against the bare integer would silently bind to the | |
| wrong member once the specification's members were reordered. | |
| """ | |
| return "_".join((aggregate_hook_base(struct_name), member_name)).upper() | |
| def emit_struct_declaration(environment: Environment, node: _XdrStruct) -> None: | |
| """Emit one declaration pair for an XDR struct type""" | |
| if node.name in public_apis: | |
| template = get_jinja2_template(environment, "declaration", "close") | |
| print(template.render(name=node.name)) | |
| marked = [ | |
| field | |
| for field in node.fields | |
| if (node.name, field.name) in aggregate_members | |
| ] | |
| if marked: | |
| template = get_jinja2_template( | |
| environment, "declaration", "aggregate_hooks" | |
| ) | |
| print( | |
| template.render( | |
| hook=aggregate_hook_base(node.name), | |
| c_type=kernel_c_type(marked[0].spec), | |
| classifier=marked[0].spec.c_classifier, | |
| members=[ | |
| aggregate_member_symbol(node.name, field.name) | |
| for field in marked | |
| ], | |
| ) | |
| ) | |
| def emit_struct_member_definition( | |
| environment: Environment, field: _XdrDeclaration, struct_name: str, peer: str | |
| ) -> None: | |
| """Emit a definition for one field in an XDR struct""" | |
| if peer == "server" and pages_member_is_decoded(struct_name, field.name): | |
| template = get_jinja2_template(environment, "definition", "pages_opaque") | |
| print(template.render(name=field.name)) | |
| return | |
| if isinstance(field, _XdrBasic): | |
| template = get_jinja2_template(environment, "definition", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| type=kernel_c_type(field.spec), | |
| classifier=field.spec.c_classifier, | |
| ) | |
| ) | |
| elif isinstance(field, _XdrFixedLengthOpaque): | |
| template = get_jinja2_template(environment, "definition", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| size=field.size, | |
| ) | |
| ) | |
| elif isinstance(field, _XdrVariableLengthOpaque): | |
| template = get_jinja2_template(environment, "definition", field.template) | |
| print(template.render(name=field.name)) | |
| elif isinstance(field, _XdrString): | |
| template = get_jinja2_template(environment, "definition", field.template) | |
| print(template.render(name=field.name)) | |
| elif isinstance(field, _XdrFixedLengthArray): | |
| template = get_jinja2_template(environment, "definition", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| type=kernel_c_type(field.spec), | |
| size=field.size, | |
| ) | |
| ) | |
| elif isinstance(field, _XdrVariableLengthArray): | |
| template = get_jinja2_template(environment, "definition", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| type=kernel_c_type(field.spec), | |
| classifier=field.spec.c_classifier, | |
| ) | |
| ) | |
| elif isinstance(field, _XdrOptionalData): | |
| template = get_jinja2_template(environment, "definition", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| type=kernel_c_type(field.spec), | |
| classifier=field.spec.c_classifier, | |
| ) | |
| ) | |
| def emit_struct_definition( | |
| environment: Environment, node: _XdrStruct, peer: str | |
| ) -> None: | |
| """Emit one definition for an XDR struct type""" | |
| template = get_jinja2_template(environment, "definition", "open") | |
| print(template.render(name=node.name)) | |
| for field in node.fields: | |
| emit_struct_member_definition(environment, field, node.name, peer) | |
| template = get_jinja2_template(environment, "definition", "close") | |
| print(template.render(name=node.name)) | |
| def emit_struct_member_decoder( | |
| environment: Environment, | |
| field: _XdrDeclaration, | |
| struct_name: str, | |
| peer: str, | |
| ) -> None: | |
| """Emit a decoder for one field in an XDR struct""" | |
| if peer == "server" and pages_member_is_decoded(struct_name, field.name): | |
| template = get_jinja2_template(environment, "decoder", "pages_opaque") | |
| print( | |
| template.render( | |
| name=field.name, | |
| maxsize=pages_member_maxsize(field), | |
| ) | |
| ) | |
| return | |
| if isinstance(field, _XdrVariableLengthArray) and ( | |
| (struct_name, field.name) in aggregate_members | |
| ): | |
| if peer != "server": | |
| raise NotImplementedError( | |
| "pragma aggregate is server-side only; " | |
| + peer | |
| + " generation is not yet supported" | |
| ) | |
| template = get_jinja2_template(environment, "decoder", "aggregate_array") | |
| print( | |
| template.render( | |
| name=field.name, | |
| type=field.spec.type_name, | |
| c_type=kernel_c_type(field.spec), | |
| classifier=field.spec.c_classifier, | |
| maxsize=field.maxsize, | |
| hook=aggregate_hook_base(struct_name), | |
| member_sym=aggregate_member_symbol(struct_name, field.name), | |
| ) | |
| ) | |
| return | |
| if isinstance(field, _XdrOptionalData) and ( | |
| (struct_name, field.name) in aggregate_members | |
| ): | |
| if peer != "server": | |
| raise NotImplementedError( | |
| "pragma aggregate is server-side only; " | |
| + peer | |
| + " generation is not yet supported" | |
| ) | |
| template = get_jinja2_template(environment, "decoder", "aggregate_optional") | |
| print( | |
| template.render( | |
| name=field.name, | |
| type=field.spec.type_name, | |
| c_type=kernel_c_type(field.spec), | |
| classifier=field.spec.c_classifier, | |
| hook=aggregate_hook_base(struct_name), | |
| member_sym=aggregate_member_symbol(struct_name, field.name), | |
| ) | |
| ) | |
| return | |
| if isinstance(field, _XdrBasic): | |
| template = get_jinja2_template(environment, "decoder", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| type=field.spec.type_name, | |
| classifier=field.spec.c_classifier, | |
| ) | |
| ) | |
| elif isinstance(field, _XdrFixedLengthOpaque): | |
| template = get_jinja2_template(environment, "decoder", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| size=field.size, | |
| ) | |
| ) | |
| elif isinstance(field, _XdrVariableLengthOpaque): | |
| template = get_jinja2_template(environment, "decoder", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| maxsize=field.maxsize, | |
| ) | |
| ) | |
| elif isinstance(field, _XdrString): | |
| template = get_jinja2_template(environment, "decoder", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| maxsize=field.maxsize, | |
| ) | |
| ) | |
| elif isinstance(field, _XdrFixedLengthArray): | |
| template = get_jinja2_template(environment, "decoder", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| type=field.spec.type_name, | |
| size=field.size, | |
| classifier=field.spec.c_classifier, | |
| ) | |
| ) | |
| elif isinstance(field, _XdrVariableLengthArray): | |
| template = get_jinja2_template(environment, "decoder", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| type=field.spec.type_name, | |
| maxsize=field.maxsize, | |
| classifier=field.spec.c_classifier, | |
| ) | |
| ) | |
| elif isinstance(field, _XdrOptionalData): | |
| template = get_jinja2_template(environment, "decoder", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| type=field.spec.type_name, | |
| classifier=field.spec.c_classifier, | |
| ) | |
| ) | |
| def emit_struct_decoder( | |
| environment: Environment, node: _XdrStruct, peer: str | |
| ) -> None: | |
| """Emit one decoder function for an XDR struct type""" | |
| template = get_jinja2_template(environment, "decoder", "open") | |
| print(template.render(name=node.name)) | |
| for field in node.fields: | |
| emit_struct_member_decoder(environment, field, node.name, peer) | |
| # The optional-data aggregate decoder fails and closes the | |
| # function; the members after it are never decoded. | |
| if isinstance(field, _XdrOptionalData) and ( | |
| (node.name, field.name) in aggregate_members | |
| ): | |
| return | |
| template = get_jinja2_template(environment, "decoder", "close") | |
| print(template.render()) | |
| def emit_struct_member_encoder( | |
| environment: Environment, | |
| field: _XdrDeclaration, | |
| struct_name: str, | |
| peer: str, | |
| ) -> None: | |
| """Emit an encoder for one field in an XDR struct""" | |
| if isinstance(field, _XdrVariableLengthArray) and ( | |
| (struct_name, field.name) in aggregate_members | |
| ): | |
| if peer != "server": | |
| raise NotImplementedError( | |
| "pragma aggregate is server-side only; " | |
| + peer | |
| + " generation is not yet supported" | |
| ) | |
| template = get_jinja2_template(environment, "encoder", "aggregate_array") | |
| print( | |
| template.render( | |
| name=field.name, | |
| type=field.spec.type_name, | |
| c_type=kernel_c_type(field.spec), | |
| classifier=field.spec.c_classifier, | |
| maxsize=field.maxsize, | |
| hook=aggregate_hook_base(struct_name), | |
| member_sym=aggregate_member_symbol(struct_name, field.name), | |
| ) | |
| ) | |
| return | |
| if isinstance(field, _XdrOptionalData) and ( | |
| (struct_name, field.name) in aggregate_members | |
| ): | |
| if peer != "server": | |
| raise NotImplementedError( | |
| "pragma aggregate is server-side only; " | |
| + peer | |
| + " generation is not yet supported" | |
| ) | |
| template = get_jinja2_template(environment, "encoder", "aggregate_optional") | |
| print( | |
| template.render( | |
| name=field.name, | |
| type=field.spec.type_name, | |
| c_type=kernel_c_type(field.spec), | |
| classifier=field.spec.c_classifier, | |
| hook=aggregate_hook_base(struct_name), | |
| member_sym=aggregate_member_symbol(struct_name, field.name), | |
| ) | |
| ) | |
| return | |
| if (struct_name, field.name) in pages_members: | |
| if peer != "server": | |
| raise NotImplementedError( | |
| "pragma pages is server-side only; " | |
| + peer | |
| + " generation is not yet supported" | |
| ) | |
| # Both representations carry the length field, which is all the | |
| # pages encoder reads, so pages_member_is_decoded() does not | |
| # gate this site. | |
| template = get_jinja2_template(environment, "encoder", "pages_opaque") | |
| print( | |
| template.render( | |
| name=field.name, | |
| maxsize=pages_member_maxsize(field), | |
| ) | |
| ) | |
| return | |
| if isinstance(field, _XdrBasic): | |
| template = get_jinja2_template(environment, "encoder", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| type=field.spec.type_name, | |
| ) | |
| ) | |
| elif isinstance(field, _XdrFixedLengthOpaque): | |
| template = get_jinja2_template(environment, "encoder", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| size=field.size, | |
| ) | |
| ) | |
| elif isinstance(field, _XdrVariableLengthOpaque): | |
| template = get_jinja2_template(environment, "encoder", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| maxsize=field.maxsize, | |
| ) | |
| ) | |
| elif isinstance(field, _XdrString): | |
| template = get_jinja2_template(environment, "encoder", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| maxsize=field.maxsize, | |
| ) | |
| ) | |
| elif isinstance(field, _XdrFixedLengthArray): | |
| template = get_jinja2_template(environment, "encoder", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| type=field.spec.type_name, | |
| size=field.size, | |
| ) | |
| ) | |
| elif isinstance(field, _XdrVariableLengthArray): | |
| template = get_jinja2_template(environment, "encoder", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| type=field.spec.type_name, | |
| maxsize=field.maxsize, | |
| ) | |
| ) | |
| elif isinstance(field, _XdrOptionalData): | |
| template = get_jinja2_template(environment, "encoder", field.template) | |
| print( | |
| template.render( | |
| name=field.name, | |
| type=field.spec.type_name, | |
| classifier=field.spec.c_classifier, | |
| ) | |
| ) | |
| def emit_struct_encoder(environment: Environment, node: _XdrStruct, peer: str) -> None: | |
| """Emit one encoder function for an XDR struct type""" | |
| template = get_jinja2_template(environment, "encoder", "open") | |
| print(template.render(name=node.name)) | |
| for field in node.fields: | |
| emit_struct_member_encoder(environment, field, node.name, peer) | |
| template = get_jinja2_template(environment, "encoder", "close") | |
| print(template.render()) | |
| def emit_struct_maxsize(environment: Environment, node: _XdrStruct) -> None: | |
| """Emit one maxsize macro for an XDR struct type""" | |
| macro_name = get_header_name().upper() + "_" + node.name + "_sz" | |
| template = get_jinja2_template(environment, "maxsize", "struct") | |
| print( | |
| template.render( | |
| macro=macro_name, | |
| width=" + ".join(node.symbolic_width()), | |
| ) | |
| ) | |
| class XdrStructGenerator(SourceGenerator): | |
| """Generate source code for XDR structs""" | |
| def __init__(self, language: str, peer: str): | |
| """Initialize an instance of this class""" | |
| self.environment = create_jinja2_environment(language, "struct") | |
| self.peer = peer | |
| def emit_declaration(self, node: _XdrStruct) -> None: | |
| """Emit one declaration pair for an XDR struct type""" | |
| emit_struct_declaration(self.environment, node) | |
| def emit_definition(self, node: _XdrStruct) -> None: | |
| """Emit one definition for an XDR struct type""" | |
| emit_struct_definition(self.environment, node, self.peer) | |
| def emit_decoder(self, node: _XdrStruct) -> None: | |
| """Emit one decoder function for an XDR struct type""" | |
| emit_struct_decoder(self.environment, node, self.peer) | |
| def emit_encoder(self, node: _XdrStruct) -> None: | |
| """Emit one encoder function for an XDR struct type""" | |
| emit_struct_encoder(self.environment, node, self.peer) | |
| def emit_maxsize(self, node: _XdrStruct) -> None: | |
| """Emit one maxsize macro for an XDR struct type""" | |
| emit_struct_maxsize(self.environment, node) |