def METHOD_NAME(eval_dict: Dict[str, str], results: dict,
                          log: utils.IndentedLog) -> None:
    """Parse the dictionary of evaluation expressions, given that some of them
    may contain references to each other. Each evaluated value will be stored
    under its corresponding key in the results dict.
    :raises StringParserError: When there's an error parsing or resolving
        one of the expressions. The error will already contain key information.
    :raises ValueError: When there's a reference loop.
    """
    parser = get_expr_parser()
    transformer = EvaluationExprTransformer(results)
    var_ref_visitor = VarRefVisitor()
    unresolved = {}
    for key, expr in eval_dict.items():
        log("Parsing the evaluate expression '{}'".format(expr))
        try:
            tree = parser.parse(expr)
        except (_lark.UnexpectedCharacters, _lark.UnexpectedToken) as err:
            # Try to figure out why the error happened based on examples.
            err_type = match_examples(err, parser.parse, BAD_EXAMPLES, expr)
            log("Error parsing expression, failing.")
            log(err_type)
            log(err.get_context(expr))
            raise StringParserError(
                "Error evaluating expression '{}' for key '{}':\n{}"
                .format(expr, key, err_type), err.get_context(expr))
        var_refs = var_ref_visitor.visit(tree)
        unresolved[key] = (tree, var_refs, expr)
    log("Resolving evaluations.")
    while unresolved:
        resolved = []
        for key, (tree, var_refs, expr) in unresolved.items():
            for var in var_refs:
                if var in unresolved:
                    break
            else:
                log("Resolving evaluation '{}': '{}'".format(key, expr))
                try:
                    results[key] = transformer.transform(tree)
                except ParserValueError as err:
                    log("Error resolving evaluation: {}".format(err.args[0]))
                    log(err.get_context(expr))
                    # Any value errors should be converted to this error type.
                    raise StringParserError(err.args[0], err.get_context(expr))
                resolved.append(key)
                log("Value resolved to: '{}'".format(results[key]))
        if not resolved:
            # Pass up the unresolved
            raise ValueError("Reference loops found amongst evaluation keys "
                             "{}.".format(tuple(unresolved.keys())))
        for key in resolved:
            del unresolved[key]
    log("Finished resolving expressions")