objc-actions.c

早期freebsd实现

{
  tree type = TREE_TYPE (decl);
  static int alreadyWarned = 0;

  if (TREE_CODE (type) == RECORD_TYPE && TREE_STATIC_TEMPLATE (type))
    {
      if (!alreadyWarned)
	{
	  error ("GNU compiler does not support statically allocated objects");
	  alreadyWarned = 1;
	}
      error_with_decl (decl, "`%s' cannot be statically allocated");
    }
}

/* implement static typing. at this point, we know we have an interface... */

tree
get_static_reference (interface)
     tree interface;
{
  return xref_tag (RECORD_TYPE, CLASS_NAME (interface));
}

/* Create and push a decl for a built-in external variable or field NAME.
   CODE says which.
   TYPE is its data type.  */

static tree
create_builtin_decl (code, type, name)
     enum tree_code code;
     tree type;
     char *name;
{
  tree decl = build_decl (code, get_identifier (name), type);
  if (code == VAR_DECL)
    {
      TREE_STATIC (decl) = 1;
      make_decl_rtl (decl, 0, 1);
      pushdecl (decl);
    }
  return decl;
}

/*
 *	purpose: "play" parser, creating/installing representations
 *		 of the declarations that are required by Objective-C.
 *
 *	model:
 *
 *		type_spec--------->sc_spec
 *		(tree_list)        (tree_list)
 *		    |                  |
 *		    |                  |
 *		identifier_node    identifier_node
 */
static void
synth_module_prologue ()
{
  tree expr_decl, temp_type;

  /* defined in `objc.h' */
  objc_object_id = get_identifier (TAG_OBJECT);

  objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id);

  id_type = build_pointer_type (objc_object_reference);

  objc_class_id = get_identifier (TAG_CLASS);
  
  class_type = build_pointer_type (xref_tag (RECORD_TYPE, objc_class_id));

  /* Declare type of selector-objects that represent an operation name.  */

#ifdef OBJC_INT_SELECTORS
  /* `unsigned int' */
  selector_type = unsigned_type_node;
#else
  /* `struct objc_selector *' */
  selector_type
    = build_pointer_type (xref_tag (RECORD_TYPE,
				    get_identifier (TAG_SELECTOR)));
#endif /* not OBJC_INT_SELECTORS */

  /* struct objc_object *objc_msgSend (id, SEL, ...); */

  temp_type
    = build_function_type (id_type,
			   tree_cons (NULL_TREE, id_type,
				      tree_cons (NULLT, selector_type, NULLT)));

  _msg_decl = builtin_function ("objc_msgSend", temp_type, NOT_BUILT_IN, 0);

  /* struct objc_object *objc_msgSendSuper (void *, SEL, ...); */

  temp_type
    = build_function_type (id_type,
			   tree_cons (NULL_TREE, ptr_type_node,
				      tree_cons (NULLT, selector_type, NULLT)));

  _msgSuper_decl = builtin_function ("objc_msgSendSuper",
				     temp_type, NOT_BUILT_IN, 0);

  /* id objc_getClass (); */
  
  temp_type = build_function_type (id_type, NULLT);

  objc_getClass_decl
    = builtin_function ("objc_getClass", temp_type, NOT_BUILT_IN, 0);

  /* id objc_getMetaClass (); */

  objc_getMetaClass_decl
    = builtin_function ("objc_getMetaClass", temp_type, NOT_BUILT_IN, 0);

  /* extern SEL _OBJC_SELECTOR_REFERENCES[]; */

#ifdef OBJC_SELECTORS_WITHOUT_LABELS
  _OBJC_SELECTOR_REFERENCES_decl
    = create_builtin_decl (VAR_DECL, build_array_type (selector_type, NULLT),
			   "_OBJC_SELECTOR_REFERENCES");
#endif
}

/*
 * custom "build_string ()" which sets TREE_TYPE!
 */
static tree
my_build_string (len, str)
     int len;
     char *str;
{
  int wide_flag = 0;
  tree aString = build_string (len, str);
  /*
   *  some code from "combine_strings ()", which is local to c-parse.y.
   */
  if (TREE_TYPE (aString) == int_array_type_node)
    wide_flag = 1;

  TREE_TYPE (aString) =
    build_array_type (wide_flag ? integer_type_node : char_type_node,
		      build_index_type (build_int_2 (len - 1, 0)));

  TREE_CONSTANT (aString) = 1;	/* puts string in the ".text" segment */
  TREE_STATIC (aString) = 1;

  return aString;
}

/* Take care of defining and initializing _OBJC_SYMBOLS.  */

/* Predefine the following data type:

	struct _objc_symtab {
		long sel_ref_cnt;
		SEL *refs;
		short cls_def_cnt;
		short cat_def_cnt;
		void *defs[cls_def_cnt + cat_def_cnt];
	}; */

static void
build_objc_symtab_template ()
{
  tree field_decl, field_decl_chain, index;

  objc_symtab_template = start_struct (RECORD_TYPE, get_identifier (_TAG_SYMTAB));

  /* long sel_ref_cnt; */

  field_decl = create_builtin_decl (FIELD_DECL,
				    long_integer_type_node,
				    "sel_ref_cnt");
  field_decl_chain = field_decl;

  /* SEL *refs; */

  field_decl = create_builtin_decl (FIELD_DECL,
				    build_pointer_type (selector_type),
				    "refs");
  chainon (field_decl_chain, field_decl);

  /* short cls_def_cnt; */

  field_decl = create_builtin_decl (FIELD_DECL,
				    short_integer_type_node,
				    "cls_def_cnt");
  chainon (field_decl_chain, field_decl);

  /* short cat_def_cnt; */

  field_decl = create_builtin_decl (FIELD_DECL,
				    short_integer_type_node,
				    "cat_def_cnt");
  chainon (field_decl_chain, field_decl);

  /* void *defs[cls_def_cnt + cat_def_cnt]; */

  index = build_index_type (build_int_2 (imp_count + cat_count - 1, 0));
  field_decl = create_builtin_decl (FIELD_DECL,
				    build_array_type (ptr_type_node, index),
				    "defs");
  chainon (field_decl_chain, field_decl);

  finish_struct (objc_symtab_template, field_decl_chain);
}

/* Create the initial value for the `defs' field of _objc_symtab.
   This is a CONSTRUCTOR.  */

static tree
init_def_list ()
{
  tree expr, initlist = NULLT;
  struct imp_entry *impent;

  if (imp_count)
    for (impent = imp_list; impent; impent = impent->next)
      {
	if (TREE_CODE (impent->imp_context) == IMPLEMENTATION_TYPE)
	  {
	    expr = build_unary_op (ADDR_EXPR, impent->class_decl, 0);
	    initlist = tree_cons (NULLT, expr, initlist);
	  }
      }

  if (cat_count)
    for (impent = imp_list; impent; impent = impent->next)
      {
	if (TREE_CODE (impent->imp_context) == CATEGORY_TYPE)
	  {
	    expr = build_unary_op (ADDR_EXPR, impent->class_decl, 0);
	    initlist = tree_cons (NULLT, expr, initlist);
	  }
      }
  return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist));
}

/* Construct the initial value for all of _objc_symtab.  */

static tree
init_objc_symtab ()
{
  tree initlist;

  /* sel_ref_cnt = { ..., 5, ... } */

  if (sel_ref_chain)
    initlist = build_tree_list (NULLT, build_int_2 (max_selector_index, 0));
  else
    initlist = build_tree_list (NULLT, build_int_2 (0, 0));

  /* refs = { ..., _OBJC_SELECTOR_REFERENCES, ... } */

#ifndef OBJC_SELECTORS_WITHOUT_LABELS
  initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
#else
  if (sel_ref_chain)
    initlist = tree_cons (NULLT, _OBJC_SELECTOR_REFERENCES_decl, initlist);
  else
    initlist = tree_cons (NULLT, build_int_2 (0, 0), initlist);
#endif

  /* cls_def_cnt = { ..., 5, ... } */

  initlist = tree_cons (NULLT, build_int_2 (imp_count, 0), initlist);

  /* cat_def_cnt = { ..., 5, ... } */

  initlist = tree_cons (NULLT, build_int_2 (cat_count, 0), initlist);

  /* cls_def = { ..., { &Foo, &Bar, ...}, ... } */

  if (imp_count || cat_count)
    initlist = tree_cons (NULLT, init_def_list (), initlist);

  return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist));
}

/* Push forward-declarations of all the categories
   so that init_def_list can use them in a CONSTRUCTOR.  */

static void
forward_declare_categories ()
{
  struct imp_entry *impent;
  tree sav = implementation_context;
  for (impent = imp_list; impent; impent = impent->next)
    {
      if (TREE_CODE (impent->imp_context) == CATEGORY_TYPE)
	{
	  /* Set an invisible arg to synth_id_with_class_suffix.  */
	  implementation_context = impent->imp_context;
	  impent->class_decl
	    = create_builtin_decl (VAR_DECL, objc_category_template,
				   IDENTIFIER_POINTER (synth_id_with_class_suffix ("_OBJC_CATEGORY")));
	}
    }
  implementation_context = sav;
}

/* Create the declaration of _OBJC_SYMBOLS, with type `strict _objc_symtab'
   and initialized appropriately.  */

static void
generate_objc_symtab_decl ()
{
  tree sc_spec;

  if (!objc_category_template)
    build_category_template ();

  /* forward declare categories */
  if (cat_count)
    forward_declare_categories ();

  if (!objc_symtab_template)
    build_objc_symtab_template ();

  sc_spec = build_tree_list (NULLT, ridpointers[(int) RID_STATIC]);

  _OBJC_SYMBOLS_decl = start_decl (get_identifier ("_OBJC_SYMBOLS"),
				   tree_cons (NULLT, objc_symtab_template, sc_spec), 1);

  finish_decl (_OBJC_SYMBOLS_decl, init_objc_symtab (), NULLT);
}

/*
 *	tree_node------->tree_node----->...
 *          |                |
 *          | (value)        | (value)
 *          |                |
 *	  expr             expr
 */
static tree
init_module_descriptor ()
{
  tree initlist, expr;

  /* version = { 1, ... } */

  expr = build_int_2 (OBJC_VERSION, 0);
  initlist = build_tree_list (NULLT, expr);

  /* size = { ..., sizeof (struct objc_module), ... } */

  expr = build_int_2 (TREE_INT_CST_LOW (TYPE_SIZE (objc_module_template)) /
		      BITS_PER_UNIT, 0);
  initlist = tree_cons (NULLT, expr, initlist);

  /* name = { ..., "foo.m", ... } */

  expr = build_msg_pool_reference (
				   add_objc_string (get_identifier (input_filename)));
  initlist = tree_cons (NULLT, expr, initlist);

  /* symtab = { ..., _OBJC_SYMBOLS, ... } */

  if (_OBJC_SYMBOLS_decl)
    expr = build_unary_op (ADDR_EXPR, _OBJC_SYMBOLS_decl, 0);
  else
    expr = build_int_2 (0, 0);
  initlist = tree_cons (NULLT, expr, initlist);

  return build_nt (CONSTRUCTOR, NULLT, nreverse (initlist));
}

/* Write out the data structures to describe Objective C classes defined.
   If appropriate, compile and output a setup function to initialize them.
   Return a string which is the name of a function to call to initialize
   the Objective C data structures for this file (and perhaps for other files
   also).  */

static char *
build_module_descriptor ()
{
  tree decl_specs, field_decl, field_decl_chain;

  objc_module_template = start_struct (RECORD_TYPE, get_identifier (_TAG_MODULE));

  /* long version; */

  decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_LONG]);
  field_decl = get_identifier ("version");
  field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
  field_decl_chain = field_decl;

  /* long  size; */

  decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_LONG]);
  field_decl = get_identifier ("size");
  field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
  chainon (field_decl_chain, field_decl);

  /* char  *name; */

  decl_specs = build_tree_list (NULLT, ridpointers[(int) RID_CHAR]);
  field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("name"));
  field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
  chainon (field_decl_chain, field_decl);

  /* struct objc_symtab *symtab; */

  decl_specs = get_identifier (_TAG_SYMTAB);
  decl_specs = build_tree_list (NULLT, xref_tag (RECORD_TYPE, decl_specs));
  field_decl = build1 (INDIRECT_REF, NULLT, get_identifier ("symtab"));
  field_decl = grokfield (input_filename, lineno, field_decl, decl_specs, NULLT);
  chainon (field_decl_chain, field_decl);

  finish_struct (objc_module_template, field_decl_chain);

  /* create an instance of "objc_module" */

  decl_specs = tree_cons (NULLT, objc_module_template,
			  build_tree_list (NULLT, ridpointers[(int) RID_STATIC]));

  _OBJC_MODULES_decl = start_decl (get_identifier ("_OBJC_MODULES"),
				   decl_specs, 1);

  finish_decl (_OBJC_MODULES_decl, init_module_descriptor (), NULLT);

  /* Mark the decl to avoid "defined but not used" warning. */
  DECL_IN_SYSTEM_HEADER (_OBJC_MODULES_decl) = 1;

  /* Generate a constructor call for the module descriptor. 
     This code was generated by reading the grammar rules
     of c-parse.y;  Therefore, it may not be the most efficient
     way of generating the requisite code. */
#ifndef NEXT_OBJC_RUNTIME
  {
    tree parms, function_decl, decelerator, void_list_node;
    tree function_type;
    char *buf;
    char *global_object_name = 0;
    tree t;

    /* Use a global object (which is already required to be unique over
       the program) rather than the file name (which imposes extra
       constraints).  -- [e-mail], 10 Jan 1990.  */

    /* Find the name of some global object defined in this file.  */
    for (t = getdecls (); t; t = TREE_CHAIN (t))
      if (TREE_PUBLIC (t) && !DECL_EXTERNAL (t) && DECL_INITIAL (t) != 0)
	{
	  global_object_name = IDENTIFIER_POINTER (DECL_NAME (t));
	  break;
	}

    /* If none, use the name of the file.  */
    if (!global_object_name)
      {
	char *p, *q;
	global_object_name
	  = (char *) alloca (strlen (main_input_filename) + 1);

	p = main_input_filename;
	q = global_object_name;

	/* Replace any weird characters in the file name.  */
	for (; *p; p++)
	  if (! ((*p >= '0' && *p <= '9')
		 || (*p >= 'A' && *p <= 'Z')
		 || (*p >= 'a' && *p <= 'z')))
	    *q++ = '_';
	  else
	    *q++ = *p;