#!/usr/bin/env python3
# ex: set filetype=python:
"""Define and implement the Abstract Syntax Tree for the XDR language."""
import sys
from typing import List
from dataclasses import dataclass
from lark import ast_utils, Transformer
from lark.tree import Meta
this_module = sys.modules[__name__]
excluded_apis = []
header_name = "none"
public_apis = []
enums = set()
structs = set()
pass_by_reference = set()
@dataclass
class _XdrAst(ast_utils.Ast):
"""Base class for the XDR abstract syntax tree"""
@dataclass
class _XdrIdentifier(_XdrAst):
"""Corresponds to 'identifier' in the XDR language grammar"""
symbol: str
@dataclass
class _XdrValue(_XdrAst):
"""Corresponds to 'value' in the XDR language grammar"""
value: str
@dataclass
class _XdrConstantValue(_XdrAst):
"""Corresponds to 'constant' in the XDR language grammar"""
value: int
@dataclass
class _XdrTypeSpecifier(_XdrAst):
"""Corresponds to 'type_specifier' in the XDR language grammar"""
type_name: str
c_classifier: str
@dataclass
class _XdrDefinedType(_XdrTypeSpecifier):
"""Corresponds to a type defined by the input specification"""
@dataclass
class _XdrBuiltInType(_XdrTypeSpecifier):
"""Corresponds to a built-in XDR type"""
@dataclass
class _XdrDeclaration(_XdrAst):
"""Base class of XDR type declarations"""
@dataclass
class _XdrFixedLengthOpaque(_XdrDeclaration):
"""A fixed-length opaque declaration"""
name: str
size: str
template: str = "fixed_length_opaque"
@dataclass
class _XdrVariableLengthOpaque(_XdrDeclaration):
"""A variable-length opaque declaration"""
name: str
maxsize: str
template: str = "variable_length_opaque"
@dataclass
class _XdrVariableLengthString(_XdrDeclaration):
"""A (NUL-terminated) variable-length string declaration"""
name: str
maxsize: str
template: str = "variable_length_string"
@dataclass
class _XdrFixedLengthArray(_XdrDeclaration):
"""A fixed-length array declaration"""
name: str
spec: _XdrTypeSpecifier
size: str
template: str = "fixed_length_array"
@dataclass
class _XdrVariableLengthArray(_XdrDeclaration):
"""A variable-length array declaration"""
name: str
spec: _XdrTypeSpecifier
maxsize: str
template: str = "variable_length_array"
@dataclass
class _XdrOptionalData(_XdrDeclaration):
"""An 'optional_data' declaration"""
name: str
spec: _XdrTypeSpecifier
template: str = "optional_data"
@dataclass
class _XdrBasic(_XdrDeclaration):
"""A 'basic' declaration"""
name: str
spec: _XdrTypeSpecifier
template: str = "basic"
@dataclass
class _XdrVoid(_XdrDeclaration):
"""A void declaration"""
template: str = "void"
@dataclass
class _XdrConstant(_XdrAst):
"""Corresponds to 'constant_def' in the grammar"""
name: str
value: str
@dataclass
class _XdrEnumerator(_XdrAst):
"""An 'identifier = value' enumerator"""
name: str
value: str
@dataclass
class _XdrEnum(_XdrAst):
"""An XDR enum definition"""
name: str
minimum: int
maximum: int
enumerators: List[_XdrEnumerator]
@dataclass
class _XdrStruct(_XdrAst):
"""An XDR struct definition"""
name: str
fields: List[_XdrDeclaration]
@dataclass
class _XdrPointer(_XdrAst):
"""An XDR pointer definition"""
name: str
fields: List[_XdrDeclaration]
@dataclass
class _XdrTypedef(_XdrAst):
"""An XDR typedef"""
declaration: _XdrDeclaration
@dataclass
class _XdrCaseSpec(_XdrAst):
"""One case in an XDR union"""
values: List[str]
arm: _XdrDeclaration
template: str = "case_spec"
@dataclass
class _XdrDefaultSpec(_XdrAst):
"""Default case in an XDR union"""
arm: _XdrDeclaration
template: str = "default_spec"
@dataclass
class _XdrUnion(_XdrAst):
"""An XDR union"""
name: str
discriminant: _XdrDeclaration
cases: List[_XdrCaseSpec]
default: _XdrDeclaration
@dataclass
class _RpcProcedure(_XdrAst):
"""RPC procedure definition"""
name: str
number: str
argument: _XdrTypeSpecifier
result: _XdrTypeSpecifier
@dataclass
class _RpcVersion(_XdrAst):
"""RPC version definition"""
name: str
number: str
procedures: List[_RpcProcedure]
@dataclass
class _RpcProgram(_XdrAst):
"""RPC program definition"""
name: str
number: str
versions: List[_RpcVersion]
@dataclass
class _Pragma(_XdrAst):
"""Empty class for pragma directives"""
@dataclass
class Definition(_XdrAst, ast_utils.WithMeta):
"""Corresponds to 'definition' in the grammar"""
meta: Meta
value: _XdrAst
@dataclass
class Specification(_XdrAst, ast_utils.AsList):
"""Corresponds to 'specification' in the grammar"""
definitions: List[Definition]
class ParseToAst(Transformer):
"""Functions that transform productions into AST nodes"""
def identifier(self, children):
"""Instantiate one _XdrIdentifier object"""
return _XdrIdentifier(children[0].value)
def value(self, children):
"""Instantiate one _XdrValue object"""
if isinstance(children[0], _XdrIdentifier):
return _XdrValue(children[0].symbol)
return _XdrValue(children[0].children[0].value)
def constant(self, children):
"""Instantiate one _XdrConstantValue object"""
match children[0].data:
case "decimal_constant":
value = int(children[0].children[0].value, base=10)
case "hexadecimal_constant":
value = int(children[0].children[0].value, base=16)
case "octal_constant":
value = int(children[0].children[0].value, base=8)
return _XdrConstantValue(value)
def type_specifier(self, children):
"""Instantiate one type_specifier object"""
c_classifier = ""
if isinstance(children[0], _XdrIdentifier):
name = children[0].symbol
if name in enums:
c_classifier = "enum "
if name in structs:
c_classifier = "struct "
return _XdrDefinedType(
type_name=name,
c_classifier=c_classifier,
)
token = children[0].data
return _XdrBuiltInType(
type_name=token.value,
c_classifier=c_classifier,
)
def constant_def(self, children):
"""Instantiate one _XdrConstant object"""
name = children[0].symbol
value = children[1].value
return _XdrConstant(name, value)
# cel: Python can compute a min() and max() for the enumerator values
# so that the generated code can perform proper range checking.
def enum(self, children):
"""Instantiate one _XdrEnum object"""
enum_name = children[0].symbol
enums.add(enum_name)
i = 0
enumerators = []
body = children[1]
while i < len(body.children):
name = body.children[i].symbol
value = body.children[i + 1].value
enumerators.append(_XdrEnumerator(name, value))
i = i + 2
return _XdrEnum(enum_name, 0, 0, enumerators)
def fixed_length_opaque(self, children):
"""Instantiate one _XdrFixedLengthOpaque declaration object"""
name = children[0].symbol
size = children[1].value
return _XdrFixedLengthOpaque(name, size)
def variable_length_opaque(self, children):
"""Instantiate one _XdrVariableLengthOpaque declaration object"""
name = children[0].symbol
if children[1] is not None:
maxsize = children[1].value
else:
maxsize = "0"
return _XdrVariableLengthOpaque(name, maxsize)
def variable_length_string(self, children):
"""Instantiate one _XdrVariableLengthString declaration object"""
name = children[0].symbol
if children[1] is not None:
maxsize = children[1].value
else:
maxsize = "0"
return _XdrVariableLengthString(name, maxsize)
def fixed_length_array(self, children):
"""Instantiate one _XdrFixedLengthArray declaration object"""
spec = children[0]
name = children[1].symbol
size = children[2].value
return _XdrFixedLengthArray(name, spec, size)
def variable_length_array(self, children):
"""Instantiate one _XdrVariableLengthArray declaration object"""
spec = children[0]
name = children[1].symbol
if children[2] is not None:
maxsize = children[2].value
else:
maxsize = "0"
return _XdrVariableLengthArray(name, spec, maxsize)
def optional_data(self, children):
"""Instantiate one _XdrOptionalData declaration object"""
spec = children[0]
name = children[1].symbol
structs.add(name)
pass_by_reference.add(name)
return _XdrOptionalData(name, spec)
def basic(self, children):
"""Instantiate one _XdrBasic object"""
spec = children[0]
name = children[1].symbol
return _XdrBasic(name, spec)
def void(self, children):
"""Instantiate one _XdrVoid declaration object"""
return _XdrVoid()
def struct(self, children):
"""Instantiate one _XdrStruct object"""
name = children[0].symbol
structs.add(name)
pass_by_reference.add(name)
fields = children[1].children
last_field = fields[-1]
if (
isinstance(last_field, _XdrOptionalData)
and name == last_field.spec.type_name
):
return _XdrPointer(name, fields)
return _XdrStruct(name, fields)
def typedef(self, children):
"""Instantiate one _XdrTypedef object"""
new_type = children[0]
if isinstance(new_type, _XdrBasic) and isinstance(
new_type.spec, _XdrDefinedType
):
if new_type.spec.type_name in pass_by_reference:
pass_by_reference.add(new_type.name)
return _XdrTypedef(new_type)
def case_spec(self, children):
"""Instantiate one _XdrCaseSpec object"""
values = []
for item in children[0:-1]:
values.append(item.value)
arm = children[-1]
return _XdrCaseSpec(values, arm)
def default_spec(self, children):
"""Instantiate one _XdrDefaultSpec object"""
arm = children[0]
return _XdrDefaultSpec(arm)
def union(self, children):
"""Instantiate one _XdrUnion object"""
name = children[0].symbol
structs.add(name)
pass_by_reference.add(name)
body = children[1]
discriminant = body.children[0].children[0]
cases = body.children[1:-1]
default = body.children[-1]
return _XdrUnion(name, discriminant, cases, default)
def procedure_def(self, children):
"""Instantiate one _RpcProcedure object"""
result = children[0]
name = children[1].symbol
argument = children[2]
number = children[3].value
return _RpcProcedure(name, number, argument, result)
def version_def(self, children):
"""Instantiate one _RpcVersion object"""
name = children[0].symbol
number = children[-1].value
procedures = children[1:-1]
return _RpcVersion(name, number, procedures)
def program_def(self, children):
"""Instantiate one _RpcProgram object"""
name = children[0].symbol
number = children[-1].value
versions = children[1:-1]
return _RpcProgram(name, number, versions)
def pragma_def(self, children):
"""Instantiate one _Pragma object"""
directive = children[0].children[0].data
match directive:
case "exclude_directive":
excluded_apis.append(children[1].symbol)
case "header_directive":
global header_name
header_name = children[1].symbol
case "public_directive":
public_apis.append(children[1].symbol)
case _:
raise NotImplementedError("Directive not supported")
return _Pragma()
transformer = ast_utils.create_transformer(this_module, ParseToAst())
def transform_parse_tree(parse_tree):
"""Transform productions into an abstract syntax tree"""
return transformer.transform(parse_tree)
def get_header_name() -> str:
"""Return header name set by pragma header directive"""
return header_name
Codebase Browser
linux