Subversion Repositories openrisc

/* GNU Objective C Runtime method related functions.
   Copyright (C) 2010 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);
}