angr/state_plugins/heap/utils.py
def concretize(x, solver, sym_handler):
    """
    For now a lot of naive concretization is done when handling heap metadata to keep things manageable. This idiom
    showed up a lot as a result, so to reduce code repetition this function uses a callback to handle the one or two
    operations that varied across invocations.

    :param x: the item to be concretized
    :param solver: the solver to evaluate the item with
    :param sym_handler: the handler to be used when the item may take on more than one value
    :returns: a concrete value for the item
    """
    if solver.symbolic(x):
        try:
            return solver.eval_one(x)
        except SimSolverError:
            return sym_handler(x)
    else:
        return solver.eval(x)

    For now a lot of naive concretization is done when handling heap metadata to keep things manageable. This idiom
    showed up a lot as a result, so to reduce code repetition this function uses a callback to handle the one or two
    operations that varied across invocations.

    :param x: the item to be concretized
    :param solver: the solver to evaluate the item with
    :param sym_handler: the handler to be used when the item may take on more than one value
    :returns: a concrete value for the item
    
For now a lot of naive concretization is done when handling heap metadata to keep things manageable. This idiom
showed up a lot as a result, so to reduce code repetition this function uses a callback to handle the one or two
operations that varied across invocations.
For now a lot of naive concretization is done when handling heap metadata to keep things manageable . This idiom showed up a lot as a result so to reduce code repetition this function uses a callback to handle the one or two operations that varied across invocations .
def concretize(x, solver, sym_handler):
    if solver.symbolic(x):
        try:
            return solver.eval_one(x)
        except SimSolverError:
            return sym_handler(x)
    else:
        return solver.eval(x)
def concretize ( x , solver , sym_handler ) : if solver . symbolic ( x ) : try : return solver . eval_one ( x ) except SimSolverError : return sym_handler ( x ) else : return solver . eval ( x )
For now a lot of naive concretization is done when handling heap metadata to keep things manageable.
For now a lot of naive concretization is done when handling heap metadata to keep things manageable .
"""
    For now a lot of naive concretization is done when handling heap metadata to keep things manageable. This idiom
    showed up a lot as a result, so to reduce code repetition this function uses a callback to handle the one or two
    operations that varied across invocations.

    :param x: the item to be concretized
    :param solver: the solver to evaluate the item with
    :param sym_handler: the handler to be used when the item may take on more than one value
    :returns: a concrete value for the item
    """
a concrete value for the item
a concrete value for the item
x
the item to be concretized
the item to be concretized
solver
the solver to evaluate the item with
the solver to evaluate the item with
sym_handler
the handler to be used when the item may take on more than one value
the handler to be used when the item may take on more than one value