Process review feedback

Author: Schamper

dissect/cstruct/cstruct.py

@@ -253,11 +253,7 @@ def load(self, definition: str, deftype: int | None = None, **kwargs) -> cstruct
         Definitions can be parsed using different parsers. Currently, there's
         only one supported parser - DEF_CSTYLE. Parsers can add types and
         modify this cstruct instance. Arguments can be passed to parsers
-        using kwargs.
-
-        The CSTYLE parser was recently replaced with token based parser,
-        instead of a strictly regex based one. The old parser is still available
-        by using DEF_LEGACY.
+        using ``kwargs``.
 
         Args:
             definition: The definition to parse.

dissect/cstruct/lexer.py

@@ -482,7 +482,8 @@ def tokenize(self) -> list[Token]:
 
             elif ch == "-" and (
                 self._pos == 0
-                or self._tokens[-1].type not in (TokenType.IDENTIFIER, TokenType.NUMBER, TokenType.RPAREN)
+                or self._tokens[-1].type
+                not in (TokenType.IDENTIFIER, TokenType.NUMBER, TokenType.RPAREN, TokenType.RBRACKET)
             ):
                 self._emit(TokenType.UNARY_MINUS, self._take(), line, col)
 

dissect/cstruct/parser.py

@@ -7,6 +7,7 @@
 from dissect.cstruct import compiler
 from dissect.cstruct.exceptions import (
     ExpressionParserError,
+    LexerError,
     ParserError,
 )
 from dissect.cstruct.expression import Expression
@@ -91,11 +92,6 @@ def _at(self, *types: TokenType) -> bool:
         """Return whether the current token matches any of the given types."""
         return self._tokens[self._pos].type in types
 
-    def _at_value(self, value: str) -> bool:
-        """Return whether the current token is an identifier with the given value."""
-        token = self._tokens[self._pos]
-        return token.type == TokenType.IDENTIFIER and token.value == value
-
     def _error(self, msg: str, *, token: Token | None = None) -> ParserError:
         return ParserError(f"line {(token if token is not None else self._tokens[self._pos]).line}: {msg}")
 
@@ -188,7 +184,7 @@ def _parse_define(self) -> None:
         if isinstance(value, str):
             try:
                 value = Expression(value).evaluate(self.cs)
-            except ExpressionParserError:
+            except (LexerError, ExpressionParserError):
                 # If evaluation fails, just keep it as a string (e.g. for macro-like constants)
                 pass
 

dissect/cstruct/utils.py

@@ -367,10 +367,10 @@ def sizeof(type_: type[BaseType] | BaseType) -> int:
     return len(type_)
 
 
-def offsetof(type_: type[Structure], field: str) -> int:
+def offsetof(type_: type[Structure], name: str) -> int:
     """Get the offset of a field in a structure."""
-    if (field := type_.fields.get(field)) is None:
-        raise ValueError(f"Structure '{type_.__name__}' does not have a field named '{field}'")
+    if (field := type_.fields.get(name)) is None:
+        raise ValueError(f"Structure '{type_.__name__}' does not have a field named '{name}'")
     if (offset := field.offset) is None:
         raise ValueError(f"Field '{field._name}' of structure '{type_.__name__}' does not have a known offset")
     return offset

tests/test_lexer.py

@@ -56,6 +56,23 @@
         ("a << b", [TokenType.IDENTIFIER, TokenType.LSHIFT, TokenType.IDENTIFIER], ["a", "<<", "b"]),
         ("x >> 2", [TokenType.IDENTIFIER, TokenType.RSHIFT, TokenType.NUMBER], ["x", ">>", "2"]),
         ("-1", [TokenType.UNARY_MINUS, TokenType.NUMBER], ["-", "1"]),
+        (
+            "(0) - 1",
+            [TokenType.LPAREN, TokenType.NUMBER, TokenType.RPAREN, TokenType.MINUS, TokenType.NUMBER],
+            ["(", "0", ")", "-", "1"],
+        ),
+        (
+            "c[1] - 1",
+            [
+                TokenType.IDENTIFIER,
+                TokenType.LBRACKET,
+                TokenType.NUMBER,
+                TokenType.RBRACKET,
+                TokenType.MINUS,
+                TokenType.NUMBER,
+            ],
+            ["c", "[", "1", "]", "-", "1"],
+        ),
         ("1 - 1", [TokenType.NUMBER, TokenType.MINUS, TokenType.NUMBER], ["1", "-", "1"]),
         # Preprocessor directives
         ("#define", [TokenType.PP_DEFINE], ["define"]),