172 lines
4.9 KiB
Python
172 lines
4.9 KiB
Python
from typing import Optional as O, Union as U, Any, Generic as G, TypeVar
|
|
from ..core.base import Type, Context, PossibleDynamic as D
|
|
from ..core.io import Stream, Pos, PosInfo
|
|
from ..core.meta import Wrapper
|
|
from ..core.expr import BaseExpr
|
|
|
|
|
|
T = TypeVar('T')
|
|
|
|
class Nothing(Type[None]):
|
|
def __init__(self) -> None:
|
|
pass
|
|
|
|
def parse(self, context: Context, stream: Stream) -> None:
|
|
return None
|
|
|
|
def dump(self, context: Context, stream: Stream, value: None) -> None:
|
|
pass
|
|
|
|
def sizeof(self, context: Context, start: PosInfo, value: None) -> O[PosInfo]:
|
|
return 0
|
|
|
|
def default(self, context: Context) -> None:
|
|
return None
|
|
|
|
def __str__(self) -> str:
|
|
return 'Nothing'
|
|
|
|
def __repr__(self) -> str:
|
|
return '{__name__}.Nothing()'
|
|
|
|
class Implied(G[T], Type[T]):
|
|
""" Parse/dump nothing, yield value. """
|
|
__slots__ = ('value',)
|
|
|
|
def __init__(self, value: U[BaseExpr[T], T]) -> None:
|
|
self.value = value
|
|
|
|
def parse(self, context: Context, stream: Stream) -> T:
|
|
return context.get(self.value)
|
|
|
|
def dump(self, context: Context, stream: Stream, value: T) -> None:
|
|
context.put(self.value, value)
|
|
|
|
def sizeof(self, context: Context, start: PosInfo, value: O[T]) -> O[PosInfo]:
|
|
return 0
|
|
|
|
def default(self, context: Context) -> T:
|
|
return context.peek(self.value)
|
|
|
|
def __str__(self) -> str:
|
|
return f'={self.value}'
|
|
|
|
def __repr__(self) -> str:
|
|
return f'{__name__}.Static({self.value!r})'
|
|
|
|
class Ignored(G[T], Wrapper[T]):
|
|
""" Parse/dump something, yield nothing. """
|
|
def __init__(self, child: Type[T]) -> None:
|
|
super().__init__(child)
|
|
|
|
def parse(self, context: Context, stream: Stream) -> None:
|
|
super().parse(context, stream)
|
|
|
|
def dump(self, context: Context, stream: Stream, value: None) -> None:
|
|
super().dump(context, stream, super().default(context))
|
|
|
|
def default(self, context: Context) -> None:
|
|
return None
|
|
|
|
def __str__(self) -> str:
|
|
return f'(void){super().__str__()}'
|
|
|
|
def __repr__(self) -> str:
|
|
return f'{__name__}.Ignored({super().__repr__()}'
|
|
|
|
class Pad(Type[None]):
|
|
""" Seek something, yield nothing. """
|
|
__slots__ = ('amount', 'value')
|
|
|
|
def __init__(self, amount=0, value=b'\x00'):
|
|
self.amount = amount
|
|
self.value = value
|
|
|
|
def parse(self, context: Context, stream: Stream) -> None:
|
|
stream.seek(context.get(self.amount), os.SEEK_CUR)
|
|
|
|
def dump(self, context: Context, stream: Stream, value: None) -> None:
|
|
value = stretch(context.get(self.value), context.get(self.amount))
|
|
stream.write(value)
|
|
|
|
def sizeof(self, context: Context, start: PosInfo) -> O[PosInfo]:
|
|
return context.peek(self.amount)
|
|
|
|
def default(self, context: Context) -> None:
|
|
return None
|
|
|
|
def __str__(self) -> str:
|
|
return f'[padding: {self.amount}]'
|
|
|
|
def __repr__(self) -> str:
|
|
return f'{__name__}.Pad({self.amount!r}, value={self.value!r})'
|
|
|
|
|
|
class Data(Type[bytes]):
|
|
""" Parse/dump and yield bytes. """
|
|
__slots__ = ('size',)
|
|
|
|
def __init__(self, size: U[D, O[int]] = None) -> None:
|
|
self.size = size
|
|
|
|
def parse(self, context: Context, stream: Stream) -> bytes:
|
|
size = context.get(self.size)
|
|
if size is None:
|
|
size = -1
|
|
return stream.read(size)
|
|
|
|
def dump(self, context: Context, stream: Stream, value: bytes) -> None:
|
|
stream.write(value)
|
|
context.put(self.size, len(value))
|
|
|
|
def default(self, context: Context) -> bytes:
|
|
size = context.peek(self.size)
|
|
if size is None:
|
|
size = 0
|
|
return bytes(size)
|
|
|
|
def sizeof(self, context: Context, start: PosInfo, value: O[bytes]) -> O[Pos]:
|
|
if value is not None:
|
|
return len(value)
|
|
return context.peek(self.size)
|
|
|
|
def __str__(self) -> str:
|
|
return f'byte[{self.size if self.size else ""}]'
|
|
|
|
def __repr__(self) -> str:
|
|
return f'{__name__}.Data({self.size!r})'
|
|
|
|
data = Data()
|
|
|
|
class Bits(Type[int]):
|
|
""" Parse/dump and yield bits. """
|
|
__slots__ = ('amount',)
|
|
|
|
def __init__(self, amount: U[D, int] = 0) -> None:
|
|
self.amount = amount
|
|
|
|
def parse(self, context: Context, stream: Stream) -> int:
|
|
amount = context.get(self.amount)
|
|
if amount is None:
|
|
amount = -1
|
|
return stream.read(amount, bits=True)
|
|
|
|
def dump(self, context: Context, stream: Stream, value: int) -> None:
|
|
amount = context.get(self.amount)
|
|
stream.write(value, bits=amount)
|
|
|
|
def default(self, context: Context) -> int:
|
|
return 0
|
|
|
|
def sizeof(self, context: Context, start: PosInfo, value: O[int]) -> O[Pos]:
|
|
return context.peek(self.amount) // 8
|
|
|
|
def __str__(self) -> str:
|
|
return f'bit[{self.amount}]'
|
|
|
|
def __repr__(self) -> str:
|
|
return f'{__name__}.Bits({self.amount!r})'
|
|
|
|
bit = Bits(1)
|
|
nibble = Bits(4)
|