docs: 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)