+++ /dev/null
-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)),
- )
- )
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
projects / pyelftools.git / commitdiff