code: def leave_scope(self):
          
          def entry_size(entry):
              """ For local variables and params, returns the real variable or
              local array size in bytes
              """
              if entry.scope == SCOPE.global_ or \
                      entry.is_aliased:  # aliases or global variables = 0
                  return 0
  
              if entry.class_ != CLASS.array:
                  return entry.size
  
              return entry.memsize
  
          for v in self.table[self.current_scope].values(filter_by_opt=False):
              if not v.accessed:
                  if v.scope == SCOPE.parameter:
                      kind = 'Parameter'
                      v.accessed = True  # HINT: Parameters must always be present even if not used!
                      warning_not_used(v.lineno, v.name, kind=kind)
  
          entries = sorted(self.table[self.current_scope].values(filter_by_opt=True), key=entry_size)
          offset = 0
  
          for entry in entries:  # Symbols of the current level
              if entry.class_ is CLASS.unknown:
                  self.move_to_global_scope(entry.name)
  
              if entry.class_ in (CLASS.function, CLASS.label, CLASS.type_):
                  continue
  
              # Local variables offset
              if entry.class_ == CLASS.var and entry.scope == SCOPE.local:
                  if entry.alias is not None:  # alias of another variable?
                      if entry.offset is None:
                          entry.offset = entry.alias.offset
                      else:
                          entry.offset = entry.alias.offset - entry.offset
                  else:
                      offset += entry_size(entry)
                      entry.offset = offset
  
              if entry.class_ == CLASS.array and entry.scope == SCOPE.local:
                  entry.offset = entry_size(entry) + offset
                  offset = entry.offset
  
          self.mangle = self[self.current_scope].parent_mangle
          self.table.pop()
          global_.LOOPS = global_.META_LOOPS.pop()
          return offset
docs: Ends a function body and pops current scope out of the symbol table.