1060 lines
44 KiB
Python
1060 lines
44 KiB
Python
|
#!/usr/bin/env python3
|
||
|
|
|
||
|
|
# Copyright 2023 Google LLC
|
||
|
|
#
|
||
|
|
# 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
|
||
|
|
#
|
||
|
|
# https://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 argparse
|
||
|
|
from dataclasses import dataclass, field
|
||
|
|
import json
|
||
|
|
from pathlib import Path
|
||
|
|
import sys
|
||
|
|
from textwrap import dedent
|
||
|
|
from typing import List, Tuple, Union, Optional
|
||
|
|
|
||
|
|
from pdl import ast, core
|
||
|
|
from pdl.utils import indent
|
||
|
|
|
||
|
|
|
||
|
|
def mask(width: int) -> str:
|
||
|
|
return hex((1 << width) - 1)
|
||
|
|
|
||
|
|
|
||
|
|
def generate_prelude() -> str:
|
||
|
|
return dedent("""\
|
||
|
|
from dataclasses import dataclass, field, fields
|
||
|
|
from typing import Optional, List, Tuple
|
||
|
|
import enum
|
||
|
|
import inspect
|
||
|
|
import math
|
||
|
|
|
||
|
|
@dataclass
|
||
|
|
class Packet:
|
||
|
|
payload: Optional[bytes] = field(repr=False, default_factory=bytes, compare=False)
|
||
|
|
|
||
|
|
@classmethod
|
||
|
|
def parse_all(cls, span: bytes) -> 'Packet':
|
||
|
|
packet, remain = getattr(cls, 'parse')(span)
|
||
|
|
if len(remain) > 0:
|
||
|
|
raise Exception('Unexpected parsing remainder')
|
||
|
|
return packet
|
||
|
|
|
||
|
|
@property
|
||
|
|
def size(self) -> int:
|
||
|
|
pass
|
||
|
|
|
||
|
|
def show(self, prefix: str = ''):
|
||
|
|
print(f'{self.__class__.__name__}')
|
||
|
|
|
||
|
|
def print_val(p: str, pp: str, name: str, align: int, typ, val):
|
||
|
|
if name == 'payload':
|
||
|
|
pass
|
||
|
|
|
||
|
|
# Scalar fields.
|
||
|
|
elif typ is int:
|
||
|
|
print(f'{p}{name:{align}} = {val} (0x{val:x})')
|
||
|
|
|
||
|
|
# Byte fields.
|
||
|
|
elif typ is bytes:
|
||
|
|
print(f'{p}{name:{align}} = [', end='')
|
||
|
|
line = ''
|
||
|
|
n_pp = ''
|
||
|
|
for (idx, b) in enumerate(val):
|
||
|
|
if idx > 0 and idx % 8 == 0:
|
||
|
|
print(f'{n_pp}{line}')
|
||
|
|
line = ''
|
||
|
|
n_pp = pp + (' ' * (align + 4))
|
||
|
|
line += f' {b:02x}'
|
||
|
|
print(f'{n_pp}{line} ]')
|
||
|
|
|
||
|
|
# Enum fields.
|
||
|
|
elif inspect.isclass(typ) and issubclass(typ, enum.IntEnum):
|
||
|
|
print(f'{p}{name:{align}} = {typ.__name__}::{val.name} (0x{val:x})')
|
||
|
|
|
||
|
|
# Struct fields.
|
||
|
|
elif inspect.isclass(typ) and issubclass(typ, globals().get('Packet')):
|
||
|
|
print(f'{p}{name:{align}} = ', end='')
|
||
|
|
val.show(prefix=pp)
|
||
|
|
|
||
|
|
# Array fields.
|
||
|
|
elif getattr(typ, '__origin__', None) == list:
|
||
|
|
print(f'{p}{name:{align}}')
|
||
|
|
last = len(val) - 1
|
||
|
|
align = 5
|
||
|
|
for (idx, elt) in enumerate(val):
|
||
|
|
n_p = pp + ('├── ' if idx != last else '└── ')
|
||
|
|
n_pp = pp + ('│ ' if idx != last else ' ')
|
||
|
|
print_val(n_p, n_pp, f'[{idx}]', align, typ.__args__[0], val[idx])
|
||
|
|
|
||
|
|
# Custom fields.
|
||
|
|
elif inspect.isclass(typ):
|
||
|
|
print(f'{p}{name:{align}} = {repr(val)}')
|
||
|
|
|
||
|
|
else:
|
||
|
|
print(f'{p}{name:{align}} = ##{typ}##')
|
||
|
|
|
||
|
|
last = len(fields(self)) - 1
|
||
|
|
align = max(len(f.name) for f in fields(self) if f.name != 'payload')
|
||
|
|
|
||
|
|
for (idx, f) in enumerate(fields(self)):
|
||
|
|
p = prefix + ('├── ' if idx != last else '└── ')
|
||
|
|
pp = prefix + ('│ ' if idx != last else ' ')
|
||
|
|
val = getattr(self, f.name)
|
||
|
|
|
||
|
|
print_val(p, pp, f.name, align, f.type, val)
|
||
|
|
""")
|
||
|
|
|
||
|
|
|
||
|
|
@dataclass
|
||
|
|
class FieldParser:
|
||
|
|
byteorder: str
|
||
|
|
offset: int = 0
|
||
|
|
shift: int = 0
|
||
|
|
chunk: List[Tuple[int, int, ast.Field]] = field(default_factory=lambda: [])
|
||
|
|
unchecked_code: List[str] = field(default_factory=lambda: [])
|
||
|
|
code: List[str] = field(default_factory=lambda: [])
|
||
|
|
|
||
|
|
def unchecked_append_(self, line: str):
|
||
|
|
"""Append unchecked field parsing code.
|
||
|
|
The function check_size_ must be called to generate a size guard
|
||
|
|
after parsing is completed."""
|
||
|
|
self.unchecked_code.append(line)
|
||
|
|
|
||
|
|
def append_(self, line: str):
|
||
|
|
"""Append field parsing code.
|
||
|
|
There must be no unchecked code left before this function is called."""
|
||
|
|
assert len(self.unchecked_code) == 0
|
||
|
|
self.code.append(line)
|
||
|
|
|
||
|
|
def check_size_(self, size: str):
|
||
|
|
"""Generate a check of the current span size."""
|
||
|
|
self.append_(f"if len(span) < {size}:")
|
||
|
|
self.append_(f" raise Exception('Invalid packet size')")
|
||
|
|
|
||
|
|
def check_code_(self):
|
||
|
|
"""Generate a size check for pending field parsing."""
|
||
|
|
if len(self.unchecked_code) > 0:
|
||
|
|
assert len(self.chunk) == 0
|
||
|
|
unchecked_code = self.unchecked_code
|
||
|
|
self.unchecked_code = []
|
||
|
|
self.check_size_(str(self.offset))
|
||
|
|
self.code.extend(unchecked_code)
|
||
|
|
|
||
|
|
def consume_span_(self, keep: int = 0) -> str:
|
||
|
|
"""Skip consumed span bytes."""
|
||
|
|
if self.offset > 0:
|
||
|
|
self.check_code_()
|
||
|
|
self.append_(f'span = span[{self.offset - keep}:]')
|
||
|
|
self.offset = 0
|
||
|
|
|
||
|
|
def parse_array_element_dynamic_(self, field: ast.ArrayField, span: str):
|
||
|
|
"""Parse a single array field element of variable size."""
|
||
|
|
if isinstance(field.type, ast.StructDeclaration):
|
||
|
|
self.append_(f" element, {span} = {field.type_id}.parse({span})")
|
||
|
|
self.append_(f" {field.id}.append(element)")
|
||
|
|
else:
|
||
|
|
raise Exception(f'Unexpected array element type {field.type_id} {field.width}')
|
||
|
|
|
||
|
|
def parse_array_element_static_(self, field: ast.ArrayField, span: str):
|
||
|
|
"""Parse a single array field element of constant size."""
|
||
|
|
if field.width is not None:
|
||
|
|
element = f"int.from_bytes({span}, byteorder='{self.byteorder}')"
|
||
|
|
self.append_(f" {field.id}.append({element})")
|
||
|
|
elif isinstance(field.type, ast.EnumDeclaration):
|
||
|
|
element = f"int.from_bytes({span}, byteorder='{self.byteorder}')"
|
||
|
|
element = f"{field.type_id}({element})"
|
||
|
|
self.append_(f" {field.id}.append({element})")
|
||
|
|
else:
|
||
|
|
element = f"{field.type_id}.parse_all({span})"
|
||
|
|
self.append_(f" {field.id}.append({element})")
|
||
|
|
|
||
|
|
def parse_byte_array_field_(self, field: ast.ArrayField):
|
||
|
|
"""Parse the selected u8 array field."""
|
||
|
|
array_size = core.get_array_field_size(field)
|
||
|
|
padded_size = field.padded_size
|
||
|
|
|
||
|
|
# Shift the span to reset the offset to 0.
|
||
|
|
self.consume_span_()
|
||
|
|
|
||
|
|
# Derive the array size.
|
||
|
|
if isinstance(array_size, int):
|
||
|
|
size = array_size
|
||
|
|
elif isinstance(array_size, ast.SizeField):
|
||
|
|
size = f'{field.id}_size - {field.size_modifier}' if field.size_modifier else f'{field.id}_size'
|
||
|
|
elif isinstance(array_size, ast.CountField):
|
||
|
|
size = f'{field.id}_count'
|
||
|
|
else:
|
||
|
|
size = None
|
||
|
|
|
||
|
|
# Parse from the padded array if padding is present.
|
||
|
|
if padded_size and size is not None:
|
||
|
|
self.check_size_(padded_size)
|
||
|
|
self.append_(f"if {size} > {padded_size}:")
|
||
|
|
self.append_(" raise Exception('Array size is larger than the padding size')")
|
||
|
|
self.append_(f"fields['{field.id}'] = list(span[:{size}])")
|
||
|
|
self.append_(f"span = span[{padded_size}:]")
|
||
|
|
|
||
|
|
elif size is not None:
|
||
|
|
self.check_size_(size)
|
||
|
|
self.append_(f"fields['{field.id}'] = list(span[:{size}])")
|
||
|
|
self.append_(f"span = span[{size}:]")
|
||
|
|
|
||
|
|
else:
|
||
|
|
self.append_(f"fields['{field.id}'] = list(span)")
|
||
|
|
self.append_(f"span = bytes()")
|
||
|
|
|
||
|
|
def parse_array_field_(self, field: ast.ArrayField):
|
||
|
|
"""Parse the selected array field."""
|
||
|
|
array_size = core.get_array_field_size(field)
|
||
|
|
element_width = core.get_array_element_size(field)
|
||
|
|
padded_size = field.padded_size
|
||
|
|
|
||
|
|
if element_width:
|
||
|
|
if element_width % 8 != 0:
|
||
|
|
raise Exception('Array element size is not a multiple of 8')
|
||
|
|
element_width = int(element_width / 8)
|
||
|
|
|
||
|
|
if isinstance(array_size, int):
|
||
|
|
size = None
|
||
|
|
count = array_size
|
||
|
|
elif isinstance(array_size, ast.SizeField):
|
||
|
|
size = f'{field.id}_size'
|
||
|
|
count = None
|
||
|
|
elif isinstance(array_size, ast.CountField):
|
||
|
|
size = None
|
||
|
|
count = f'{field.id}_count'
|
||
|
|
else:
|
||
|
|
size = None
|
||
|
|
count = None
|
||
|
|
|
||
|
|
# Shift the span to reset the offset to 0.
|
||
|
|
self.consume_span_()
|
||
|
|
|
||
|
|
# Apply the size modifier.
|
||
|
|
if field.size_modifier and size:
|
||
|
|
self.append_(f"{size} = {size} - {field.size_modifier}")
|
||
|
|
|
||
|
|
# Parse from the padded array if padding is present.
|
||
|
|
if padded_size:
|
||
|
|
self.check_size_(padded_size)
|
||
|
|
self.append_(f"remaining_span = span[{padded_size}:]")
|
||
|
|
self.append_(f"span = span[:{padded_size}]")
|
||
|
|
|
||
|
|
# The element width is not known, but the array full octet size
|
||
|
|
# is known by size field. Parse elements item by item as a vector.
|
||
|
|
if element_width is None and size is not None:
|
||
|
|
self.check_size_(size)
|
||
|
|
self.append_(f"array_span = span[:{size}]")
|
||
|
|
self.append_(f"{field.id} = []")
|
||
|
|
self.append_("while len(array_span) > 0:")
|
||
|
|
self.parse_array_element_dynamic_(field, 'array_span')
|
||
|
|
self.append_(f"fields['{field.id}'] = {field.id}")
|
||
|
|
self.append_(f"span = span[{size}:]")
|
||
|
|
|
||
|
|
# The element width is not known, but the array element count
|
||
|
|
# is known statically or by count field.
|
||
|
|
# Parse elements item by item as a vector.
|
||
|
|
elif element_width is None and count is not None:
|
||
|
|
self.append_(f"{field.id} = []")
|
||
|
|
self.append_(f"for n in range({count}):")
|
||
|
|
self.parse_array_element_dynamic_(field, 'span')
|
||
|
|
self.append_(f"fields['{field.id}'] = {field.id}")
|
||
|
|
|
||
|
|
# Neither the count not size is known,
|
||
|
|
# parse elements until the end of the span.
|
||
|
|
elif element_width is None:
|
||
|
|
self.append_(f"{field.id} = []")
|
||
|
|
self.append_("while len(span) > 0:")
|
||
|
|
self.parse_array_element_dynamic_(field, 'span')
|
||
|
|
self.append_(f"fields['{field.id}'] = {field.id}")
|
||
|
|
|
||
|
|
# The element width is known, and the array element count is known
|
||
|
|
# statically, or by count field.
|
||
|
|
elif count is not None:
|
||
|
|
array_size = (f'{count}' if element_width == 1 else f'{count} * {element_width}')
|
||
|
|
self.check_size_(array_size)
|
||
|
|
self.append_(f"{field.id} = []")
|
||
|
|
self.append_(f"for n in range({count}):")
|
||
|
|
span = ('span[n:n + 1]' if element_width == 1 else f'span[n * {element_width}:(n + 1) * {element_width}]')
|
||
|
|
self.parse_array_element_static_(field, span)
|
||
|
|
self.append_(f"fields['{field.id}'] = {field.id}")
|
||
|
|
self.append_(f"span = span[{array_size}:]")
|
||
|
|
|
||
|
|
# The element width is known, and the array full size is known
|
||
|
|
# by size field, or unknown (in which case it is the remaining span
|
||
|
|
# length).
|
||
|
|
else:
|
||
|
|
if size is not None:
|
||
|
|
self.check_size_(size)
|
||
|
|
array_size = size or 'len(span)'
|
||
|
|
if element_width != 1:
|
||
|
|
self.append_(f"if {array_size} % {element_width} != 0:")
|
||
|
|
self.append_(" raise Exception('Array size is not a multiple of the element size')")
|
||
|
|
self.append_(f"{field.id}_count = int({array_size} / {element_width})")
|
||
|
|
array_count = f'{field.id}_count'
|
||
|
|
else:
|
||
|
|
array_count = array_size
|
||
|
|
self.append_(f"{field.id} = []")
|
||
|
|
self.append_(f"for n in range({array_count}):")
|
||
|
|
span = ('span[n:n + 1]' if element_width == 1 else f'span[n * {element_width}:(n + 1) * {element_width}]')
|
||
|
|
self.parse_array_element_static_(field, span)
|
||
|
|
self.append_(f"fields['{field.id}'] = {field.id}")
|
||
|
|
if size is not None:
|
||
|
|
self.append_(f"span = span[{size}:]")
|
||
|
|
else:
|
||
|
|
self.append_(f"span = bytes()")
|
||
|
|
|
||
|
|
# Drop the padding
|
||
|
|
if padded_size:
|
||
|
|
self.append_(f"span = remaining_span")
|
||
|
|
|
||
|
|
def parse_bit_field_(self, field: ast.Field):
|
||
|
|
"""Parse the selected field as a bit field.
|
||
|
|
The field is added to the current chunk. When a byte boundary
|
||
|
|
is reached all saved fields are extracted together."""
|
||
|
|
|
||
|
|
# Add to current chunk.
|
||
|
|
width = core.get_field_size(field)
|
||
|
|
self.chunk.append((self.shift, width, field))
|
||
|
|
self.shift += width
|
||
|
|
|
||
|
|
# Wait for more fields if not on a byte boundary.
|
||
|
|
if (self.shift % 8) != 0:
|
||
|
|
return
|
||
|
|
|
||
|
|
# Parse the backing integer using the configured endiannes,
|
||
|
|
# extract field values.
|
||
|
|
size = int(self.shift / 8)
|
||
|
|
end_offset = self.offset + size
|
||
|
|
|
||
|
|
if size == 1:
|
||
|
|
value = f"span[{self.offset}]"
|
||
|
|
else:
|
||
|
|
span = f"span[{self.offset}:{end_offset}]"
|
||
|
|
self.unchecked_append_(f"value_ = int.from_bytes({span}, byteorder='{self.byteorder}')")
|
||
|
|
value = "value_"
|
||
|
|
|
||
|
|
for shift, width, field in self.chunk:
|
||
|
|
v = (value if len(self.chunk) == 1 and shift == 0 else f"({value} >> {shift}) & {mask(width)}")
|
||
|
|
|
||
|
|
if isinstance(field, ast.ScalarField):
|
||
|
|
self.unchecked_append_(f"fields['{field.id}'] = {v}")
|
||
|
|
elif isinstance(field, ast.FixedField) and field.enum_id:
|
||
|
|
self.unchecked_append_(f"if {v} != {field.enum_id}.{field.tag_id}:")
|
||
|
|
self.unchecked_append_(f" raise Exception('Unexpected fixed field value')")
|
||
|
|
elif isinstance(field, ast.FixedField):
|
||
|
|
self.unchecked_append_(f"if {v} != {hex(field.value)}:")
|
||
|
|
self.unchecked_append_(f" raise Exception('Unexpected fixed field value')")
|
||
|
|
elif isinstance(field, ast.TypedefField):
|
||
|
|
self.unchecked_append_(f"fields['{field.id}'] = {field.type_id}({v})")
|
||
|
|
elif isinstance(field, ast.SizeField):
|
||
|
|
self.unchecked_append_(f"{field.field_id}_size = {v}")
|
||
|
|
elif isinstance(field, ast.CountField):
|
||
|
|
self.unchecked_append_(f"{field.field_id}_count = {v}")
|
||
|
|
elif isinstance(field, ast.ReservedField):
|
||
|
|
pass
|
||
|
|
else:
|
||
|
|
raise Exception(f'Unsupported bit field type {field.kind}')
|
||
|
|
|
||
|
|
# Reset state.
|
||
|
|
self.offset = end_offset
|
||
|
|
self.shift = 0
|
||
|
|
self.chunk = []
|
||
|
|
|
||
|
|
def parse_typedef_field_(self, field: ast.TypedefField):
|
||
|
|
"""Parse a typedef field, to the exclusion of Enum fields."""
|
||
|
|
|
||
|
|
if self.shift != 0:
|
||
|
|
raise Exception('Typedef field does not start on an octet boundary')
|
||
|
|
if (isinstance(field.type, ast.StructDeclaration) and field.type.parent_id is not None):
|
||
|
|
raise Exception('Derived struct used in typedef field')
|
||
|
|
|
||
|
|
width = core.get_declaration_size(field.type)
|
||
|
|
if width is None:
|
||
|
|
self.consume_span_()
|
||
|
|
self.append_(f"{field.id}, span = {field.type_id}.parse(span)")
|
||
|
|
self.append_(f"fields['{field.id}'] = {field.id}")
|
||
|
|
else:
|
||
|
|
if width % 8 != 0:
|
||
|
|
raise Exception('Typedef field type size is not a multiple of 8')
|
||
|
|
width = int(width / 8)
|
||
|
|
end_offset = self.offset + width
|
||
|
|
# Checksum value field is generated alongside checksum start.
|
||
|
|
# Deal with this field as padding.
|
||
|
|
if not isinstance(field.type, ast.ChecksumDeclaration):
|
||
|
|
span = f'span[{self.offset}:{end_offset}]'
|
||
|
|
self.unchecked_append_(f"fields['{field.id}'] = {field.type_id}.parse_all({span})")
|
||
|
|
self.offset = end_offset
|
||
|
|
|
||
|
|
def parse_payload_field_(self, field: Union[ast.BodyField, ast.PayloadField]):
|
||
|
|
"""Parse body and payload fields."""
|
||
|
|
|
||
|
|
payload_size = core.get_payload_field_size(field)
|
||
|
|
offset_from_end = core.get_field_offset_from_end(field)
|
||
|
|
|
||
|
|
# If the payload is not byte aligned, do parse the bit fields
|
||
|
|
# that can be extracted, but do not consume the input bytes as
|
||
|
|
# they will also be included in the payload span.
|
||
|
|
if self.shift != 0:
|
||
|
|
if payload_size:
|
||
|
|
raise Exception("Unexpected payload size for non byte aligned payload")
|
||
|
|
|
||
|
|
rounded_size = int((self.shift + 7) / 8)
|
||
|
|
padding_bits = 8 * rounded_size - self.shift
|
||
|
|
self.parse_bit_field_(core.make_reserved_field(padding_bits))
|
||
|
|
self.consume_span_(rounded_size)
|
||
|
|
else:
|
||
|
|
self.consume_span_()
|
||
|
|
|
||
|
|
# The payload or body has a known size.
|
||
|
|
# Consume the payload and update the span in case
|
||
|
|
# fields are placed after the payload.
|
||
|
|
if payload_size:
|
||
|
|
if getattr(field, 'size_modifier', None):
|
||
|
|
self.append_(f"{field.id}_size -= {field.size_modifier}")
|
||
|
|
self.check_size_(f'{field.id}_size')
|
||
|
|
self.append_(f"payload = span[:{field.id}_size]")
|
||
|
|
self.append_(f"span = span[{field.id}_size:]")
|
||
|
|
# The payload or body is the last field of a packet,
|
||
|
|
# consume the remaining span.
|
||
|
|
elif offset_from_end == 0:
|
||
|
|
self.append_(f"payload = span")
|
||
|
|
self.append_(f"span = bytes([])")
|
||
|
|
# The payload or body is followed by fields of static size.
|
||
|
|
# Consume the span that is not reserved for the following fields.
|
||
|
|
elif offset_from_end is not None:
|
||
|
|
if (offset_from_end % 8) != 0:
|
||
|
|
raise Exception('Payload field offset from end of packet is not a multiple of 8')
|
||
|
|
offset_from_end = int(offset_from_end / 8)
|
||
|
|
self.check_size_(f'{offset_from_end}')
|
||
|
|
self.append_(f"payload = span[:-{offset_from_end}]")
|
||
|
|
self.append_(f"span = span[-{offset_from_end}:]")
|
||
|
|
self.append_(f"fields['payload'] = payload")
|
||
|
|
|
||
|
|
def parse_checksum_field_(self, field: ast.ChecksumField):
|
||
|
|
"""Generate a checksum check."""
|
||
|
|
|
||
|
|
# The checksum value field can be read starting from the current
|
||
|
|
# offset if the fields in between are of fixed size, or from the end
|
||
|
|
# of the span otherwise.
|
||
|
|
self.consume_span_()
|
||
|
|
value_field = core.get_packet_field(field.parent, field.field_id)
|
||
|
|
offset_from_start = 0
|
||
|
|
offset_from_end = 0
|
||
|
|
start_index = field.parent.fields.index(field)
|
||
|
|
value_index = field.parent.fields.index(value_field)
|
||
|
|
value_size = int(core.get_field_size(value_field) / 8)
|
||
|
|
|
||
|
|
for f in field.parent.fields[start_index + 1:value_index]:
|
||
|
|
size = core.get_field_size(f)
|
||
|
|
if size is None:
|
||
|
|
offset_from_start = None
|
||
|
|
break
|
||
|
|
else:
|
||
|
|
offset_from_start += size
|
||
|
|
|
||
|
|
trailing_fields = field.parent.fields[value_index:]
|
||
|
|
trailing_fields.reverse()
|
||
|
|
for f in trailing_fields:
|
||
|
|
size = core.get_field_size(f)
|
||
|
|
if size is None:
|
||
|
|
offset_from_end = None
|
||
|
|
break
|
||
|
|
else:
|
||
|
|
offset_from_end += size
|
||
|
|
|
||
|
|
if offset_from_start is not None:
|
||
|
|
if offset_from_start % 8 != 0:
|
||
|
|
raise Exception('Checksum value field is not aligned to an octet boundary')
|
||
|
|
offset_from_start = int(offset_from_start / 8)
|
||
|
|
checksum_span = f'span[:{offset_from_start}]'
|
||
|
|
if value_size > 1:
|
||
|
|
start = offset_from_start
|
||
|
|
end = offset_from_start + value_size
|
||
|
|
value = f"int.from_bytes(span[{start}:{end}], byteorder='{self.byteorder}')"
|
||
|
|
else:
|
||
|
|
value = f'span[{offset_from_start}]'
|
||
|
|
self.check_size_(offset_from_start + value_size)
|
||
|
|
|
||
|
|
elif offset_from_end is not None:
|
||
|
|
sign = ''
|
||
|
|
if offset_from_end % 8 != 0:
|
||
|
|
raise Exception('Checksum value field is not aligned to an octet boundary')
|
||
|
|
offset_from_end = int(offset_from_end / 8)
|
||
|
|
checksum_span = f'span[:-{offset_from_end}]'
|
||
|
|
if value_size > 1:
|
||
|
|
start = offset_from_end
|
||
|
|
end = offset_from_end - value_size
|
||
|
|
value = f"int.from_bytes(span[-{start}:-{end}], byteorder='{self.byteorder}')"
|
||
|
|
else:
|
||
|
|
value = f'span[-{offset_from_end}]'
|
||
|
|
self.check_size_(offset_from_end)
|
||
|
|
|
||
|
|
else:
|
||
|
|
raise Exception('Checksum value field cannot be read at constant offset')
|
||
|
|
|
||
|
|
self.append_(f"{value_field.id} = {value}")
|
||
|
|
self.append_(f"fields['{value_field.id}'] = {value_field.id}")
|
||
|
|
self.append_(f"computed_{value_field.id} = {value_field.type.function}({checksum_span})")
|
||
|
|
self.append_(f"if computed_{value_field.id} != {value_field.id}:")
|
||
|
|
self.append_(" raise Exception(f'Invalid checksum computation:" +
|
||
|
|
f" {{computed_{value_field.id}}} != {{{value_field.id}}}')")
|
||
|
|
|
||
|
|
def parse(self, field: ast.Field):
|
||
|
|
# Field has bit granularity.
|
||
|
|
# Append the field to the current chunk,
|
||
|
|
# check if a byte boundary was reached.
|
||
|
|
if core.is_bit_field(field):
|
||
|
|
self.parse_bit_field_(field)
|
||
|
|
|
||
|
|
# Padding fields.
|
||
|
|
elif isinstance(field, ast.PaddingField):
|
||
|
|
pass
|
||
|
|
|
||
|
|
# Array fields.
|
||
|
|
elif isinstance(field, ast.ArrayField) and field.width == 8:
|
||
|
|
self.parse_byte_array_field_(field)
|
||
|
|
|
||
|
|
elif isinstance(field, ast.ArrayField):
|
||
|
|
self.parse_array_field_(field)
|
||
|
|
|
||
|
|
# Other typedef fields.
|
||
|
|
elif isinstance(field, ast.TypedefField):
|
||
|
|
self.parse_typedef_field_(field)
|
||
|
|
|
||
|
|
# Payload and body fields.
|
||
|
|
elif isinstance(field, (ast.PayloadField, ast.BodyField)):
|
||
|
|
self.parse_payload_field_(field)
|
||
|
|
|
||
|
|
# Checksum fields.
|
||
|
|
elif isinstance(field, ast.ChecksumField):
|
||
|
|
self.parse_checksum_field_(field)
|
||
|
|
|
||
|
|
else:
|
||
|
|
raise Exception(f'Unimplemented field type {field.kind}')
|
||
|
|
|
||
|
|
def done(self):
|
||
|
|
self.consume_span_()
|
||
|
|
|
||
|
|
|
||
|
|
@dataclass
|
||
|
|
class FieldSerializer:
|
||
|
|
byteorder: str
|
||
|
|
shift: int = 0
|
||
|
|
value: List[str] = field(default_factory=lambda: [])
|
||
|
|
code: List[str] = field(default_factory=lambda: [])
|
||
|
|
indent: int = 0
|
||
|
|
|
||
|
|
def indent_(self):
|
||
|
|
self.indent += 1
|
||
|
|
|
||
|
|
def unindent_(self):
|
||
|
|
self.indent -= 1
|
||
|
|
|
||
|
|
def append_(self, line: str):
|
||
|
|
"""Append field serializing code."""
|
||
|
|
lines = line.split('\n')
|
||
|
|
self.code.extend([' ' * self.indent + line for line in lines])
|
||
|
|
|
||
|
|
def extend_(self, value: str, length: int):
|
||
|
|
"""Append data to the span being constructed."""
|
||
|
|
if length == 1:
|
||
|
|
self.append_(f"_span.append({value})")
|
||
|
|
else:
|
||
|
|
self.append_(f"_span.extend(int.to_bytes({value}, length={length}, byteorder='{self.byteorder}'))")
|
||
|
|
|
||
|
|
def serialize_array_element_(self, field: ast.ArrayField):
|
||
|
|
"""Serialize a single array field element."""
|
||
|
|
if field.width is not None:
|
||
|
|
length = int(field.width / 8)
|
||
|
|
self.extend_('_elt', length)
|
||
|
|
elif isinstance(field.type, ast.EnumDeclaration):
|
||
|
|
length = int(field.type.width / 8)
|
||
|
|
self.extend_('_elt', length)
|
||
|
|
else:
|
||
|
|
self.append_("_span.extend(_elt.serialize())")
|
||
|
|
|
||
|
|
def serialize_array_field_(self, field: ast.ArrayField):
|
||
|
|
"""Serialize the selected array field."""
|
||
|
|
if field.padded_size:
|
||
|
|
self.append_(f"_{field.id}_start = len(_span)")
|
||
|
|
|
||
|
|
if field.width == 8:
|
||
|
|
self.append_(f"_span.extend(self.{field.id})")
|
||
|
|
else:
|
||
|
|
self.append_(f"for _elt in self.{field.id}:")
|
||
|
|
self.indent_()
|
||
|
|
self.serialize_array_element_(field)
|
||
|
|
self.unindent_()
|
||
|
|
|
||
|
|
if field.padded_size:
|
||
|
|
self.append_(f"_span.extend([0] * ({field.padded_size} - len(_span) + _{field.id}_start))")
|
||
|
|
|
||
|
|
def serialize_bit_field_(self, field: ast.Field):
|
||
|
|
"""Serialize the selected field as a bit field.
|
||
|
|
The field is added to the current chunk. When a byte boundary
|
||
|
|
is reached all saved fields are serialized together."""
|
||
|
|
|
||
|
|
# Add to current chunk.
|
||
|
|
width = core.get_field_size(field)
|
||
|
|
shift = self.shift
|
||
|
|
|
||
|
|
if isinstance(field, str):
|
||
|
|
self.value.append(f"({field} << {shift})")
|
||
|
|
elif isinstance(field, ast.ScalarField):
|
||
|
|
max_value = (1 << field.width) - 1
|
||
|
|
self.append_(f"if self.{field.id} > {max_value}:")
|
||
|
|
self.append_(f" print(f\"Invalid value for field {field.parent.id}::{field.id}:" +
|
||
|
|
f" {{self.{field.id}}} > {max_value}; the value will be truncated\")")
|
||
|
|
self.append_(f" self.{field.id} &= {max_value}")
|
||
|
|
self.value.append(f"(self.{field.id} << {shift})")
|
||
|
|
elif isinstance(field, ast.FixedField) and field.enum_id:
|
||
|
|
self.value.append(f"({field.enum_id}.{field.tag_id} << {shift})")
|
||
|
|
elif isinstance(field, ast.FixedField):
|
||
|
|
self.value.append(f"({field.value} << {shift})")
|
||
|
|
elif isinstance(field, ast.TypedefField):
|
||
|
|
self.value.append(f"(self.{field.id} << {shift})")
|
||
|
|
|
||
|
|
elif isinstance(field, ast.SizeField):
|
||
|
|
max_size = (1 << field.width) - 1
|
||
|
|
value_field = core.get_packet_field(field.parent, field.field_id)
|
||
|
|
size_modifier = ''
|
||
|
|
|
||
|
|
if getattr(value_field, 'size_modifier', None):
|
||
|
|
size_modifier = f' + {value_field.size_modifier}'
|
||
|
|
|
||
|
|
if isinstance(value_field, (ast.PayloadField, ast.BodyField)):
|
||
|
|
self.append_(f"_payload_size = len(payload or self.payload or []){size_modifier}")
|
||
|
|
self.append_(f"if _payload_size > {max_size}:")
|
||
|
|
self.append_(f" print(f\"Invalid length for payload field:" +
|
||
|
|
f" {{_payload_size}} > {max_size}; the packet cannot be generated\")")
|
||
|
|
self.append_(f" raise Exception(\"Invalid payload length\")")
|
||
|
|
array_size = "_payload_size"
|
||
|
|
elif isinstance(value_field, ast.ArrayField) and value_field.width:
|
||
|
|
array_size = f"(len(self.{value_field.id}) * {int(value_field.width / 8)}{size_modifier})"
|
||
|
|
elif isinstance(value_field, ast.ArrayField) and isinstance(value_field.type, ast.EnumDeclaration):
|
||
|
|
array_size = f"(len(self.{value_field.id}) * {int(value_field.type.width / 8)}{size_modifier})"
|
||
|
|
elif isinstance(value_field, ast.ArrayField):
|
||
|
|
self.append_(
|
||
|
|
f"_{value_field.id}_size = sum([elt.size for elt in self.{value_field.id}]){size_modifier}")
|
||
|
|
array_size = f"_{value_field.id}_size"
|
||
|
|
else:
|
||
|
|
raise Exception("Unsupported field type")
|
||
|
|
self.value.append(f"({array_size} << {shift})")
|
||
|
|
|
||
|
|
elif isinstance(field, ast.CountField):
|
||
|
|
max_count = (1 << field.width) - 1
|
||
|
|
self.append_(f"if len(self.{field.field_id}) > {max_count}:")
|
||
|
|
self.append_(f" print(f\"Invalid length for field {field.parent.id}::{field.field_id}:" +
|
||
|
|
f" {{len(self.{field.field_id})}} > {max_count}; the array will be truncated\")")
|
||
|
|
self.append_(f" del self.{field.field_id}[{max_count}:]")
|
||
|
|
self.value.append(f"(len(self.{field.field_id}) << {shift})")
|
||
|
|
elif isinstance(field, ast.ReservedField):
|
||
|
|
pass
|
||
|
|
else:
|
||
|
|
raise Exception(f'Unsupported bit field type {field.kind}')
|
||
|
|
|
||
|
|
# Check if a byte boundary is reached.
|
||
|
|
self.shift += width
|
||
|
|
if (self.shift % 8) == 0:
|
||
|
|
self.pack_bit_fields_()
|
||
|
|
|
||
|
|
def pack_bit_fields_(self):
|
||
|
|
"""Pack serialized bit fields."""
|
||
|
|
|
||
|
|
# Should have an integral number of bytes now.
|
||
|
|
assert (self.shift % 8) == 0
|
||
|
|
|
||
|
|
# Generate the backing integer, and serialize it
|
||
|
|
# using the configured endiannes,
|
||
|
|
size = int(self.shift / 8)
|
||
|
|
|
||
|
|
if len(self.value) == 0:
|
||
|
|
self.append_(f"_span.extend([0] * {size})")
|
||
|
|
elif len(self.value) == 1:
|
||
|
|
self.extend_(self.value[0], size)
|
||
|
|
else:
|
||
|
|
self.append_(f"_value = (")
|
||
|
|
self.append_(" " + " |\n ".join(self.value))
|
||
|
|
self.append_(")")
|
||
|
|
self.extend_('_value', size)
|
||
|
|
|
||
|
|
# Reset state.
|
||
|
|
self.shift = 0
|
||
|
|
self.value = []
|
||
|
|
|
||
|
|
def serialize_typedef_field_(self, field: ast.TypedefField):
|
||
|
|
"""Serialize a typedef field, to the exclusion of Enum fields."""
|
||
|
|
|
||
|
|
if self.shift != 0:
|
||
|
|
raise Exception('Typedef field does not start on an octet boundary')
|
||
|
|
if (isinstance(field.type, ast.StructDeclaration) and field.type.parent_id is not None):
|
||
|
|
raise Exception('Derived struct used in typedef field')
|
||
|
|
|
||
|
|
if isinstance(field.type, ast.ChecksumDeclaration):
|
||
|
|
size = int(field.type.width / 8)
|
||
|
|
self.append_(f"_checksum = {field.type.function}(_span[_checksum_start:])")
|
||
|
|
self.extend_('_checksum', size)
|
||
|
|
else:
|
||
|
|
self.append_(f"_span.extend(self.{field.id}.serialize())")
|
||
|
|
|
||
|
|
def serialize_payload_field_(self, field: Union[ast.BodyField, ast.PayloadField]):
|
||
|
|
"""Serialize body and payload fields."""
|
||
|
|
|
||
|
|
if self.shift != 0 and self.byteorder == 'big':
|
||
|
|
raise Exception('Payload field does not start on an octet boundary')
|
||
|
|
|
||
|
|
if self.shift == 0:
|
||
|
|
self.append_(f"_span.extend(payload or self.payload or [])")
|
||
|
|
else:
|
||
|
|
# Supported case of packet inheritance;
|
||
|
|
# the incomplete fields are serialized into
|
||
|
|
# the payload, rather than separately.
|
||
|
|
# First extract the padding bits from the payload,
|
||
|
|
# then recombine them with the bit fields to be serialized.
|
||
|
|
rounded_size = int((self.shift + 7) / 8)
|
||
|
|
padding_bits = 8 * rounded_size - self.shift
|
||
|
|
self.append_(f"_payload = payload or self.payload or bytes()")
|
||
|
|
self.append_(f"if len(_payload) < {rounded_size}:")
|
||
|
|
self.append_(f" raise Exception(f\"Invalid length for payload field:" +
|
||
|
|
f" {{len(_payload)}} < {rounded_size}\")")
|
||
|
|
self.append_(
|
||
|
|
f"_padding = int.from_bytes(_payload[:{rounded_size}], byteorder='{self.byteorder}') >> {self.shift}")
|
||
|
|
self.value.append(f"(_padding << {self.shift})")
|
||
|
|
self.shift += padding_bits
|
||
|
|
self.pack_bit_fields_()
|
||
|
|
self.append_(f"_span.extend(_payload[{rounded_size}:])")
|
||
|
|
|
||
|
|
def serialize_checksum_field_(self, field: ast.ChecksumField):
|
||
|
|
"""Generate a checksum check."""
|
||
|
|
|
||
|
|
self.append_("_checksum_start = len(_span)")
|
||
|
|
|
||
|
|
def serialize(self, field: ast.Field):
|
||
|
|
# Field has bit granularity.
|
||
|
|
# Append the field to the current chunk,
|
||
|
|
# check if a byte boundary was reached.
|
||
|
|
if core.is_bit_field(field):
|
||
|
|
self.serialize_bit_field_(field)
|
||
|
|
|
||
|
|
# Padding fields.
|
||
|
|
elif isinstance(field, ast.PaddingField):
|
||
|
|
pass
|
||
|
|
|
||
|
|
# Array fields.
|
||
|
|
elif isinstance(field, ast.ArrayField):
|
||
|
|
self.serialize_array_field_(field)
|
||
|
|
|
||
|
|
# Other typedef fields.
|
||
|
|
elif isinstance(field, ast.TypedefField):
|
||
|
|
self.serialize_typedef_field_(field)
|
||
|
|
|
||
|
|
# Payload and body fields.
|
||
|
|
elif isinstance(field, (ast.PayloadField, ast.BodyField)):
|
||
|
|
self.serialize_payload_field_(field)
|
||
|
|
|
||
|
|
# Checksum fields.
|
||
|
|
elif isinstance(field, ast.ChecksumField):
|
||
|
|
self.serialize_checksum_field_(field)
|
||
|
|
|
||
|
|
else:
|
||
|
|
raise Exception(f'Unimplemented field type {field.kind}')
|
||
|
|
|
||
|
|
|
||
|
|
def generate_toplevel_packet_serializer(packet: ast.Declaration) -> List[str]:
|
||
|
|
"""Generate the serialize() function for a toplevel Packet or Struct
|
||
|
|
declaration."""
|
||
|
|
|
||
|
|
serializer = FieldSerializer(byteorder=packet.file.byteorder)
|
||
|
|
for f in packet.fields:
|
||
|
|
serializer.serialize(f)
|
||
|
|
return ['_span = bytearray()'] + serializer.code + ['return bytes(_span)']
|
||
|
|
|
||
|
|
|
||
|
|
def generate_derived_packet_serializer(packet: ast.Declaration) -> List[str]:
|
||
|
|
"""Generate the serialize() function for a derived Packet or Struct
|
||
|
|
declaration."""
|
||
|
|
|
||
|
|
packet_shift = core.get_packet_shift(packet)
|
||
|
|
if packet_shift and packet.file.byteorder == 'big':
|
||
|
|
raise Exception(f"Big-endian packet {packet.id} has an unsupported body shift")
|
||
|
|
|
||
|
|
serializer = FieldSerializer(byteorder=packet.file.byteorder, shift=packet_shift)
|
||
|
|
for f in packet.fields:
|
||
|
|
serializer.serialize(f)
|
||
|
|
return ['_span = bytearray()'
|
||
|
|
] + serializer.code + [f'return {packet.parent.id}.serialize(self, payload = bytes(_span))']
|
||
|
|
|
||
|
|
|
||
|
|
def generate_packet_parser(packet: ast.Declaration) -> List[str]:
|
||
|
|
"""Generate the parse() function for a toplevel Packet or Struct
|
||
|
|
declaration."""
|
||
|
|
|
||
|
|
packet_shift = core.get_packet_shift(packet)
|
||
|
|
if packet_shift and packet.file.byteorder == 'big':
|
||
|
|
raise Exception(f"Big-endian packet {packet.id} has an unsupported body shift")
|
||
|
|
|
||
|
|
# Convert the packet constraints to a boolean expression.
|
||
|
|
validation = []
|
||
|
|
if packet.constraints:
|
||
|
|
cond = []
|
||
|
|
for c in packet.constraints:
|
||
|
|
if c.value is not None:
|
||
|
|
cond.append(f"fields['{c.id}'] != {hex(c.value)}")
|
||
|
|
else:
|
||
|
|
field = core.get_packet_field(packet, c.id)
|
||
|
|
cond.append(f"fields['{c.id}'] != {field.type_id}.{c.tag_id}")
|
||
|
|
|
||
|
|
validation = [f"if {' or '.join(cond)}:", " raise Exception(\"Invalid constraint field values\")"]
|
||
|
|
|
||
|
|
# Parse fields iteratively.
|
||
|
|
parser = FieldParser(byteorder=packet.file.byteorder, shift=packet_shift)
|
||
|
|
for f in packet.fields:
|
||
|
|
parser.parse(f)
|
||
|
|
parser.done()
|
||
|
|
|
||
|
|
# Specialize to child packets.
|
||
|
|
children = core.get_derived_packets(packet)
|
||
|
|
decl = [] if packet.parent_id else ['fields = {\'payload\': None}']
|
||
|
|
specialization = []
|
||
|
|
|
||
|
|
if len(children) != 0:
|
||
|
|
# Try parsing every child packet successively until one is
|
||
|
|
# successfully parsed. Return a parsing error if none is valid.
|
||
|
|
# Return parent packet if no child packet matches.
|
||
|
|
# TODO: order child packets by decreasing size in case no constraint
|
||
|
|
# is given for specialization.
|
||
|
|
for _, child in children:
|
||
|
|
specialization.append("try:")
|
||
|
|
specialization.append(f" return {child.id}.parse(fields.copy(), payload)")
|
||
|
|
specialization.append("except Exception as exn:")
|
||
|
|
specialization.append(" pass")
|
||
|
|
|
||
|
|
return decl + validation + parser.code + specialization + [f"return {packet.id}(**fields), span"]
|
||
|
|
|
||
|
|
|
||
|
|
def generate_packet_size_getter(packet: ast.Declaration) -> List[str]:
|
||
|
|
constant_width = 0
|
||
|
|
variable_width = []
|
||
|
|
for f in packet.fields:
|
||
|
|
field_size = core.get_field_size(f)
|
||
|
|
if field_size is not None:
|
||
|
|
constant_width += field_size
|
||
|
|
elif isinstance(f, (ast.PayloadField, ast.BodyField)):
|
||
|
|
variable_width.append("len(self.payload)")
|
||
|
|
elif isinstance(f, ast.TypedefField):
|
||
|
|
variable_width.append(f"self.{f.id}.size")
|
||
|
|
elif isinstance(f, ast.ArrayField) and isinstance(f.type, (ast.StructDeclaration, ast.CustomFieldDeclaration)):
|
||
|
|
variable_width.append(f"sum([elt.size for elt in self.{f.id}])")
|
||
|
|
elif isinstance(f, ast.ArrayField) and isinstance(f.type, ast.EnumDeclaration):
|
||
|
|
variable_width.append(f"len(self.{f.id}) * {f.type.width}")
|
||
|
|
elif isinstance(f, ast.ArrayField):
|
||
|
|
variable_width.append(f"len(self.{f.id}) * {int(f.width / 8)}")
|
||
|
|
else:
|
||
|
|
raise Exception("Unsupported field type")
|
||
|
|
|
||
|
|
constant_width = int(constant_width / 8)
|
||
|
|
if len(variable_width) == 0:
|
||
|
|
return [f"return {constant_width}"]
|
||
|
|
elif len(variable_width) == 1 and constant_width:
|
||
|
|
return [f"return {variable_width[0]} + {constant_width}"]
|
||
|
|
elif len(variable_width) == 1:
|
||
|
|
return [f"return {variable_width[0]}"]
|
||
|
|
elif len(variable_width) > 1 and constant_width:
|
||
|
|
return ([f"return {constant_width} + ("] + " +\n ".join(variable_width).split("\n") + [")"])
|
||
|
|
elif len(variable_width) > 1:
|
||
|
|
return (["return ("] + " +\n ".join(variable_width).split("\n") + [")"])
|
||
|
|
else:
|
||
|
|
assert False
|
||
|
|
|
||
|
|
|
||
|
|
def generate_packet_post_init(decl: ast.Declaration) -> List[str]:
|
||
|
|
"""Generate __post_init__ function to set constraint field values."""
|
||
|
|
|
||
|
|
# Gather all constraints from parent packets.
|
||
|
|
constraints = []
|
||
|
|
current = decl
|
||
|
|
while current.parent_id:
|
||
|
|
constraints.extend(current.constraints)
|
||
|
|
current = current.parent
|
||
|
|
|
||
|
|
if constraints:
|
||
|
|
code = []
|
||
|
|
for c in constraints:
|
||
|
|
if c.value is not None:
|
||
|
|
code.append(f"self.{c.id} = {c.value}")
|
||
|
|
else:
|
||
|
|
field = core.get_packet_field(decl, c.id)
|
||
|
|
code.append(f"self.{c.id} = {field.type_id}.{c.tag_id}")
|
||
|
|
return code
|
||
|
|
|
||
|
|
else:
|
||
|
|
return ["pass"]
|
||
|
|
|
||
|
|
|
||
|
|
def generate_enum_declaration(decl: ast.EnumDeclaration) -> str:
|
||
|
|
"""Generate the implementation of an enum type."""
|
||
|
|
|
||
|
|
enum_name = decl.id
|
||
|
|
tag_decls = []
|
||
|
|
for t in decl.tags:
|
||
|
|
tag_decls.append(f"{t.id} = {hex(t.value)}")
|
||
|
|
|
||
|
|
return dedent("""\
|
||
|
|
|
||
|
|
class {enum_name}(enum.IntEnum):
|
||
|
|
{tag_decls}
|
||
|
|
""").format(enum_name=enum_name, tag_decls=indent(tag_decls, 1))
|
||
|
|
|
||
|
|
|
||
|
|
def generate_packet_declaration(packet: ast.Declaration) -> str:
|
||
|
|
"""Generate the implementation a toplevel Packet or Struct
|
||
|
|
declaration."""
|
||
|
|
|
||
|
|
packet_name = packet.id
|
||
|
|
field_decls = []
|
||
|
|
for f in packet.fields:
|
||
|
|
if isinstance(f, ast.ScalarField):
|
||
|
|
field_decls.append(f"{f.id}: int = field(kw_only=True, default=0)")
|
||
|
|
elif isinstance(f, ast.TypedefField):
|
||
|
|
if isinstance(f.type, ast.EnumDeclaration):
|
||
|
|
field_decls.append(
|
||
|
|
f"{f.id}: {f.type_id} = field(kw_only=True, default={f.type_id}.{f.type.tags[0].id})")
|
||
|
|
elif isinstance(f.type, ast.ChecksumDeclaration):
|
||
|
|
field_decls.append(f"{f.id}: int = field(kw_only=True, default=0)")
|
||
|
|
elif isinstance(f.type, (ast.StructDeclaration, ast.CustomFieldDeclaration)):
|
||
|
|
field_decls.append(f"{f.id}: {f.type_id} = field(kw_only=True, default_factory={f.type_id})")
|
||
|
|
else:
|
||
|
|
raise Exception("Unsupported typedef field type")
|
||
|
|
elif isinstance(f, ast.ArrayField) and f.width == 8:
|
||
|
|
field_decls.append(f"{f.id}: bytearray = field(kw_only=True, default_factory=bytearray)")
|
||
|
|
elif isinstance(f, ast.ArrayField) and f.width:
|
||
|
|
field_decls.append(f"{f.id}: List[int] = field(kw_only=True, default_factory=list)")
|
||
|
|
elif isinstance(f, ast.ArrayField) and f.type_id:
|
||
|
|
field_decls.append(f"{f.id}: List[{f.type_id}] = field(kw_only=True, default_factory=list)")
|
||
|
|
|
||
|
|
if packet.parent_id:
|
||
|
|
parent_name = packet.parent_id
|
||
|
|
parent_fields = 'fields: dict, '
|
||
|
|
serializer = generate_derived_packet_serializer(packet)
|
||
|
|
else:
|
||
|
|
parent_name = 'Packet'
|
||
|
|
parent_fields = ''
|
||
|
|
serializer = generate_toplevel_packet_serializer(packet)
|
||
|
|
|
||
|
|
parser = generate_packet_parser(packet)
|
||
|
|
size = generate_packet_size_getter(packet)
|
||
|
|
post_init = generate_packet_post_init(packet)
|
||
|
|
|
||
|
|
return dedent("""\
|
||
|
|
|
||
|
|
@dataclass
|
||
|
|
class {packet_name}({parent_name}):
|
||
|
|
{field_decls}
|
||
|
|
|
||
|
|
def __post_init__(self):
|
||
|
|
{post_init}
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def parse({parent_fields}span: bytes) -> Tuple['{packet_name}', bytes]:
|
||
|
|
{parser}
|
||
|
|
|
||
|
|
def serialize(self, payload: bytes = None) -> bytes:
|
||
|
|
{serializer}
|
||
|
|
|
||
|
|
@property
|
||
|
|
def size(self) -> int:
|
||
|
|
{size}
|
||
|
|
""").format(packet_name=packet_name,
|
||
|
|
parent_name=parent_name,
|
||
|
|
parent_fields=parent_fields,
|
||
|
|
field_decls=indent(field_decls, 1),
|
||
|
|
post_init=indent(post_init, 2),
|
||
|
|
parser=indent(parser, 2),
|
||
|
|
serializer=indent(serializer, 2),
|
||
|
|
size=indent(size, 2))
|
||
|
|
|
||
|
|
|
||
|
|
def generate_custom_field_declaration_check(decl: ast.CustomFieldDeclaration) -> str:
|
||
|
|
"""Generate the code to validate a user custom field implementation.
|
||
|
|
|
||
|
|
This code is to be executed when the generated module is loaded to ensure
|
||
|
|
the user gets an immediate and clear error message when the provided
|
||
|
|
custom types do not fit the expected template.
|
||
|
|
"""
|
||
|
|
return dedent("""\
|
||
|
|
|
||
|
|
if (not callable(getattr({custom_field_name}, 'parse', None)) or
|
||
|
|
not callable(getattr({custom_field_name}, 'parse_all', None))):
|
||
|
|
raise Exception('The custom field type {custom_field_name} does not implement the parse method')
|
||
|
|
""").format(custom_field_name=decl.id)
|
||
|
|
|
||
|
|
|
||
|
|
def generate_checksum_declaration_check(decl: ast.ChecksumDeclaration) -> str:
|
||
|
|
"""Generate the code to validate a user checksum field implementation.
|
||
|
|
|
||
|
|
This code is to be executed when the generated module is loaded to ensure
|
||
|
|
the user gets an immediate and clear error message when the provided
|
||
|
|
checksum functions do not fit the expected template.
|
||
|
|
"""
|
||
|
|
return dedent("""\
|
||
|
|
|
||
|
|
if not callable({checksum_name}):
|
||
|
|
raise Exception('{checksum_name} is not callable')
|
||
|
|
""").format(checksum_name=decl.id)
|
||
|
|
|
||
|
|
|
||
|
|
def run(input: argparse.FileType, output: argparse.FileType, custom_type_location: Optional[str]):
|
||
|
|
file = ast.File.from_json(json.load(input))
|
||
|
|
core.desugar(file)
|
||
|
|
|
||
|
|
custom_types = []
|
||
|
|
custom_type_checks = ""
|
||
|
|
for d in file.declarations:
|
||
|
|
if isinstance(d, ast.CustomFieldDeclaration):
|
||
|
|
custom_types.append(d.id)
|
||
|
|
custom_type_checks += generate_custom_field_declaration_check(d)
|
||
|
|
elif isinstance(d, ast.ChecksumDeclaration):
|
||
|
|
custom_types.append(d.id)
|
||
|
|
custom_type_checks += generate_checksum_declaration_check(d)
|
||
|
|
|
||
|
|
output.write(f"# File generated from {input.name}, with the command:\n")
|
||
|
|
output.write(f"# {' '.join(sys.argv)}\n")
|
||
|
|
output.write("# /!\\ Do not edit by hand.\n")
|
||
|
|
if custom_types and custom_type_location:
|
||
|
|
output.write(f"\nfrom {custom_type_location} import {', '.join(custom_types)}\n")
|
||
|
|
output.write(generate_prelude())
|
||
|
|
output.write(custom_type_checks)
|
||
|
|
|
||
|
|
for d in file.declarations:
|
||
|
|
if isinstance(d, ast.EnumDeclaration):
|
||
|
|
output.write(generate_enum_declaration(d))
|
||
|
|
elif isinstance(d, (ast.PacketDeclaration, ast.StructDeclaration)):
|
||
|
|
output.write(generate_packet_declaration(d))
|
||
|
|
|
||
|
|
|
||
|
|
def main() -> int:
|
||
|
|
"""Generate python PDL backend."""
|
||
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
||
|
|
parser.add_argument('--input', type=argparse.FileType('r'), default=sys.stdin, help='Input PDL-JSON source')
|
||
|
|
parser.add_argument('--output', type=argparse.FileType('w'), default=sys.stdout, help='Output Python file')
|
||
|
|
parser.add_argument('--custom-type-location',
|
||
|
|
type=str,
|
||
|
|
required=False,
|
||
|
|
help='Module of declaration of custom types')
|
||
|
|
return run(**vars(parser.parse_args()))
|
||
|
|
|
||
|
|
|
||
|
|
if __name__ == '__main__':
|
||
|
|
sys.exit(main())
|