def _resolve_available(self, tokens, context):
        """
        Checks the token stream for context references and if there are missing references - substitutes available
        references and returns a partially evaluated expression.
        :param tokens: the token stream (all tokens fetched)
        :param context: the evaluation context
        :return: the partially evaluated expression or none if expression can be fully evaluated
        """
        from .gen.ExcellentParser import ExcellentParser

        has_missing = False
        output_components = []

        for t in range(len(tokens.tokens) - 1):  # we can ignore the final EOF token
            token = tokens.get(t)
            next_token = tokens.get(t + 1)

            # if token is a NAME not followed by ( then it's a context reference
            if token.type == ExcellentParser.NAME and next_token.type != ExcellentParser.LPAREN:
                try:
                    output_components.append(context.resolve_variable(token.text))
                except EvaluationError:
                    has_missing = True
                    output_components.append(token)
            else:
                output_components.append(token)

        # if we don't have missing context references, perform evaluation as normal
        if not has_missing:
            return None

        # re-combine the tokens and context values back into an expression
        output = [self._expression_prefix]

        for output_component in output_components:
            if isinstance(output_component, Token):
                comp_val = output_component.text
            else:
                comp_val = conversions.to_repr(output_component, context)
            output.append(comp_val)

        return ''.join(output)
Checks the token stream for context references and if there are missing references - substitutes available
        references and returns a partially evaluated expression.
        :param tokens: the token stream (all tokens fetched)
        :param context: the evaluation context
        :return: the partially evaluated expression or none if expression can be fully evaluated