code: def access_call(self, id_, lineno, scope=None, type_=None):
          
          entry = self.access_id(id_, lineno, scope, default_type=type_)
          if entry is None:
              return self.access_func(id_, lineno)
  
          if entry.callable is False:  # Is it NOT callable?
              if entry.type_ != self.basic_types[TYPE.string]:
                  syntax_error_not_array_nor_func(lineno, id_)
                  return None
              else:  # Ok, it is a string slice if it has 0 or 1 parameters
                  return entry
  
          if entry.callable is None and entry.type_ == self.basic_types[TYPE.string]:
              # Ok, it is a string slice if it has 0 or 1 parameters
              entry.callable = False
              return entry
  
          # Mangled name (functions always has _name as mangled)
          # entry.mangled = '_%s' % entry.name
          # entry.callable = True  # HINT: must be true already
          return entry
docs: Creates a func/array/string call. Checks if id is callable or not.
          An identifier is "callable" if it can be followed by a list of para-
          meters.
          This does not mean the id_ is a function, but that it allows the same
          syntax a function does:
  
          For example:
             - MyFunction(a, "hello", 5) is a Function so MyFuncion is callable
             - MyArray(5, 3.7, VAL("32")) makes MyArray identifier "callable".
             - MyString(5 TO 7) or MyString(5) is a "callable" string.