code: def _process_state(cls, unprocessed, processed, state):
          
          assert type(state) is str, "wrong state name %r" % state
          assert state[0] != '#', "invalid state name %r" % state
          if state in processed:
              return processed[state]
          tokens = processed[state] = []
          rflags = cls.flags
          for tdef in unprocessed[state]:
              if isinstance(tdef, include):
                  # it's a state reference
                  assert tdef != state, "circular state reference %r" % state
                  tokens.extend(cls._process_state(unprocessed, processed,
                                                   str(tdef)))
                  continue
              if isinstance(tdef, _inherit):
                  # should be processed already, but may not in the case of:
                  # 1. the state has no counterpart in any parent
                  # 2. the state includes more than one 'inherit'
                  continue
              if isinstance(tdef, default):
                  new_state = cls._process_new_state(tdef.state, unprocessed, processed)
                  tokens.append((re.compile('').match, None, new_state))
                  continue
  
              assert type(tdef) is tuple, "wrong rule def %r" % tdef
  
              try:
                  rex = cls._process_regex(tdef[0], rflags, state)
              except Exception as err:
                  raise ValueError("uncompilable regex %r in state %r of %r: %s" %
                                   (tdef[0], state, cls, err))
  
              token = cls._process_token(tdef[1])
  
              if len(tdef) == 2:
                  new_state = None
              else:
                  new_state = cls._process_new_state(tdef[2],
                                                     unprocessed, processed)
  
              tokens.append((rex, token, new_state))
          return tokens
docs: Preprocess a single state definition.