data.h

功能较全面的反汇编器：反汇编器ht-2.0.15.tar.gz

/*
 *	HT Editor
 *	data.h
 *
 *	Copyright (C) 2002, 2003 Stefan Weyergraf ([e-mail])
 *	Copyright (C) 2002, 2003 Sebastian Biallas ([e-mail])
 *
 *	This program is free software; you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License version 2 as
 *	published by the Free Software Foundation.
 *
 *	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 __DATA_H__
#define __DATA_H__

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "io/types.h"
#include <cstdlib>

typedef uint32 ObjectID;
typedef uint32 ID;

class ObjectStream;

struct BuildCtorArg {
};


template <typename T1, typename T2>
inline bool instanceOf(const T2 *o)
{
	return (dynamic_cast<const T1*>(o) != NULL);
} 

/*
 *	C style malloc support
 */

class HTMallocRes;
HTMallocRes ht_malloc(size_t);

class HTMallocRes
{
private:
	friend HTMallocRes ht_malloc(size_t);
	const size_t mSize;

	HTMallocRes(size_t size)
		: mSize(size)
	{
	}

	HTMallocRes operator=(const HTMallocRes &); // not implemented

public:
	template <typename T> operator T* () const
	{
		return static_cast<T*>(::malloc(mSize));
	}
};

inline HTMallocRes ht_malloc(size_t size)
{
	return HTMallocRes(size);
}


/**
 *	Macro for creating object build functions
 */
#define BUILDER(reg, obj, parent) Object *build_##obj(){BuildCtorArg a;return new obj(a);}
#define BUILDER2(reg, obj) Object *build_##obj(){BuildCtorArg a;return new obj(a);}

/**
 *	Registers builder function by object id.
 */
#define REGISTER(reg, obj) registerAtom(reg, (void*)build_##obj);

/**
 *	Unregisters builder function by object id.
 */
#define UNREGISTER(reg, obj) unregisterAtom(reg);

/* actually a str => bigendian-int */
/** used to define ObjectIDs */
#define MAGIC32(magic) (unsigned long)(((unsigned char)magic[0]<<24) | ((unsigned char)magic[1]<<16) | ((unsigned char)magic[2]<<8) | (unsigned char)magic[3])

/** No/invalid object */
#define OBJID_INVALID			((ObjectID)0)
/** A placeholder object id */
#define OBJID_TEMP			((ObjectID)-1)

#define OBJID_OBJECT			MAGIC32("DAT\x00")

#define OBJID_ARRAY			MAGIC32("DAT\x10")
#define OBJID_STACK			MAGIC32("DAT\x11")

#define OBJID_BINARY_TREE		MAGIC32("DAT\x20")
#define OBJID_AVL_TREE			MAGIC32("DAT\x21")
#define OBJID_SET			MAGIC32("DAT\x22")

#define OBJID_SLINKED_LIST		MAGIC32("DAT\x30")
#define OBJID_QUEUE			MAGIC32("DAT\x31")
#define OBJID_DLINKED_LIST		MAGIC32("DAT\x32")

#define OBJID_KEYVALUE			MAGIC32("DAT\x40")
#define OBJID_SINT			MAGIC32("DAT\x41")
#define OBJID_SINT64			MAGIC32("DAT\x42")
#define OBJID_UINT			MAGIC32("DAT\x43")
#define OBJID_UINT64			MAGIC32("DAT\x44")
#define OBJID_FLOAT			MAGIC32("DAT\x45")

#define OBJID_MEMAREA			MAGIC32("DAT\x48")

#define OBJID_STRING			MAGIC32("DAT\x50")
#define OBJID_ISTRING			MAGIC32("DAT\x51")

#define OBJID_AUTO_COMPARE		MAGIC32("DAT\xc0")

/**
 *	This is THE base class.
 */
class Object {
public:
				Object(BuildCtorArg&) {};
				Object() {};

	virtual			~Object() {};
		void		init() {};
	virtual	void		done() {};
/* new */

/**
 *	Standard object duplicator.
 *	@returns copy of object
 */
	virtual	Object *	clone() const;
/**
 *	Standard Object comparator.
 *	@param obj object to compare to
 *	@returns 0 for equality, negative number if |this<obj| and positive number if |this>obj|
 */
	virtual	int		compareTo(const Object *obj) const;
/**
 *	Stringify object.
 *	Stringify object in string-buffer <i>s</i>. Never writes more than
 *	<i>maxlen</i> characters to <i>s</i>. If <i>maxlen</i> is > 0, a
 *	trailing zero-character is written.
 *
 *	@param buf pointer to buffer that receives object stringification
 *	@param buflen size of buffer that receives object stringification
 *	@returns number of characters written to <i>s</i>, not including the trailing zero
 */
	virtual	int		toString(char *buf, int buflen) const;
/**
 *	Standard Object idle function.
 *	Overwrite and register with htidle.cc::register_idle()
 *	(FIXME)
 *
 *	@returns true if working, false if really idle
 */
	virtual	bool		idle();
/**
 *	Load object from object stream.
 *
 *	@param s object stream to load this object from
 */
	virtual	void		load(ObjectStream &s);
/**
 *	@returns unique object id.
 */
	virtual	ObjectID	getObjectID() const;
/**
 *	stores object.
 *
 *	@param s object stream to store this object into
 */
	virtual	void		store(ObjectStream &s) const;
};

typedef int (*Comparator)(const Object *a, const Object *b);

int autoCompare(const Object *a, const Object *b);

typedef void* ObjHandle;
const ObjHandle invObjHandle = NULL;
const uint invIdx = ((uint)-1);

/**
 *	An Enumerator.
 */
class Enumerator: public Object {
public:
				Enumerator(BuildCtorArg&a): Object(a) {};
				Enumerator() {};
	/* extends Object */
	virtual Enumerator *	clone() const = 0;
	virtual	int		toString(char *buf, int buflen) const;
	/* new */

/**
 *	Count elements.
 *
 *	@returns number of objects contained in this structure
 *	@throws NotImplementedException if counting of elements is not supported
 */
	virtual	uint		count() const = 0;

/**
 *	Compare objects.
 *	Compare objects <i>a</i> and <i>b</i> and determine their (logical)
 *	linear order.
 *
 *	@param a object a
 *	@param b object b
 *	@returns 0 if <i>a</i> equals <i>b</i>,
 *	a value >0 if <i>a</i> is greater than <i>b</i> and
 *	a value <0 if <i>a</i> is less than <i>b</i>
 */
	virtual	int		compareObjects(const Object *a, const Object *b) const = 0;
/**
 *	Test if contained.
 *	Test if an object like <i>obj</i> is contained in this structure
 *
 *	@param obj signature of object to find
 *	@returns true if an object like <i>obj</i> is contained, false otherwise
 */
	inline	bool		contains(const Object *obj) const
	{
		return find(obj) != invObjHandle;
	}
/**
 *	Test if empty.
 *	@returns true if empty
 */
	inline bool		isEmpty() const
	{
		return count() == 0;
	}
/**
 *	Find equal object.
 *	Find first object equaling <i>obj</i> in this structure
 *	and if found return it's object handle.
 *
 *	@param obj signature of object to find
 *	@returns object handle of found object or <i>invObjHandle</i> if not found
 */
	virtual	ObjHandle	find(const Object *obj) const;
/**
 *	Find greater-or-equal object.
 *	Find lowest object being greater or equal compared to <i>obj</i> in this structure
 *	and if found return it's object handle. (lowest, greater and equal are
 *	defined via the compareTo method)
 *
 *	@param obj signature of object to find
 *	@returns object handle of found object or <i>invObjHandle</i> if not found
 */
	virtual	ObjHandle	findGE(const Object *obj) const;
/**
 *	Find greater object.
 *	Find lowest object being greater compared to <i>obj</i> in this structure
 *	and if found return it's object handle. (lowest and greater are
 *	defined via the compareTo method)
 *
 *	@param obj signature of object to find
 *	@returns object handle of found object or <i>invObjHandle</i> if not found
 */
	virtual	ObjHandle	findG(const Object *obj) const;
/**
 *	Find lower-or-equal object.
 *	Find greatest object being lower or equal compared to <i>obj</i> in this structure
 *	and if found return it's object handle. (greatest, lower and equal are
 *	defined via the compareTo method)
 *
 *	@param obj signature of object to find
 *	@returns object handle of found object or <i>invObjHandle</i> if not found
 */
	virtual	ObjHandle	findLE(const Object *obj) const;
/**
 *	Find lower object.
 *	Find greatest object being lower compared to <i>obj</i> in this structure
 *	and if found return it's object handle. (greatest and lower are
 *	defined via the compareTo method)
 *
 *	@param obj signature of object to find
 *	@returns object handle of found object or <i>invObjHandle</i> if not found
 */
	virtual	ObjHandle	findL(const Object *obj) const;
/**
 *	Find object's handle by index.
 *
 *	@param i index of object to find
 *	@returns object handle of found object or <i>invObjHandle</i> if not found
 */	
	virtual	ObjHandle	findByIdx(int i) const = 0;
/**
 *	Find (logically) last element's object handle.
 *
 *	@returns object handle of the last element or <i>invObjHandle</i>
 *	if the structure is empty
 */
	virtual	ObjHandle	findLast() const = 0;
/**
 *	Find (logically) previous element's object handle.
 *	Find logically previous element (predecessor) of the object identified
 *	by <i>h</i>. Predecessor of "the invalid object" is the last element
 *	in this structure by definition. (ie. <i>findPrev(invObjHandle) :=
 *	findLast()</i>).
 *
 *	@param h object handle to find a predecessor to
 *	@returns object handle of predecessor or <i>invObjHandle</i> if <i>h</i>
 *	identifies the first element.
 */
	virtual	ObjHandle	findPrev(ObjHandle h) const = 0;
/**
 *	Find (logically) first element's object handle.
 *
 *	@returns object handle of the first element or <i>invObjHandle</i>
 *	if this structure is empty
 */
	virtual	ObjHandle	findFirst() const = 0;
/**
 *	Find (logically) next element's object handle.
 *	Find logically next element (successor) of the object, identified
 *	by <i>h</i>. Successor of "the invalid object" is the first element
 *	in this structure by definition. (ie. <i>findNext(invObjHandle) :=
 *	findFirst()</i>).
 *
 *	@param h object handle to find a successor to
 *	@returns object handle of successor or <i>invObjHandle</i> if <i>h</i>
 *	identifies the last element.
 */
	virtual	ObjHandle	findNext(ObjHandle h) const = 0;
/**
 *	Get object pointer from object handle.
 *
 *	@param h object handle
 *	@returns object pointer if <i>h</i> is valid, <i>NULL</i> otherwise
 */
	virtual	Object *	get(ObjHandle h) const = 0;
/**
 *	Get object's index from its handle.
 *
 *	@param h object handle of object
 *	@returns index of object if <i>h</i> is valid, <i>InvIdx</i> otherwise.
 */
	virtual	uint		getObjIdx(ObjHandle h) const = 0;
/**
 *	Get element by index.
 *	Get the element with index <i>idx</i> (if possible).
 *
 *	@param idx index of element to get
 *	@returns pointer to the requested element or <i>NULL</i> if <i>idx</i>
 *	is invalid.
 */
		Object *	operator [] (int idx) const
		{
			return get(findByIdx(idx));
		}
};

#define foreach(XTYPE, X, E, code...)\
for (ObjHandle temp0815 = (E).findFirst(); temp0815 != invObjHandle;) {\
	XTYPE *X = (XTYPE*)(E).get(temp0815);                          \
	temp0815 = (E).findNext(temp0815);                             \
	{code;}                                                        \
}

#define foreachbwd(XTYPE, X, E, code...)\
for (ObjHandle temp0815 = (E).findLast(); temp0815 != invObjHandle;) {\
	XTYPE *X = (XTYPE*)(E).get(temp0815);                         \
	temp0815 = (E).findPrev(temp0815);                            \
	{code;}                                                       \
}

#define firstThat(XTYPE, X, E, condition) \
{                                         \
	XTYPE *Y = NULL;                  \
	foreach(XTYPE, X, E,              \
		if (condition) {          \
			Y = X;            \
			break;            \
		}                         \
	)                                 \
	X = Y;                            \
}