from core import *
from adapters import *
from macros import *
#===============================================================================
# exceptions
#===============================================================================
class QuotedStringError(ConstructError):
__slots__ = []
#===============================================================================
# constructs
#===============================================================================
class QuotedString(Construct):
r"""
A quoted string (begins with an opening-quote, terminated by a
closing-quote, which may be escaped by an escape character)
Parameters:
* name - the name of the field
* start_quote - the opening quote character. default is '"'
* end_quote - the closing quote character. default is '"'
* esc_char - the escape character, or None to disable escaping. defualt
is "\" (backslash)
* encoding - the character encoding (e.g., "utf8"), or None to return
raw bytes. defualt is None.
* allow_eof - whether to allow EOF before the closing quote is matched.
if False, an exception will be raised when EOF is reached by the closing
quote is missing. default is False.
Example:
QuotedString("foo", start_quote = "{", end_quote = "}", esc_char = None)
"""
__slots__ = [
"start_quote", "end_quote", "char", "esc_char", "encoding",
"allow_eof"
]
def __init__(self, name, start_quote = '"', end_quote = None,
esc_char = '\\', encoding = None, allow_eof = False):
Construct.__init__(self, name)
if end_quote is None:
end_quote = start_quote
self.start_quote = Literal(start_quote)
self.char = Char("char")
self.end_quote = end_quote
self.esc_char = esc_char
self.encoding = encoding
self.allow_eof = allow_eof
def _parse(self, stream, context):
self.start_quote._parse(stream, context)
text = []
escaped = False
try:
while True:
ch = self.char._parse(stream, context)
if ch == self.esc_char:
if escaped:
text.append(ch)
escaped = False
else:
escaped = True
elif ch == self.end_quote and not escaped:
break
else:
text.append(ch)
escaped = False
except FieldError:
if not self.allow_eof:
raise
text = "".join(text)
if self.encoding is not None:
text = text.decode(self.encoding)
return text
def _build(self, obj, stream, context):
self.start_quote._build(None, stream, context)
if self.encoding:
obj = obj.encode(self.encoding)
for ch in obj:
if ch == self.esc_char:
self.char._build(self.esc_char, stream, context)
elif ch == self.end_quote:
if self.esc_char is None:
raise QuotedStringError("found ending quote in data, "
"but no escape char defined", ch)
else:
self.char._build(self.esc_char, stream, context)
self.char._build(ch, stream, context)
self.char._build(self.end_quote, stream, context)
def _sizeof(self, context):
raise SizeofError("can't calculate size")
#===============================================================================
# macros
#===============================================================================
class WhitespaceAdapter(Adapter):
"""
Adapter for whitespace sequences; do not use directly.
See Whitespace.
Parameters:
* subcon - the subcon to adapt
* build_char - the character used for encoding (building)
"""
__slots__ = ["build_char"]
def __init__(self, subcon, build_char):
Adapter.__init__(self, subcon)
self.build_char = build_char
def _encode(self, obj, context):
return self.build_char
def _decode(self, obj, context):
return None
def Whitespace(charset = " \t", optional = True):
"""whitespace (space that is ignored between tokens). when building, the
first character of the charset is used.
* charset - the set of characters that are considered whitespace. default
is space and tab.
* optional - whether or not whitespace is optional. default is True.
"""
con = CharOf(None, charset)
if optional:
con = OptionalGreedyRange(con)
else:
con = GreedyRange(con)
return WhitespaceAdapter(con, build_char = charset[0])
def Literal(text):
"""matches a literal string in the text
* text - the text (string) to match
"""
return ConstAdapter(Field(None, len(text)), text)
def Char(name):
"""a one-byte character"""
return Field(name, 1)
def CharOf(name, charset):
"""matches only characters of a given charset
* name - the name of the field
* charset - the set of valid characters
"""
return OneOf(Char(name), charset)
def CharNoneOf(name, charset):
"""matches only characters that do not belong to a given charset
* name - the name of the field
* charset - the set of invalid characters
"""
return NoneOf(Char(name), charset)
def Alpha(name):
"""a letter character (A-Z, a-z)"""
return CharOf(name, set('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'))
def Digit(name):
"""a digit character (0-9)"""
return CharOf(name, set('0123456789'))
def AlphaDigit(name):
"""an alphanumeric character (A-Z, a-z, 0-9)"""
return CharOf(name, set("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"))
def BinDigit(name):
"""a binary digit (0-1)"""
return CharOf(name, set('01'))
def HexDigit(name):
"""a hexadecimal digit (0-9, A-F, a-f)"""
return CharOf(name, set('0123456789abcdefABCDEF'))
def Word(name):
"""a sequence of letters"""
return StringAdapter(GreedyRange(Alpha(name)))
class TextualIntAdapter(Adapter):
"""
Adapter for textual integers
Parameters:
* subcon - the subcon to adapt
* radix - the base of the integer (decimal, hexadecimal, binary, ...)
* digits - the sequence of digits of that radix
"""
__slots__ = ["radix", "digits"]
def __init__(self, subcon, radix = 10, digits = "0123456789abcdef"):
Adapter.__init__(self, subcon)
if radix > len(digits):
raise ValueError("not enough digits for radix %d" % (radix,))
self.radix = radix
self.digits = digits
def _encode(self, obj, context):
chars = []
if obj < 0:
chars.append("-")
n = -obj
else:
n = obj
r = self.radix
digs = self.digits
while n > 0:
n, d = divmod(n, r)
chars.append(digs[d])
# obj2 = "".join(reversed(chars))
# filler = digs[0] * (self._sizeof(context) - len(obj2))
# return filler + obj2
return "".join(reversed(chars))
def _decode(self, obj, context):
return int("".join(obj), self.radix)
def DecNumber(name):
"""decimal number"""
return TextualIntAdapter(GreedyRange(Digit(name)))
def BinNumber(name):
"""binary number"""
return TextualIntAdapter(GreedyRange(Digit(name)), 2)
def HexNumber(name):
"""hexadecimal number"""
return TextualIntAdapter(GreedyRange(Digit(name)), 16)
def StringUpto(name, charset):
"""a string that stretches up to a terminator, or EOF. unlike CString,
StringUpto will no consume the terminator char.
* name - the name of the field
* charset - the set of terminator characters"""
return StringAdapter(OptionalGreedyRange(CharNoneOf(name, charset)))
def Line(name):
r"""a textual line (up to "\n")"""
return StringUpto(name, "\n")
class IdentifierAdapter(Adapter):
"""
Adapter for programmatic identifiers
Parameters:
* subcon - the subcon to adapt
"""
def _encode(self, obj, context):
return obj[0], obj[1:]
def _decode(self, obj, context):
return obj[0] + "".join(obj[1])
def Identifier(name,
headset = set("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"),
tailset = set("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_")
):
"""a programmatic identifier (symbol). must start with a char of headset,
followed by a sequence of tailset characters
* name - the name of the field
* headset - charset for the first character. default is A-Z, a-z, and _
* tailset - charset for the tail. default is A-Z, a-z, 0-9 and _
"""
return IdentifierAdapter(
Sequence(name,
CharOf("head", headset),
OptionalGreedyRange(CharOf("tail", tailset)),
)
)
|