gambas-source-code/main/gbx/gbx_value.h

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

	value.h

	Datatype management routines. Conversions between each Gambas datatype,
	and conversions between Gambas datatypes and native datatypes.

	(c) 2000-2007 Benoit 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 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.

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


#ifndef __GBX_VALUE_H
#define __GBX_VALUE_H

#include <time.h>

#include "gbx_type.h"
#include "gbx_class.h"

typedef
	struct {
		TYPE type;
		int value;
    #if __WORDSIZE == 64
    int _pad;
    #endif
		intptr_t _reserved[2];
		}
	PACKED
	VALUE_BOOLEAN;

typedef
	struct {
		TYPE type;
		int value;
    #if __WORDSIZE == 64
    int _pad;
    #endif
		intptr_t _reserved[2];
		}
	PACKED
	VALUE_BYTE;

typedef
	struct {
		TYPE type;
		int value;
    #if __WORDSIZE == 64
    int _pad;
    #endif
		intptr_t _reserved[2];
		}
	PACKED
	VALUE_SHORT;

typedef
	struct {
		TYPE type;
		int value;
    #if __WORDSIZE == 64
    int _pad;
    #endif
		intptr_t _reserved[2];
		}
	PACKED
	VALUE_INTEGER;

typedef
	struct {
		TYPE type;
		int64_t value;
    #if __WORDSIZE == 64
    intptr_t _reserved[2];
    #else
    int _reserved;
    #endif
		}
	PACKED
	VALUE_LONG;

typedef
	struct {
		TYPE type;
		intptr_t value;
    intptr_t _reserved[2];
		}
	PACKED
	VALUE_POINTER;

typedef
	struct {
		TYPE type;
		#if __WORDSIZE == 64
		#else
		int _pad;
		#endif
		double value;
    #if __WORDSIZE == 64
    intptr_t _reserved[2];
    #endif
		}
	PACKED
	VALUE_SINGLE;

typedef
	struct {
		TYPE type;
		#if __WORDSIZE == 64
		#else
		int _pad;
		#endif
		double value;
    #if __WORDSIZE == 64
    intptr_t _reserved[2];
    #endif
		}
	PACKED
	VALUE_FLOAT;

typedef
	struct {
		TYPE type;
		int date;  /* number of days */
		int time;  /* number of milliseconds */
    #if __WORDSIZE == 64
    intptr_t _reserved[2];
    #else
    int _reserved;
    #endif
		}
	PACKED
	VALUE_DATE;

typedef
	struct {
		TYPE type;
		char *addr;
		int start;
		int len;
		#if __WORDSIZE == 64
		intptr_t _reserved;
		#endif
		}
	PACKED
	VALUE_STRING;

typedef
	struct {
		TYPE type;
		CLASS *class;
		void *object;
		char kind;
		char defined;
		short index;
		/*long function;*/
		}
	PACKED
	VALUE_FUNCTION;

enum
{
	FUNCTION_NULL = 0,
	FUNCTION_NATIVE = 1,
	FUNCTION_PRIVATE = 2,
	FUNCTION_PUBLIC = 3,
	FUNCTION_EVENT = 4,
	FUNCTION_EXTERN = 5,
	FUNCTION_UNKNOWN = 6,
	FUNCTION_CALL = 7,
};

typedef
	struct {
		TYPE type;
		TYPE ptype;
		intptr_t value[2];
		}
	PACKED
	VALUE_VOID;

typedef
	struct {
		TYPE type;
		TYPE vtype;
		/*
		union {
			char _boolean;
			char _byte;
			short _short;
			double _double;
			int _int;
			long long _int64;
			long long _date;
			char *_string;
			void *_object;
			}
			*/
		char value[8];
		}
	PACKED
	VALUE_VARIANT;

typedef
	struct {
		CLASS *class;
		void *object;
		void *super;
		}
	PACKED
	VALUE_OBJECT;

typedef
	struct {
		TYPE type;
		CLASS *class;
		void *super;
		}
	PACKED
	VALUE_CLASS;

typedef
	struct {
		TYPE type;
		CLASS *class;
		void *addr;
		short index;
		unsigned keep : 1;
		}
	PACKED
	VALUE_ARRAY;

typedef
	union value {
		TYPE type;
		VALUE_BOOLEAN _boolean;
		VALUE_BYTE _byte;
		VALUE_SHORT _short;
		VALUE_INTEGER _integer;
		VALUE_LONG _long;
		VALUE_SINGLE _single;
		VALUE_FLOAT _float;
		VALUE_DATE _date;
		VALUE_STRING _string;
		VALUE_FUNCTION _function;
		VALUE_VARIANT _variant;
		VALUE_CLASS _class;
		VALUE_OBJECT _object;
		VALUE_ARRAY _array;
		VALUE_VOID _void;
		VALUE_POINTER _pointer;
		}
	VALUE;

#define VALUE_copy(_dst, _src) \
	(_dst)->_void.type = (_src)->_void.type; \
	(_dst)->_void.ptype = (_src)->_void.ptype; \
	(_dst)->_void.value[0] = (_src)->_void.value[0]; \
	(_dst)->_void.value[1] = (_src)->_void.value[1];

#define VALUE_is_object(val) (TYPE_is_object((val)->type))
#define VALUE_is_string(val) ((val)->type == T_STRING || (val)->type == T_CSTRING)
#define VALUE_is_number(val) ((val)->type >= T_BYTE && (val)->type <= T_FLOAT)

void VALUE_default(VALUE *value, TYPE type);
void VALUE_convert(VALUE *value, TYPE type);
void VALUE_read(VALUE *value, void *addr, TYPE type);
void VALUE_write(VALUE *value, void *addr, TYPE type);

//void VALUE_put(VALUE *value, void *addr, TYPE type);

void VALUE_free(void *addr, TYPE type);
void VALUE_to_string(VALUE *value, char **addr, int *len);
void VALUE_from_string(VALUE *value, const char *addr, int len);

void VALUE_class_read(CLASS *class, VALUE *value, char *addr, CTYPE ctype);
void VALUE_class_write(CLASS *class, VALUE *value, char *addr, CTYPE ctype);
void VALUE_class_constant(CLASS *class, VALUE *value, int ind);

bool VALUE_is_null(VALUE *val);

void VALUE_get_string(VALUE *val, char **text, int *length);

#define VALUE_conv(_value, _type) \
{ \
	if ((_value)->type != (_type)) \
		VALUE_convert(_value, _type); \
}

#define VALUE_conv_string(_value) \
{ \
	if ((_value)->type != T_STRING && (_value)->type != T_CSTRING) \
		VALUE_convert(_value, T_STRING); \
}


#define VALUE_is_super(_value) (EXEC_super && EXEC_super == (_value)->_object.super)

#endif