def c_eval(expr: str) -> Union[int, float]:
    """
    Evaluate a C arithmetic/logic expression and return the result

    Examples:
        >>> c_eval('10 + (5 / 3)')
        11
        >>> c_eval('!0')
        1
        >>> c_eval('sizeof(x)')
        128

    Args:
        expr: C expression

    Returns:
        result: the expression evaluation result

    Raises:
        EvalError: expression evaluation error
    """
    try:
        expr = expr.replace("!", " not ").replace("&&", " and ").replace("||", " or ")
        return eval_node(ast.parse(expr.strip()).body[0])
    except EvalError:
        raise
    except Exception:
        raise EvalError

def eval_attribute_node(node: ast.Attribute) -> Union[int, float]:
    """
    Evaluate node attribute, e.g. 'self.x'
    Only 'self' is allowed. The attribute must be a number.

    Args:
        node: attribute node

    Returns:
        result: the attribute value

    Raises:
        EvalError: expression result is not a number, or not self attribute
        ContextNotFound: context is not defined
    """
    if not node.value or node.value.id != "self":  # type: ignore
        raise EvalError("only self is allowed")
    context = get_cstruct_context()
    if context is None:
        raise ContextNotFound("context is not defined")
    result = getattr(context, node.attr)
    if not isinstance(result, (int, float)):
        raise EvalError("expression result is not a number")
    return result

def eval_compare(node) -> bool:
    "Evaluate a compare node"
    right = eval_node(node.left)
    for operation, comp in zip(node.ops, node.comparators):
        left = right
        right = eval_node(comp)
        if not OPS[type(operation)](left, right):
            return False
    return True

def eval_div(node) -> Union[int, float]:
    "Evaluate div node (integer/float)"
    left = eval_node(node.left)
    right = eval_node(node.right)
    if isinstance(left, float) or isinstance(right, float):
        return operator.truediv(left, right)
    else:
        return operator.floordiv(left, right)

def eval_get(node) -> Union[int, float, Type["AbstractCStruct"]]:
    "Get definition/struct by name"
    try:
        return DEFINES[node.id]
    except KeyError:
        return STRUCTS[node.id]

def get_cstruct_context() -> Optional["AbstractCStruct"]:
    """
    Get the calling CStruct instance from the stack (if any)
    """
    from .abstract import AbstractCStruct

    stack = inspect.stack()
    for frame in stack:
        caller_self = frame.frame.f_locals.get("self")
        if isinstance(caller_self, AbstractCStruct):
            return caller_self
    return None