/*
 *	useval.h - Values used in Usecode interpreter.
 *
 *  Copyright (C) 1999  Jeffrey S. Freedman
 *  Copyright (C) 2000-2001  The Exult Team
 *
 *  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 of the License, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifndef USEVAL_H
#define USEVAL_H	1

#include <cassert>
#include <iostream>

#include <vector>	// STL container
#include <deque>	// STL container
#include <string>	// STL string

class Game_object;

/*
 *	A value that we store can be an integer, string, or array.
 */
class Usecode_value
	{
public:
	enum Val_type			// The types:
		{
		int_type = 0,
		string_type = 1,	// Allocated string.
		array_type = 2,
		end_of_array_type = 3,	// Marks end of array.
		pointer_type = 4
		};
private:
	Val_type type;		// Type stored here.
	union
		{
		long intval;
		char *str;
		Usecode_value *array;
		Game_object *ptr;
		} value;

	bool undefined;
					// Count array elements.
	static int count_array(const Usecode_value& val);
public:
	inline Usecode_value() : type(int_type), undefined(true)
		{ value.intval = 0; }
	inline Usecode_value(int ival) : type(int_type), undefined(false)
		{ value.intval = ival; }
	Usecode_value(const char *s);
					// Create array with 1st element.
	Usecode_value(int size, Usecode_value *elem0) 
			: type(array_type), undefined(false)
		{
		value.array = new Usecode_value[size + 1];
		value.array[size].type = end_of_array_type;
		if (elem0)
			value.array[0] = *elem0;
		}
	Usecode_value(Game_object *ptr) : type(pointer_type), undefined(false)
		{ value.ptr = ptr; }
	~Usecode_value();
	Usecode_value& operator=(const Usecode_value& v2);
	Usecode_value& operator=(const char *str);
					// Copy ctor.
	inline Usecode_value(const Usecode_value& v2)
		: type(int_type)
		{ *this = v2; }

	Usecode_value operator+(const Usecode_value& v2);
					// Comparator.
	void	push_back(int);
	bool operator==(const Usecode_value& v2) const;
	bool operator!=(const Usecode_value& v2) const { return !(*this == v2); }

	inline Val_type get_type() const
		{ return type; }
	int get_array_size() const		// Get size of array.
		{ return (type == array_type) ? count_array(*this) : 0; }
	bool is_array() const
		{ return (type == array_type); }
	bool is_int() const
		{ return (type == int_type); }
	bool is_ptr() const
		{ return (type == pointer_type); }
	long get_int_value() const	// Get integer value.
		{ 
#ifdef DEBUG
		if (type == pointer_type || (type == int_type && (value.intval > 0x10000 || value.intval < -0x10000)))
			std::cerr << "Probable attempt at getting int value of pointer!!" << std::endl; 
#endif
		return ((type == int_type) ? value.intval : 0);
		}
	Game_object* get_ptr_value() const	// Get pointer value.
		{ return ((type == pointer_type) ? value.ptr : 0); }
					// Get string value.
	const char *get_str_value() const
		{ return ((type == string_type) ? value.str : 0); }
	long need_int_value() const
		{
					// Convert strings.
		const char *str = get_str_value();
		return str ? std::atoi(str) 
			: ((type == array_type && get_array_size())
			? value.array[0].need_int_value() 
					// Pointer = ref.
			: (type == pointer_type ? (value.intval&0x7ffffff)
					: get_int_value()));
		}
					// Add array element. (No checking!)
	void put_elem(int i, Usecode_value& val)
		{ value.array[i] = val; }
					// Get an array element.
	inline Usecode_value& get_elem(int i) const
		{
		static Usecode_value zval(0);
//		assert(type == array_type);//+++++Testing.
		return (type == array_type) ? value.array[i] : zval;
		}
	inline Usecode_value& operator[](int i)
		{
		assert(type == array_type);
		return value.array[i];
		}
					// Get array elem. 0, or this.
	inline Usecode_value& get_elem0()
		{ return (type == array_type) ? value.array[0] : *this; }
	inline bool is_false() const	// Represents a FALSE value?
		{
		switch(type)
			{
			case int_type:
				return value.intval == 0;
			case pointer_type:
				return value.ptr == NULL;
			case array_type:
				return value.array[0].type == end_of_array_type;
			default:
				return false;
			}
		}
	inline bool is_true() const
		{ return !is_false(); }

	inline bool is_undefined() const
		{ return undefined; }

	int resize(int new_size);	// Resize array.
					// Look in array for given value.
	int find_elem(const Usecode_value& val);
					// Concat. to end of this array.
	Usecode_value& concat(Usecode_value& val2);
	void append(int *vals, int cnt);// Append integer values.
					// Add value(s) to an array.
	int add_values(int index, Usecode_value& val2);
	void print(std::ostream& out, bool shortformat=false); // Print in ASCII.
					// Save/restore.
	int save(unsigned char *buf, int len);
	bool restore(unsigned char *& ptr, int len);
	};


std::ostream& operator<<(std::ostream& out, Usecode_value& val);

#endif