/* GNU Objective C Runtime method related functions.
   Copyright (C) 2010-2018 Free Software Foundation, Inc.
   Contributed by Nicola Pero

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 3, or (at your option) any later version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
details.

Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.

You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
<http://www.gnu.org/licenses/>.  */

#include "objc-private/common.h"
#include "objc/runtime.h"
#include "objc-private/module-abi-8.h" /* For runtime structures.   */
#include "objc/thr.h"
#include "objc-private/runtime.h"      /* For __objc_runtime_mutex.  */
#include <stdlib.h>                    /* For malloc.  */

SEL
method_getName (struct objc_method * method)
{
  if (method == NULL)
    return NULL;

  return method->method_name;
}

const char *
method_getTypeEncoding (struct objc_method * method)
{
  if (method == NULL)
    return NULL;

  return method->method_types;
}

IMP
method_getImplementation (struct objc_method * method)
{
  if (method == NULL)
    return NULL;

  return method->method_imp;
}

struct objc_method_description *
method_getDescription (struct objc_method * method)
{
  /* Note that the following returns NULL if method is NULL, which is
     fine.  */
  return (struct objc_method_description *)method;
}

struct objc_method **
class_copyMethodList (Class class_, unsigned int *numberOfReturnedMethods)
{
  unsigned int count = 0;
  struct objc_method **returnValue = NULL;
  struct objc_method_list* method_list;

  if (class_ == Nil)
    {
      if (numberOfReturnedMethods)
	*numberOfReturnedMethods = 0;
      return NULL;
    }

  /* Lock the runtime mutex because the class methods may be
     concurrently modified.  */
  objc_mutex_lock (__objc_runtime_mutex);

  /* Count how many methods we have.  */
  method_list = class_->methods;

  while (method_list)
    {
      count = count + method_list->method_count;
      method_list = method_list->method_next;
    }

  if (count != 0)
    {
      unsigned int i = 0;
      
      /* Allocate enough memory to hold them.  */
      returnValue 
	= (struct objc_method **)(malloc (sizeof (struct objc_method *) 
					  * (count + 1)));
      
      /* Copy the methods.  */
      method_list = class_->methods;
      
      while (method_list)
	{
	  int j;
	  for (j = 0; j < method_list->method_count; j++)
	    {
	      returnValue[i] = &(method_list->method_list[j]);
	      i++;
	    }
	  method_list = method_list->method_next;
	}
      
      returnValue[i] = NULL;
    }

  objc_mutex_unlock (__objc_runtime_mutex);

  if (numberOfReturnedMethods)
    *numberOfReturnedMethods = count;

  return returnValue;
}

IMP
method_setImplementation (struct objc_method * method, IMP implementation)
{
  IMP old_implementation;

  if (method == NULL  ||  implementation == NULL)
    return NULL;

  /* We lock the runtime mutex so that concurrent calls to change the
     same method won't conflict with each other.  */
  objc_mutex_lock (__objc_runtime_mutex);

  old_implementation = method->method_imp;
  method->method_imp = implementation;

  /* That was easy :-).  But now we need to find all classes that use
     this method, and update the IMP in the dispatch tables.  */
  __objc_update_classes_with_methods (method, NULL);

  objc_mutex_unlock (__objc_runtime_mutex);

  return old_implementation;
}

void
method_exchangeImplementations (struct objc_method * method_a, struct objc_method * method_b)
{
  IMP old_implementation_a;
  IMP old_implementation_b;

  if (method_a == NULL  ||  method_b == NULL)
    return;

  /* We lock the runtime mutex so that concurrent calls to exchange
     similar methods won't conflict with each other.  Each of them
     should be atomic.  */
  objc_mutex_lock (__objc_runtime_mutex);

  old_implementation_a = method_a->method_imp;
  old_implementation_b = method_b->method_imp;

  method_a->method_imp = old_implementation_b;
  method_b->method_imp = old_implementation_a;

  /* That was easy :-).  But now we need to find all classes that use
     these methods, and update the IMP in the dispatch tables.  */
  __objc_update_classes_with_methods (method_a, method_b);

  objc_mutex_unlock (__objc_runtime_mutex);
}