gbx_c_class.c

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

/***************************************************************************

  CClass.c

  The native class Class needed for introspection

  (c) 2000-2004 Beno� Minisini <[e-mail]>

  This program 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 1, or (at your option)
  any later version.

  This program 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.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

***************************************************************************/

#define __GBX_C_CLASS_C

#include <ctype.h>

#include "gb_common.h"
#include "gbx_api.h"
#include "gambas.h"
#include "gbx_library.h"
#include "gbx_project.h"
#include "gbx_class.h"
#include "gbx_class_desc.h"
#include "gbx_exec.h"

#include "gbx_object.h"
#include "gbx_c_class.h"

PRIVATE CLASS_DESC_SYMBOL *_current_symbol = NULL;

PRIVATE CLASS_DESC *get_desc(CLASS *class, const char *name)
{
  long index;

  index = CLASS_find_symbol(class, name);
  if (index == NO_SYMBOL)
  {
    GB_Error((char *)E_NSYMBOL, name, class->name);
    return NULL;
  }
  else
    return class->table[index].desc;
}

/**************************************************************************************************/

BEGIN_METHOD(library_get, GB_STRING name)

  const char *name = GB_ToZeroString(ARG(name));
  LIBRARY *lib;

  lib = LIBRARY_find(name);

  if (lib == NULL)
  {
    GB_Error("Unknown library '&1'", name);
    return;
  }

  if (!LIBRARY_is_loaded(lib))
  {
    GB_Error("Library is not loaded");
    return;
  }

  GB_ReturnObject(lib);

END_METHOD


BEGIN_PROPERTY(library_count)

  GB_ReturnInt(LIBRARY_count);

END_PROPERTY


BEGIN_METHOD_VOID(library_next)

  LIBRARY **plib = (LIBRARY **)GB_GetEnum();

  *plib = LIBRARY_next(*plib);
  if (*plib == NULL)
    GB_StopEnum();
  else
    GB_ReturnObject(*plib);

END_METHOD


BEGIN_PROPERTY(library_name)

  GB_ReturnConstZeroString(OBJECT(LIBRARY)->name);

END_PROPERTY


BEGIN_PROPERTY(library_path)

  GB_ReturnString(PROJECT_lib_path);

END_PROPERTY


BEGIN_METHOD(library_load, GB_STRING name)

  const char *name = GB_ToZeroString(ARG(name));
  LIBRARY *lib;

  lib = LIBRARY_find(name);
  if (!lib)
    lib = LIBRARY_create(name);
  if (!LIBRARY_is_loaded(lib))
    LIBRARY_load(lib);

  GB_ReturnObject(lib);

END_METHOD


BEGIN_METHOD_VOID(library_unload)

  LIBRARY_unload(OBJECT(LIBRARY));

END_METHOD




/**************************************************************************************************/

BEGIN_METHOD(class_get, GB_STRING name)

  const char *name = GB_ToZeroString(ARG(name));
  CLASS *class = NULL;

  if (name != NULL)
    class = CLASS_look(name);

  if (class == NULL)
  {
    GB_Error("Unknown class '&1'", name);
    return;
  }

  if (!class->state)
  {
    GB_Error("Class is not loaded");
    return;
  }

  GB_ReturnObject(class);

END_METHOD


BEGIN_METHOD(class_load, GB_STRING name)

  CLASS *class;

  class = CLASS_get(GB_ToZeroString(ARG(name)));
  GB_ReturnObject(class);

END_METHOD


BEGIN_PROPERTY(class_name)

  GB_ReturnConstZeroString(OBJECT(CLASS)->name);

END_PROPERTY


BEGIN_METHOD_VOID(class_next)

  TABLE *table = CLASS_get_table();
  long *index = (long *)GB_GetEnum();
  CLASS *class;

  for(;;)
  {
    if (*index >= TABLE_count(table))
    {
      GB_StopEnum();
      break;
    }

    class = ((CLASS_SYMBOL *)TABLE_get_symbol(table, *index))->class;
    (*index)++;

    if (class->state)
    {
      GB_ReturnObject(class);
      break;
    }
  }

END_METHOD


BEGIN_PROPERTY(class_count)

  GB_ReturnInt(CLASS_count());

END_PROPERTY


BEGIN_PROPERTY(class_object_count)

  GB_ReturnInt(OBJECT(CLASS)->count);

END_PROPERTY


BEGIN_PROPERTY(class_hidden)

  GB_ReturnBoolean(*(OBJECT(CLASS)->name) == '.');

END_PROPERTY


BEGIN_PROPERTY(class_native)

  GB_ReturnBoolean(CLASS_is_native(OBJECT(CLASS)));

END_PROPERTY

/*
BEGIN_PROPERTY(class_library)

  GB_ReturnObject(OBJECT(CLASS)->belong);

END_PROPERTY
*/

BEGIN_PROPERTY(class_parent)

  GB_ReturnObject(OBJECT(CLASS)->parent);

END_PROPERTY



/**************************************************************************************************/

BEGIN_PROPERTY(class_symbols_count)

  GB_ReturnInt(OBJECT(CLASS)->n_desc);

END_PROPERTY


BEGIN_METHOD_VOID(class_symbols_next)

  CLASS *class = OBJECT(CLASS);
  long *index = (long *)GB_GetEnum();

/*_HIDDEN:*/

  if (*index >= class->n_desc)
  {
    GB_StopEnum();
    return;
  }

  /*cd = class->table[*index].desc;*/

  /*if (cd->symbol.name[0] == '$' || cd->symbol.name[0] == '@')
    goto _HIDDEN;*/

  /*GB_ReturnObject(&class->table[class->table[*index].sort].ref);*/
  GB_ReturnConstZeroString(class->table[class->table[*index].sort].desc->gambas.name);
  (*index)++;

END_METHOD


BEGIN_METHOD(class_symbol_get, GB_STRING name)

  CLASS *class = OBJECT(CLASS);
  CLASS_DESC_SYMBOL *cd = NULL;
  const char *name = GB_ToZeroString(ARG(name));

  if (name != NULL)
    cd = CLASS_get_symbol(class, name);

  if (cd == NULL)
  {
    GB_Error("Unknown symbol '&1'", name);
    return;
  }

  _current_symbol = cd;
  GB_ReturnObject(class);

END_METHOD


BEGIN_PROPERTY(class_instance)

  GB_ReturnObject(OBJECT(CLASS)->instance);

END_PROPERTY



/**************************************************************************************************/

BEGIN_PROPERTY(symbol_name)

  GB_ReturnConstString(_current_symbol->name, _current_symbol->len);

END_PROPERTY


BEGIN_PROPERTY(symbol_kind)

  CLASS_DESC_SYMBOL *cds = _current_symbol;

  switch(CLASS_DESC_get_type(cds->desc))
  {
    case CD_VARIABLE:
    case CD_STATIC_VARIABLE:
      GB_ReturnInt(1);
      return;

    case CD_PROPERTY:
    case CD_PROPERTY_READ:
    case CD_STATIC_PROPERTY:
    case CD_STATIC_PROPERTY_READ:
      GB_ReturnInt(2);
      return;

    case CD_METHOD:
    case CD_STATIC_METHOD:
      GB_ReturnInt(3);
      return;

    case CD_EVENT:
      GB_ReturnInt(4);
      return;

    case CD_CONSTANT:
      GB_ReturnInt(5);
      return;

    default:
      GB_ReturnInt(0);
      return;
  }

END_PROPERTY


BEGIN_PROPERTY(symbol_static)

  CLASS_DESC_SYMBOL *cds = _current_symbol;

  GB_ReturnBoolean(index(CD_STATIC_LIST, CLASS_DESC_get_type(cds->desc)) != NULL);

END_PROPERTY


BEGIN_PROPERTY(symbol_hidden)

  CLASS_DESC_SYMBOL *cds = _current_symbol;

  GB_ReturnBoolean(*cds->name == '_');

END_PROPERTY


BEGIN_PROPERTY(symbol_read_only)

  CLASS_DESC_SYMBOL *cds = _current_symbol;

  switch (CLASS_DESC_get_type(cds->desc))
  {
    case CD_PROPERTY:
    case CD_STATIC_PROPERTY:
      GB_ReturnBoolean(FALSE);
      break;

    default:
      GB_ReturnBoolean(TRUE);
      break;
  }

END_PROPERTY


BEGIN_PROPERTY(symbol_type)