gambas-source-code/main/gbx/gbx_subr_extern.c

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

  gbx_subr_extern.c

  (c) 2000-2009 Benoît Minisini <gambas@users.sourceforge.net>

  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 2, 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.

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

#include <sys/wait.h>

#include "gb_common.h"
#include "gb_alloc.h"
#include "gb_common_check.h"
#include "gb_pcode.h"

#include "gbx_subr.h"


void SUBR_alloc(ushort code)
{
  int size;
  int count;
  void *ptr;
  char *copy;

  SUBR_ENTER();

  if (NPARAM == 2)
    count = SUBR_get_integer(&PARAM[1]);
  else
    count = 1;
  
  if (TYPE_is_null(PARAM->type))
  {
    size = 1;
    copy = NULL;
  }
  if (TYPE_is_string(PARAM->type))
  {
    size = PARAM->_string.len + 1;
    copy = PARAM->_string.addr + PARAM->_string.start;
  }
  else
  {
    size = SUBR_get_integer(PARAM);
    copy = NULL;
  }
  
  if (count <= 0 || size <= 0)
    THROW(E_ARG);
  
  ALLOC(&ptr, size * count, "SUBR_alloc");
  
  if (copy)
  {
    size--;
    memcpy(ptr, copy, size);
    ((char *)ptr)[size] = 0;
  }
  
  RETURN->type = T_POINTER;
  RETURN->_pointer.value = ptr;
  
  SUBR_LEAVE();
}


void SUBR_free(void)
{
  void *ptr;

  SUBR_ENTER_PARAM(1);

  ptr = SUBR_get_pointer(PARAM);
  
  FREE(&ptr, "SUBR_free");
  
  SUBR_LEAVE_VOID();
}


void SUBR_realloc(ushort code)
{
  int size;
  int count;
  void *ptr;

  SUBR_ENTER();

  if (NPARAM == 3)
    size = SUBR_get_integer(&PARAM[2]);
  else
    size = 1;
  
  count = SUBR_get_integer(&PARAM[1]);
  
  if (size <= 0 || count <= 0)
    THROW(E_ARG);
  
  ptr = SUBR_get_pointer(&PARAM[0]);
  
  REALLOC(&ptr, size * count, "SUBR_realloc");
  
  RETURN->type = T_POINTER;
  RETURN->_pointer.value = ptr;
  
  SUBR_LEAVE();
}


void SUBR_strptr(ushort code)
{
  char *ptr;
  size_t len = 0;
	bool err;
  
  SUBR_ENTER();
  
  ptr = (char *)SUBR_get_pointer(PARAM);
	
	if (NPARAM == 1)
	{
		err = CHECK_strlen(ptr, &len);
	}
	else
	{
		len = SUBR_get_integer(&PARAM[1]);
		err = CHECK_address(ptr, len);
	}
    
	if (err)
	{
		RETURN->type = T_NULL;
	}
	else
	{ 
		RETURN->type = T_CSTRING;
		RETURN->_string.addr = ptr;
		RETURN->_string.start = 0;
		RETURN->_string.len = (int)len;
	}
	
  SUBR_LEAVE();
}


void SUBR_varptr(void)
{
	ushort op;
	void *ptr;
	VALUE *val;
  CLASS_VAR *var;
	
	SUBR_ENTER_PARAM(1);
	
	op = (ushort)SUBR_get_integer(PARAM);
	
	if ((op & 0xFF00) == C_PUSH_LOCAL)
	{
		val = &BP[op & 0xFF];
			
		switch(val->type)
		{
			case T_BOOLEAN:
			case T_BYTE:
			case T_SHORT:
			case T_INTEGER:
				ptr = &val->_integer.value;
				break;
				
			case T_LONG:
				ptr = &val->_long.value;
				break;
				
			case T_SINGLE:
				ptr = &val->_single.value;
				break;
				
			case T_FLOAT:
				ptr = &val->_float.value;
				break;
			
			case T_DATE:
				ptr = &val->_date.date;
				break;
			
			case T_STRING:
			case T_CSTRING:
				ptr = val->_string.addr + val->_string.start;
				break;
				
			case T_POINTER:
				ptr = &val->_pointer.value;
				break;
			
			default:
			  THROW(E_TYPE, "Number", TYPE_get_name(val->type));
		}
	}
	else if ((op & 0xF800) == C_PUSH_DYNAMIC)
	{
    var = &CP->load->dyn[op & 0x7FF];

    if (OP == NULL)
      THROW_ILLEGAL();

    ptr = &OP[var->pos];
  }
	else if ((op & 0xF800) == C_PUSH_STATIC)
	{
    var = &CP->load->stat[op & 0x7FF];
    ptr = (char *)CP->stat + var->pos;
	}
	else
		THROW_ILLEGAL();

  RETURN->type = T_POINTER;
  RETURN->_pointer.value = ptr;
	
	SUBR_LEAVE();
}


void SUBR_ptr(ushort code)
{
  void *ptr;
  
  ptr = SUBR_get_pointer(SP - 1);
	SP--;
	
	CHECK_enter();
	VALUE_read(SP, ptr, code & 0xF);
	CHECK_leave();
	
	if (CHECK_got_error())
		THROW(E_ARG);

	SP++;
}


void SUBR_mem(void)
{
  static void *jump[] = {
    &&__ERROR, &&__BOOLEAN, &&__BYTE, &&__SHORT, &&__INTEGER, &&__LONG, &&__SINGLE, &&__FLOAT, 
		&&__DATE, &&__ERROR, &&__ERROR, &&__ERROR, &&__ERROR, &&__ERROR, &&__ERROR, &&__ERROR
    };
		
	TYPE type;
	
	SUBR_ENTER_PARAM(1);
	
	VARIANT_undo(PARAM);
	
	type = PARAM->type;
	if (TYPE_is_object(type))
		goto __ERROR;
	else if (TYPE_is_string(type) || TYPE_is_null(type))
		return;

	STRING_new_temp_value(RETURN, NULL, TYPE_sizeof_memory(type));
	goto *jump[type];
	
__BOOLEAN:

	*(RETURN->_string.addr) = PARAM->_boolean.value != 0;
	goto __END;

__BYTE:

	*(RETURN->_string.addr) = PARAM->_byte.value;
	goto __END;

__SHORT:

	memcpy(RETURN->_string.addr, &PARAM->_short.value, sizeof(short));
	goto __END;

__INTEGER:

	memcpy(RETURN->_string.addr, &PARAM->_integer.value, sizeof(int));
	goto __END;

__LONG:

	memcpy(RETURN->_string.addr, &PARAM->_long.value, sizeof(int64_t));
	goto __END;

__SINGLE:

	memcpy(RETURN->_string.addr, &PARAM->_single.value, sizeof(float));
	goto __END;

__FLOAT:

	memcpy(RETURN->_string.addr, &PARAM->_float.value, sizeof(double));
	goto __END;

__DATE:

	memcpy(RETURN->_string.addr, &PARAM->_date.date, sizeof(int) * 2);
	goto __END;
	
__ERROR:

	THROW_ILLEGAL();

__END:

	SUBR_LEAVE();
}