| 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)), | |
| ) | |
| ) | |