code: def _get_operations(self, context):
          
          #Most of the time, the real-time update is going to fire with
          #incomplete statements that don't result in any changes being made
          #to the module instances. The SequenceMatches caches hashes for the
          #second argument. Logically, we want to turn the cached version into
          #the buffer version; however, the buffer is the string that keeps 
          #changing.
  
          #in order to optimize the real-time update, we *switch* the two strings
          #when we set the sequence and then fix the references on the operations
          #after the fact.
          if context.module.changed or self.unset:
              self.matcher.set_seq2(context.cachedstr)
              self.unset = False
              #Set the changed flag back to false now that the sequencer has
              #reloaded it.
              context.module.changed = False
          self.matcher.set_seq1(context.bufferstr)
  
          opcodes = self.matcher.get_opcodes()
          result = []
  
          #Index i keeps track of how many operations were actually added because
          #they constituted a change we need to take care of.
          i = 0
          for code in opcodes:
              if code[0] != "equal":
                  #Replacements don't have a mode change. All of the operations
                  #switch the order of the line indices for the two strings.
                  if code[0] == "insert":
                      newcode = ("delete", code[3], code[4], code[1], code[2])
                  elif code[0] == "delete":
                      newcode = ("insert", code[3], code[4], code[1], code[2])
                  else:
                      newcode = ("replace", code[3], code[4], code[1], code[2])
  
                  op = Operation(context, self.parser, newcode, i)
                  result.append(op)
                  i += 1
  
          return result
docs: Returns a list of operations that need to be performed to turn the
          cached source code into the one in the buffer.