core.c

早期freebsd实现

  assert (initialized);

  /* Objective-C allows messages to be sent to a nil object.  */
  if (receiver) {

    /* Check for common programmer error.  */
    if (!receiver->class_pointer) {
      fprintf (stderr, "method %s sent to deallocated object %#x\n", 
	       sel_getName (sel), receiver);
      abort ();
    }
    
    /* Initialize the class if need be.  */
    if (!(receiver->class_pointer->info & CLS_INITIALIZED))
      initialize_class (receiver->class_pointer->name);

    /*
     * If we're passed a object then its class_pointer is a Class.  If
     * we're passed a Class then its class_pointer is a MetaClass. 
     * Therefore, searching for a instance or class method
     * requires no special decision making here. 
     *
     * Look for the method. 
     */
    imp = get_imp (receiver->class_pointer, sel);

    /* If the method cannot be found then perform error handling.  */
    if (!imp)
      imp = handle_runtime_error (receiver, sel);
  }

  /* Nice debugging messages if enabled.  */
  if (objc_trace) {
    printf ("trace: objc_msgSend , obj=%#x, class=%s, method=%s\n",
	    receiver, 
	    receiver->class_pointer->name, 
	    sel_getName (sel));
    fflush (stdout);
  }
  
  return imp;
}


IMP 
objc_msgSendSuper (Super_t super, SEL sel)
{
  IMP	imp;


  assert (initialized);

  if (!(super->class->info & CLS_INITIALIZED))
    initialize_class (super->class->name);
  if (!(super->receiver->class_pointer->info & CLS_INITIALIZED))
    initialize_class (super->receiver->class_pointer->name);

  imp = get_imp (super->class, sel);
  
  if (!imp)
    imp = handle_runtime_error (super->receiver, sel);

  if (objc_trace) {
    printf ("trace: objc_msgSendSuper , obj=%#x, class=%s, method=%s\n",
	    super->receiver, 
	    super->receiver->class_pointer->name, 
	    sel_getName (sel));
    fflush (stdout);
  }

  return imp;
}


/*
 * This function is called by objc_msgSend or objc_msgSendSuper when a
 * message is sent to a object which it does not recognize. 
 */
static IMP  
handle_runtime_error (id object, SEL sel)
{
  IMP	imp;


  /*
   * If the object recognizes the doesNotRecognize: method then we're
   * going to send it. 
   */
  imp = get_imp (object->class_pointer, sel_getUid ("doesNotRecognize:"));
  if (imp)
    error_static = (*imp)(object, sel_getUid ("doesNotRecognize:"), sel);
  else {
    /*
     * The object doesn't recognize the method.  Check for
     * responding to error:.  If it does then sent it. 
     */
    char msg[256 + strlen (sel_getName (sel)) 
	     + strlen (object->class_pointer->name)];
        
    sprintf (msg, "%s does not recognize %s", 
	     object->class_pointer->name, sel_getName (sel));
        
    imp = get_imp (object->class_pointer, sel_getUid ("error:"));
    if (imp)
      error_static = (*imp)(object, sel_getUid ("error:"), msg);
    else {
      /*
       * The object doesn't respond to doesNotRecognize: or
       * error:;  Therefore, a default action is taken. 
       */
      fprintf (stderr, "%s\n", msg);
      abort ();
    }
  }

  /*
   * Either doesNotRecognize: or error: has been overridden.  We have
   * to return that value as the default action. 
   */
  return return_error_static;
}


/*
 * This function is used by the run-time to provide a method where nil
 * objects can receive messages. 
 *
 * This method simply returns self. 
 */
static id  
nil_method (id object, SEL sel, ...)
{
  return object;
}


/*
 * This function is used by the run-time to provide a method where nil
 * objects can receive messages. 
 *
 * This method simply returns self. 
 *
 * Note: multiple thread problem area. 
 */
static id  
return_error_static (id object, SEL sel, ...)
{
  return error_static;
}


/*
 * These variables provide a way for the defalut methods of object
 * allocation, destruction, and reallocation to be overridden. 
 */
id    (*_alloc)(Class_t)                  = objc_object_create;
id    (*_dealloc)(id)                     = objc_object_dispose;
id    (*_realloc)(id, unsigned int)              = objc_object_realloc;
id    (*_copy)(id)                        = objc_object_copy;
void  (*_error)(id, const char*, va_list) = objc_error;


id 
objc_object_create (Class_t class)
{
  id     object;


  assert (class);

  /*
   * Allocate memory for the object, initialize the memory to 0, and
   * set the object's class_pointer. 
   *
   * The object's class_pointer is the class's TEXT image.  It is used by
   * the messager as the key to the class hash for methods. 
   *
   * No need to initialize the class.  That was done in objcInit. 
   */
  object = (id) xcalloc (1, class->instance_size);
  object->class_pointer = class;

  return object;
}


id  
objc_object_dispose (id object)
{
  object->class_pointer = NULL;
  free (object);

  return nil;
}


id  
objc_object_realloc (id object, unsigned int length)
{
  id  obj;
  /* Can't resize a object smaller than its instance size.  */
  /* Don't use assert here;
     checks for user errors shouldn't depend on NDEBUG.  */
  if (length < object->class_pointer->instance_size)
    abort ();

  obj = (id) realloc (object, length);
  bzero ((char*)obj + object->class_pointer->instance_size,  
	 length - object->class_pointer->instance_size);
  
  return obj;
}


id  
objc_object_copy (id object)
{
  id  obj;
  obj = class_createInstance (object->class_pointer);
  bcopy (object, obj, objc_classSize (object));
  
  return obj;
}


void  
objc_error (id object, const char *fmt, va_list ap)
{
  vfprintf (stderr, fmt, ap);
  abort ();
}


/* Silly function to skip past a sequence of digits in a string.  */
static inline const char *
skip_digits (const char *str)
{
  while (isdigit (*str))
    ++str;

  return str;
}


unsigned int 
method_getNumberOfArguments (Method_t method)
{
  unsigned int       num = 0;
  const char *args = &method->method_types[1];
  
  
  while (*args) {
  
    /* Skip past size info.  */
    args = skip_digits (args);
    
    /* Argument type next.  */
    assert (*args);
    ++num;
    
    /* Step to next arg.  */
    ++args;
  }
  
  assert (num >= 2);
  return num;
}


unsigned int 
method_getArgumentInfo (Method_t method, int indx, const char **type, 
			int *offset)
{
  const char *args = skip_digits (&method->method_types[1]);
  int         i;

  
  assert (method_getNumberOfArguments (method) >= indx);

  /* Step to arg.  */
  for (i = 0; i < indx; ++i) {
    ++args;
    args = skip_digits (args);
  }
  
  /* Return arg data.  */
  *type = args++;
  *offset = atoi (args);
  
  return indx;
}


/* This function is not thread safe.  */
Ivar_t  
object_getIvarAddress (id object, const char *name)
{
  Class_t class = object->class_pointer; /* Here is the thread safe problem.  */
  Ivar_t  ivar = NULL;
  

  do {
    IvarList_t  ivars = class->ivars;
    int         i;
      
    /* Look at all of the ivar names.  */
    for (i = 0; i < ivars->ivar_count; ++i)
      if (!strcmp (name, ivars->ivar_list[i].ivar_name))
        ivar = &ivars->ivar_list[i];
           
    /*
     * If the ivar wasn't found then lets look to the
     * super class. 
     *
     * If the class is Object then the super class is NULL
     * and we're done. 
     */
    class = class->super_class;
        
  } while (!ivar && class);

  return ivar;
}


/*
 * Search for a method starting from the current class up its hierarchy.  
 *
 * Return a pointer to the method's method structure if found.  NULL otherwise. 
 */
Method_t  
searchForMethodInHierarchy (Class_t class, SEL sel)
{
  Method_t  	method = NULL;
  const char*	name;

  if (sel == 0)
    return NULL;

  name = sel_getName (sel);

  if (name == 0)
    return NULL;

  /*
   * Scan the method list of the class.  If the method isn't found in
   * the list then step to its super class. 
   */
  do {
    
    method = searchForMethodInList (class->methods, name);
    class = class->super_class;

  } while (!method && class);
    
  return method;
}


/*
 * Given a linked list of method and a method's name.  Search for the named
 * method's method structure. 
 *
 * Return a pointer to the method's method structure if found.  NULL otherwise. 
 */
Method_t  
searchForMethodInList (MethodList_t list, const char *name)
{
  MethodList_t  method_list = list;
  

  /* Check for bumbling.  */
  /* ??? Who generates the name?  Is it the user, or part of this file?
     If we crash here, whose fault is it?  */
  assert (name);

  /* If not found then we'll search the list.  */
  while (method_list) {
    int   i;
  
    /* Search the method list.  */
    for (i = 0; i < method_list->method_count; ++i) {
      Method_t method = &method_list->method_list[i];

      if (method->method_name)
	if (!strcmp (method->method_name, name))
	  return method;
    }
        
    /* The method wasn't found.  Follow the link to the next list of 
       methods.  */
    method_list = method_list->method_next;
  }
  
  return NULL;
}


/*
 * This function adds a method list to a class.  
 *
 * This function is typically called by another function specific to the
 * run-time.  As such this function does not worry about thread safe issued.  
 */
void  
addMethodsToClass (Class_t class, MethodList_t list)
{
  int i;
  
  
  /* Passing of a linked list is not allowed.  Do multiple calls.  */
  assert (!list->method_next);

  /* Check for duplicates.  */ 
  for (i = 0; i < list->method_count; ++i) {
    Method_t  method = &list->method_list[i];

    if (method->method_name)	/* Sometimes these are NULL */
      if (searchForMethodInList (class->methods, method->method_name)) {
	/*
	 * Duplication. Print a error message an change the
	 * method name to NULL. 
	 */
	fprintf (stderr, "attempt to add a existing method: %s\n",
		 method->method_name);
	method->method_name = NULL;
      }
  }
  
  /* Add the methods to the class's method list.  */
  list->method_next = class->methods;
  class->methods = list;
}


/*
 * This function removes the instance and factory methods in the passed list
 * from a class.  
 *
 * Methods are removed from a class by replacing the method's name with NULL. 
 *
 *
 * This function is typically called by another function specific to the
 * run-time.  As such this function does not worry about thread safe issued.  
 */
void  
class_removeMethods (Class_t class, MethodList_t method_list)
{
  int i;
  
  
  /* Passing of a linked list is not allowed.  Do multiple calls.  */
  assert (!method_list->method_next);

  /*
   * For each method in the list search the method lists erasing any
   * entries found.