gbx_class_load.c

Gambas is a graphical development environment based on a Basic interpreter, like Visual Basic. It us

  if (class->debug)
  {
    class->load->global = (GLOBAL_SYMBOL *)
      get_section("global symbol section", &section, sizeof(GLOBAL_SYMBOL),
                  &class->load->n_global, "s2ltl");

    debug = (FUNC_DEBUG *)get_section("debug method section", &section, sizeof(FUNC_DEBUG), NULL, "s2l3s2");

    for (i = 0; i < class->load->n_func; i++)
    {
      func = &class->load->func[i];
      func->debug = &debug[i];
    }

    for (i = 0; i < class->load->n_func; i++)
    {
      func = &class->load->func[i];
      func->debug->pos = (ushort *)get_section("line method section", &section, sizeof(ushort), NULL, "s");
    }

    for (i = 0; i < class->load->n_func; i++)
    {
      func = &class->load->func[i];
      func->debug->local = (LOCAL_SYMBOL *)get_section("local symbol section", &section, sizeof(LOCAL_SYMBOL), &func->debug->n_local, "s2l2");
    }
  }

  /* Nom du fichier source */

  if (class->debug)
    class->path = (char *)get_section("source file name section", &section, sizeof(char), NULL, NULL);

  /* cha�es de caract�es */

  class->string = (char *)get_section("string section", &section, sizeof(char), NULL, NULL);

  /* Enregistrement des classes r��enc�s */

  for (i = 0; i < n_class_ref; i++)
    class->load->class_ref[i] = CLASS_find(&class->string[(long)class->load->class_ref[i]]);

  /* conversion des types */

  for (i = 0; i < class->load->n_func; i++)
  {
    func = &class->load->func[i];
    conv_type(class, &func->type);

    if (func->n_param > 0)
    {
      func->param = (CLASS_PARAM *)local;

      for (j = 0; j < func->n_param; j++)
        conv_type(class, &func->param[j].type);

      local += func->n_param;
    }

    if (func->n_local > 0)
    {
      func->local = (CLASS_LOCAL *)local;

			// As the 'local' section is a mix of CLASS_PARAM and CLASS_LOCAL,
			// we swap endianness there and not during get_section()

			if (_swap)
			{
	      for (j = 0; j < func->n_local; j++)
	      {
	      	SWAP_long((long *)&func->local[j].type);
	      	SWAP_type(&func->local[j].type);
				}
      }

      local += func->n_local;
    }
  }

  /* Initialisation des informations sur les ��ements */

  for (i = 0; i < class->n_event; i++)
  {
    event = &class->load->event[i];

    conv_type(class, &event->type);

    if (event->n_param > 0)
    {
      event->param = (CLASS_PARAM *)local;

      for (j = 0; j < event->n_param; j++)
        conv_type(class, &event->param[j].type);

      local += event->n_param;
    }
  }

  /* On v�ifie qu'on a bien atteint la fin du fichier */

  if (section != &class->data[len_data])
  {
    /*printf("%d\n", &class->load[BUFFER_length(class->load)] - section);*/
    THROW(E_CLASS, ClassName, "Unknown section", "");
  }


  /* relocation des d�initions de tableaux */

  if (n_array > 0)
  {
    n_array = *((long *)class->load->array) / sizeof(long);

    for (i = 0; i < n_array; i++)
    {
      class->load->array[i] = (CLASS_ARRAY *)((char *)class->load->array + ((long *)class->load->array)[i]);
      conv_type(class, &(class->load->array[i]->type));
    }
  }

  /* relocation des cha�es de caract�es */

  for (i = 0; i < n_desc; i++)
    RELOCATE(start[i].gambas.name);

  for (i = 0; i < n_unknown; i++)
    RELOCATE(class->load->unknown[i]);

  for (i = 0; i < class->n_event; i++)
    RELOCATE(class->load->event[i].name);

  if (class->debug)
  {
    for (i = 0; i < class->load->n_global; i++)
    {
      RELOCATE(class->load->global[i].sym.name);
      /*conv_type(class, &(class->load->global[i].type));*/
    }

    for (i = 0; i < class->load->n_func; i++)
    {
      func = &class->load->func[i];
      RELOCATE(func->debug->name);

      for (j = 0; j < func->debug->n_local; j++)
        RELOCATE(func->debug->local[j].sym.name);
    }
  }

  /* h�itage */

  if (info->parent >= 0)
  {
    //printf("%s inherits %s\n", class->name, (class->load->class_ref[info->parent])->name);
    CLASS_inheritance(class, class->load->class_ref[info->parent]);
  }

  /* Callbacks d'instanciation (si la classe n'est pas statique) */

  if ((info->s_dynamic == 0) && (class->parent == NULL || class->parent->new == NULL))
  {
    class->new = NULL;
    class->free = (void (*)())CLASS_do_nothing;
    /*class->ref = (void (*)())CLASS_do_nothing;
    class->unref = (void (*)())CLASS_do_nothing;*/
    SET_IF_NULL(class->check, (int (*)())CLASS_return_zero);
  }
  else
  {
    class->new = (void (*)())OBJECT_new;
    class->free = (void (*)())OBJECT_release;
    /*class->ref = (void (*)())CLASS_ref;
    class->unref = (void (*)())CLASS_unref;*/
    SET_IF_NULL(class->check, (int (*)())CLASS_return_zero);
  }

  /* Descriptions */

  CLASS_make_description(class, start, n_desc, &first);

  /* Tailles et offsets */

  CLASS_calc_info(class, class->n_event, info->s_dynamic, FALSE, info->s_static);

  /* Initialisation des informations sur les variables statiques et dynamiques */

  if (class->parent)
    offset = class->parent->off_event;
  else
    offset = sizeof(OBJECT);

  for (i = 0; i < class->load->n_dyn; i++)
  {
    var = &class->load->dyn[i];
    var->pos += offset;
  }

  /* Conversion et relocation des constantes */

  for (i = 0; i < class->load->n_cst; i++)
  {
    cc = &class->load->cst[i];
    conv_type(class, &(cc->type));
    if (!TYPE_is_integer(cc->type))
      cc->_string.addr += (long)class->string;
    if (cc->type == T_FLOAT)
    {
      if (NUMBER_from_string(NB_READ_FLOAT,cc->_string.addr, strlen(cc->_string.addr), &value))
        THROW(E_CLASS, ClassName, "Bad constant", "");

      cc->_float.value = value._float.value;
    }
  }


  /* Traitement de la description */

  for (i = first; i < class->n_desc; i++)
  {
    desc = class->table[i].desc;

    switch (desc->gambas.val4)
    {
      case CD_PROPERTY_ID: desc->gambas.name = "p"; break;
      case CD_VARIABLE_ID: desc->gambas.name = "v"; break;
      case CD_METHOD_ID: desc->gambas.name = "m"; break;
      case CD_STATIC_PROPERTY_ID: desc->gambas.name = "P"; break;
      case CD_STATIC_VARIABLE_ID: desc->gambas.name = "V"; break;
      case CD_STATIC_METHOD_ID: desc->gambas.name = "M"; break;
      case CD_CONSTANT_ID: desc->gambas.name = "C"; break;
      case CD_EVENT_ID: desc->gambas.name = ":"; break;
    }

    conv_type(class, &desc->gambas.type);

    switch (CLASS_DESC_get_type(desc))
    {
      case CD_METHOD:
      case CD_STATIC_METHOD:

        func = &class->load->func[desc->gambas.val1];
        desc->method.exec = (void (*)())desc->gambas.val1;
        desc->method.npmin = func->npmin;
        desc->method.npmax = func->n_param;
        desc->method.signature = (TYPE *)func->param;
        //desc->method.help = NULL;
        desc->method.native = FALSE;

        break;

      case CD_PROPERTY:
      case CD_STATIC_PROPERTY:

        desc->property.read = (void (*)())desc->gambas.val1;
        desc->property.write = (void (*)())desc->gambas.val2;
        if ((long)desc->property.write == -1)
          desc->gambas.name = *desc->gambas.name == 'p' ? "r" : "R";
        desc->property.native = FALSE;

        break;

      case CD_VARIABLE:
      case CD_STATIC_VARIABLE:

        if (CLASS_DESC_get_type(desc) == CD_STATIC_VARIABLE)
          var = &class->load->stat[desc->gambas.val1];
        else
          var = &class->load->dyn[desc->gambas.val1];

        desc->variable.offset = var->pos;

        break;

      case CD_CONSTANT:

        cc = &class->load->cst[desc->gambas.val1];

        if (TYPE_is_integer(desc->constant.type))
          desc->constant.value._integer = cc->_integer.value;
        else if (desc->constant.type == T_FLOAT)
          desc->constant.value._float = cc->_float.value;
        else
        {
          desc->constant.type = T_CSTRING;
          desc->constant.value._string = cc->_string.addr;
        }

        break;

      case CD_EVENT:

        event = &class->load->event[desc->gambas.val1];
        desc->event.npmin = event->n_param;
        desc->event.npmax = event->n_param;
        desc->event.signature = (TYPE *)event->param;
        //desc->event.help = NULL;
        break;

      default:

        THROW(E_CLASS, ClassName, "Bad description", "");
    }

    desc->method.class = class;
  }

  /* description des ��ements stock� �part */

  CLASS_make_event(class, &first_event);

  if (first_event > 0)
    memcpy(&class->event[first_event], class->load->event, (class->n_event - first_event) * sizeof(CLASS_EVENT));

  /* Tri */

  CLASS_sort(class);

  /* M�hodes sp�iales de la classe */

  class->special[SPEC_NEW] = CLASS_get_symbol_desc_kind(class, "_new", CD_METHOD, 0);
  class->special[SPEC_FREE] = CLASS_get_symbol_desc_kind(class, "_free", CD_METHOD, 0);
  class->special[SPEC_CALL] = CLASS_get_symbol_desc_kind(class, "_call", CD_METHOD, CD_STATIC_METHOD);

  /* Initialisation des donn�s statiques */

  EXEC.native = FALSE;
  EXEC.class = class;
  EXEC.object = NULL;
  EXEC.nparam = 0;
  EXEC.index = FUNC_INIT_STATIC;
  //EXEC.func = &class->load->func[FUNC_INIT_STATIC];

  EXEC_function();

  /* On peut faire r��ence �la classe */

  class->in_load = FALSE;

  /* La classe est maintenant utilisable ! */

  class->state = CS_LOADED;
}


PUBLIC void CLASS_load_real(CLASS *class)
{
  CLASS_load_without_init(class);
  class->state = CS_READY;

  EXEC_public(class, NULL, "_init", 0);
}