%module x86disasm
%{
#ifdef _MSC_VER
	typedef __int64         qword;
#else
	typedef long long       qword;
#endif

#include <sys/types.h>

#define MAX_REGNAME 8
#define MAX_PREFIX_STR 32
#define MAX_MNEM_STR 16
#define MAX_INSN_SIZE 20
#define MAX_OP_STRING 32
#define MAX_OP_RAW_STRING 64
#define MAX_OP_XML_STRING 256
#define MAX_NUM_OPERANDS 8
#define MAX_INSN_STRING 512
#define MAX_INSN_RAW_STRING 1024
#define MAX_INSN_XML_STRING 4096

#include "../../../config.h"


const char * version_string( void ) {
	return PACKAGE_VERSION;
}

%}

const char * version_string( void );

%rename(X86_Register) x86_reg_t;
%rename(X86_EAddr) x86_ea_t;
%rename(X86_Operand) x86_op_t;
//%rename(X86_OpList) x86_oplist_t;
%rename(X86_Insn) x86_insn_t;
%rename(X86_InvOperand) x86_invariant_op_t;
%rename(X86_Invariant) x86_invariant_t;

%include "carrays.i"

%array_class( unsigned char, byteArray );


%apply (unsigned char *STRING, int LENGTH) { 
	(unsigned char *buf, size_t buf_len) 
};


%inline %{


enum x86_asm_format { 
	unknown_syntax = 0,		/* never use! */
	native_syntax, 			/* header: 35 bytes */
	intel_syntax, 			/* header: 23 bytes */
	att_syntax,  			/* header: 23 bytes */
	xml_syntax,			/* header: 679 bytes */
	raw_syntax			/* header: 172 bytes */
};
%}

/* ================================================================== */
/* operand class */
%inline %{
	enum x86_reg_type {
	        reg_gen         = 0x00001, reg_in          = 0x00002,
	        reg_out         = 0x00004, reg_local       = 0x00008,
	        reg_fpu         = 0x00010, reg_seg         = 0x00020,
	        reg_simd        = 0x00040, reg_sys         = 0x00080,
	        reg_sp          = 0x00100, reg_fp          = 0x00200,
	        reg_pc          = 0x00400, reg_retaddr     = 0x00800,
	        reg_cond        = 0x01000, reg_zero        = 0x02000,
	        reg_ret         = 0x04000, reg_src         = 0x10000,
	        reg_dest        = 0x20000, reg_count       = 0x40000
	};

	typedef struct {
       	 	char name[MAX_REGNAME];
	        enum x86_reg_type type;
	        unsigned int size;
	        unsigned int id;
		unsigned int alias;
		unsigned int shift;
	} x86_reg_t;

	void x86_reg_from_id( unsigned int id, x86_reg_t * reg );

	typedef struct {
	        unsigned int     scale;
	        x86_reg_t        index, base;
	        long             disp;
	        char             disp_sign;
	        char             disp_size;
	} x86_ea_t;

	enum x86_op_type {
	        op_unused = 0,
	        op_register = 1,
	        op_immediate = 2,
	        op_relative_near = 3,
	        op_relative_far = 4,
	        op_absolute = 5, 
	        op_expression = 6,
	        op_offset = 7,
	        op_unknown
	};

	enum x86_op_datatype {
	       	op_byte = 1, op_word = 2,
	        op_dword = 3, op_qword = 4,
	        op_dqword = 5, op_sreal = 6,
	        op_dreal = 7, op_extreal = 8,
	        op_bcd = 9,  op_ssimd = 10,
	        op_dsimd = 11, op_sssimd = 12,
	        op_sdsimd = 13, op_descr32 = 14,
		op_descr16 = 15, op_pdescr32 = 16,
		op_pdescr16 = 17, op_fpuenv = 18,
		op_fpregset = 19,
	};

	enum x86_op_access {
	        op_read = 1,
	        op_write = 2,
	        op_execute = 4
	};

	enum x86_op_flags {
	        op_signed = 1, op_string = 2, 
	        op_constant = 4, op_pointer = 8,  
		op_sysref = 0x010, op_implied = 0x020,
		op_hardcode = 0x40, op_es_seg = 0x100,
	        op_cs_seg = 0x200, op_ss_seg = 0x300,
	        op_ds_seg = 0x400, op_fs_seg = 0x500,
	        op_gs_seg = 0x600
	};

	typedef struct {
	        enum x86_op_type        type;
	        enum x86_op_datatype    datatype;
	        enum x86_op_access      access;
	        enum x86_op_flags       flags;
	        union {
	                char            sbyte;
	                short           sword;
	                long            sdword;
	                qword           sqword;
	                unsigned char   byte;
	       	         unsigned short  word;
	                unsigned long   dword;
	                qword           qword;
	                float           sreal;
	                double          dreal;
	                unsigned char   extreal[10];
	                unsigned char   bcd[10];
	                qword           dqword[2];
	                unsigned char   simd[16];
	                unsigned char   fpuenv[28];
	                void            * address;
	                unsigned long   offset;
	                x86_reg_t       reg;
	                char            relative_near;
	       	         long            relative_far;
       	         	x86_ea_t        expression;
        	} data;
		void * insn;
	} x86_op_t;

	unsigned int x86_operand_size( x86_op_t *op );

	int x86_format_operand(x86_op_t *op, char *buf, int len,
        	          enum x86_asm_format format);
%}

%extend x86_reg_t{
	x86_reg_t * aliased_reg( ) {
		x86_reg_t * reg = (x86_reg_t * )
				  calloc( sizeof(x86_reg_t), 1 );
		x86_reg_from_id( self->id, reg );
		return reg;
	}
}

%extend x86_op_t{
	size_t size() {
		return x86_operand_size( self );
	}
	char * format( enum x86_asm_format format ) {
		char *buf, *str;
		size_t len;

		switch ( format ) {
			case xml_syntax:
				len = MAX_OP_XML_STRING;
				break;
			case raw_syntax:
				len = MAX_OP_RAW_STRING;
				break;
			case native_syntax:
			case intel_syntax:
			case att_syntax:
			case unknown_syntax:
			default:
				len = MAX_OP_STRING;
				break;
		}

		buf = (char * ) calloc( len + 1, 1 );
		x86_format_operand( self, buf, len, format );

		/* drop buffer down to a reasonable size */
		str = strdup( buf );
		free(buf);
		return str;
	}
	
	int is_address( ) {
		if ( self->type == op_absolute ||
		     self->type == op_offset ) {
		     return 1;
		}

		return 0;
	}

	int is_relative( ) {
		if ( self->type == op_relative_near ||
		     self->type == op_relative_far ) {
		     return 1;
		}

		return 0;
	}

	%newobject copy;
	x86_op_t * copy() {
		x86_op_t *op = (x86_op_t *) calloc( sizeof(x86_op_t), 1 );

		if ( op ) {
			memcpy( op, self, sizeof(x86_op_t) );
		}

		return op;
	}
}

/* ================================================================== */
/* operand list class */
%inline %{
	typedef struct X86_OpListNode {
		x86_op_t *op;
		struct X86_OpListNode *next, *prev;
	} X86_OpListNode;

	typedef struct X86_OpList {
		size_t count;
		X86_OpListNode *head, *tail, *curr;
	} X86_OpList;
%}

%extend X86_OpList {
	X86_OpList () {
		X86_OpList *list = (X86_OpList *) 
				calloc( sizeof(X86_OpList), 1 );
		list->count = 0;
		return list;
	}

	~X86_OpList() {
		X86_OpListNode *node, *next;

		node = self->head;
		while ( node ) {
			next = node->next;
			/* free( node->insn ); */
			free( node );
			node = next;
		}

		free( self );
	}

	X86_OpListNode * first() { 
		self->curr = self->head;
		return self->head; 
	}

	X86_OpListNode * last() { 
		self->curr = self->tail;
		return self->tail; 
	}

	X86_OpListNode * next() { 
		if (! self->curr ) {
			self->curr = self->head;
			return self->head;
		}

		self->curr = self->curr->next;
		return self->curr;
	}

	X86_OpListNode * prev() { 
		if (! self->curr ) {
			self->curr = self->tail;
			return self->tail;
		}

		self->curr = self->curr->prev;
		return self->curr;
	}

	%newobject append;
	void append( x86_op_t *op ) {
		X86_OpListNode *node = (X86_OpListNode *)
					calloc( sizeof(X86_OpListNode) , 1 );
		if (! node ) {
			return;
		}

		self->count++;
		if ( ! self->tail ) {
			self->head = self->tail = node;
		} else {
			self->tail->next = node;
			node->prev = self->tail;
			self->tail = node;
		}

		node->op = x86_op_t_copy( op );
	}
}

%inline %{
	typedef struct x86_operand_list {
		x86_op_t op;
		struct x86_operand_list *next;
	} x86_oplist_t;
%}

%extend x86_oplist_t {
	%newobject x86_oplist_node_copy;
}

/* ================================================================== */
/* instruction class */
%inline %{
	x86_oplist_t * x86_oplist_node_copy( x86_oplist_t * list ) {
		x86_oplist_t *ptr;
		ptr = (x86_oplist_t *) calloc( sizeof(x86_oplist_t), 1 );
		if ( ptr ) {
			memcpy( &ptr->op, &list->op, sizeof(x86_op_t) );
		}

		return ptr;
	}

	enum x86_insn_group {
		insn_none = 0, insn_controlflow = 1,
	        insn_arithmetic = 2, insn_logic = 3,
	        insn_stack = 4, insn_comparison = 5,
	        insn_move = 6, insn_string = 7,
	        insn_bit_manip = 8, insn_flag_manip = 9,
	        insn_fpu = 10, insn_interrupt = 13,
	        insn_system = 14, insn_other = 15
	};

	enum x86_insn_type {
		insn_invalid = 0, insn_jmp = 0x1001,
	        insn_jcc = 0x1002, insn_call = 0x1003,
	        insn_callcc = 0x1004, insn_return = 0x1005,
	        insn_add = 0x2001, insn_sub = 0x2002,
	        insn_mul = 0x2003, insn_div = 0x2004,
	        insn_inc = 0x2005, insn_dec = 0x2006,
	        insn_shl = 0x2007, insn_shr = 0x2008,
	        insn_rol = 0x2009, insn_ror = 0x200A,
	        insn_and = 0x3001, insn_or = 0x3002,
	        insn_xor = 0x3003, insn_not = 0x3004,
	        insn_neg = 0x3005, insn_push = 0x4001,
	        insn_pop = 0x4002, insn_pushregs = 0x4003,
	        insn_popregs = 0x4004, insn_pushflags = 0x4005,
	        insn_popflags = 0x4006, insn_enter = 0x4007,
	        insn_leave = 0x4008, insn_test = 0x5001,
	        insn_cmp = 0x5002, insn_mov = 0x6001,
	        insn_movcc = 0x6002, insn_xchg = 0x6003,
	        insn_xchgcc = 0x6004, insn_strcmp = 0x7001,
	        insn_strload = 0x7002, insn_strmov = 0x7003,
	        insn_strstore = 0x7004, insn_translate = 0x7005,
	        insn_bittest = 0x8001, insn_bitset = 0x8002,
	        insn_bitclear = 0x8003, insn_clear_carry = 0x9001,
	        insn_clear_zero = 0x9002, insn_clear_oflow = 0x9003,
	        insn_clear_dir = 0x9004, insn_clear_sign = 0x9005,
	        insn_clear_parity = 0x9006, insn_set_carry = 0x9007,
	        insn_set_zero = 0x9008, insn_set_oflow = 0x9009,
	        insn_set_dir = 0x900A, insn_set_sign = 0x900B,
	        insn_set_parity = 0x900C, insn_tog_carry = 0x9010,
	        insn_tog_zero = 0x9020, insn_tog_oflow = 0x9030,
	        insn_tog_dir = 0x9040, insn_tog_sign = 0x9050,
	        insn_tog_parity = 0x9060, insn_fmov = 0xA001,
	        insn_fmovcc = 0xA002, insn_fneg = 0xA003,
	       	insn_fabs = 0xA004, insn_fadd = 0xA005,
	        insn_fsub = 0xA006, insn_fmul = 0xA007,
	        insn_fdiv = 0xA008, insn_fsqrt = 0xA009,
	        insn_fcmp = 0xA00A, insn_fcos = 0xA00C,
	        insn_fldpi = 0xA00D, insn_fldz = 0xA00E,
	        insn_ftan = 0xA00F, insn_fsine = 0xA010,
	        insn_fsys = 0xA020, insn_int = 0xD001,
	        insn_intcc = 0xD002,   insn_iret = 0xD003,
	        insn_bound = 0xD004, insn_debug = 0xD005,
	        insn_trace = 0xD006, insn_invalid_op = 0xD007,
	        insn_oflow = 0xD008, insn_halt = 0xE001,
	        insn_in = 0xE002, insn_out = 0xE003, 
	        insn_cpuid = 0xE004, insn_nop = 0xF001,
	        insn_bcdconv = 0xF002, insn_szconv = 0xF003 
	};

	enum x86_insn_note {
		insn_note_ring0		= 1,
		insn_note_smm		= 2,
		insn_note_serial	= 4
	};

	enum x86_flag_status {
	        insn_carry_set = 0x1,
	        insn_zero_set = 0x2,
	        insn_oflow_set = 0x4,
	        insn_dir_set = 0x8,
	        insn_sign_set = 0x10,
	        insn_parity_set = 0x20,	
	        insn_carry_or_zero_set = 0x40,
	        insn_zero_set_or_sign_ne_oflow = 0x80,
	        insn_carry_clear = 0x100,
	        insn_zero_clear = 0x200,
	        insn_oflow_clear = 0x400,
	        insn_dir_clear = 0x800,
	        insn_sign_clear = 0x1000,
	        insn_parity_clear = 0x2000,
	        insn_sign_eq_oflow = 0x4000,
	        insn_sign_ne_oflow = 0x8000
	};

	enum x86_insn_cpu {
		cpu_8086 	= 1, cpu_80286	= 2,
		cpu_80386	= 3, cpu_80387	= 4,
		cpu_80486	= 5, cpu_pentium	= 6,
		cpu_pentiumpro	= 7, cpu_pentium2	= 8,
		cpu_pentium3	= 9, cpu_pentium4	= 10,
		cpu_k6		= 16, cpu_k7		= 32,
		cpu_athlon	= 48
	};

	enum x86_insn_isa {
		isa_gp		= 1, isa_fp		= 2,
		isa_fpumgt	= 3, isa_mmx		= 4,
		isa_sse1	= 5, isa_sse2	= 6,
		isa_sse3	= 7, isa_3dnow	= 8,
		isa_sys		= 9	
	};
	
	enum x86_insn_prefix {
	        insn_no_prefix = 0,
	        insn_rep_zero = 1,
	        insn_rep_notzero = 2,
	        insn_lock = 4
	};


	typedef struct {
        	unsigned long addr;
	        unsigned long offset;
	        enum x86_insn_group group;
	        enum x86_insn_type type;
		enum x86_insn_note note;
	        unsigned char bytes[MAX_INSN_SIZE];
	        unsigned char size;
		unsigned char addr_size;
		unsigned char op_size;
		enum x86_insn_cpu cpu;
		enum x86_insn_isa isa;
	        enum x86_flag_status flags_set;
	        enum x86_flag_status flags_tested;
		unsigned char stack_mod;
		long stack_mod_val;
	        enum x86_insn_prefix prefix;
	        char prefix_string[MAX_PREFIX_STR];
	        char mnemonic[MAX_MNEM_STR];
	        x86_oplist_t *operands;
		size_t operand_count;
		size_t explicit_count;
	        void *block;
	        void *function;
	        int tag;
	} x86_insn_t;

	typedef void (*x86_operand_fn)(x86_op_t *op, x86_insn_t *insn, 
		      void *arg);

	enum x86_op_foreach_type {
		op_any 	= 0,
		op_dest = 1,
		op_src 	= 2,
		op_ro 	= 3,
		op_wo 	= 4,
		op_xo 	= 5,
		op_rw 	= 6,
		op_implicit = 0x10,
		op_explicit = 0x20
	};

	size_t x86_operand_count( x86_insn_t *insn, 
				enum x86_op_foreach_type type );
	x86_op_t * x86_operand_1st( x86_insn_t *insn );
	x86_op_t * x86_operand_2nd( x86_insn_t *insn );
	x86_op_t * x86_operand_3rd( x86_insn_t *insn );
	long x86_get_rel_offset( x86_insn_t *insn );
	x86_op_t * x86_get_branch_target( x86_insn_t *insn );
	x86_op_t * x86_get_imm( x86_insn_t *insn );
	unsigned char * x86_get_raw_imm( x86_insn_t *insn );
	void x86_set_insn_addr( x86_insn_t *insn, unsigned long addr );
	int x86_format_mnemonic(x86_insn_t *insn, char *buf, int len,
                        enum x86_asm_format format);
	int x86_format_insn(x86_insn_t *insn, char *buf, int len, 
				enum x86_asm_format);
	void x86_oplist_free( x86_insn_t *insn );
	int x86_insn_is_valid( x86_insn_t *insn );
%}

%extend x86_insn_t {
	x86_insn_t() {
		x86_insn_t *insn = (x86_insn_t *)
				   calloc( sizeof(x86_insn_t), 1 );
		return insn;
	}
	~x86_insn_t() {
		x86_oplist_free( self );
		free( self );
	}

	int is_valid( ) {
		return x86_insn_is_valid( self );
	}

	x86_op_t * operand_1st() {
		return x86_operand_1st( self );
	}

	x86_op_t * operand_2nd() {
		return x86_operand_2nd( self );
	}

	x86_op_t * operand_3rd() {
		return x86_operand_3rd( self );
	}

	x86_op_t * operand_dest() {
		return x86_operand_1st( self );
	}

	x86_op_t * operand_src() {
		return x86_operand_2nd( self );
	}

	size_t num_operands( enum x86_op_foreach_type type ) {
		return x86_operand_count( self, type );
	}

	long rel_offset() {
		return x86_get_rel_offset( self );
	}

	x86_op_t * branch_target() {
		return x86_get_branch_target( self );
	}

	x86_op_t * imm() {
		return x86_get_imm( self );
	}

	unsigned char * raw_imm() {
		return x86_get_raw_imm( self );
	}

	%newobject format;
	char * format( enum x86_asm_format format ) {
		char *buf, *str;
		size_t len;

		switch ( format ) {
			case xml_syntax:
				len = MAX_INSN_XML_STRING;
				break;
			case raw_syntax:
				len = MAX_INSN_RAW_STRING;
				break;
			case native_syntax:
			case intel_syntax:
			case att_syntax:
			case unknown_syntax:
			default:
				len = MAX_INSN_STRING;
				break;
		}

		buf = (char * ) calloc( len + 1, 1 );
		x86_format_insn( self, buf, len, format );

		/* drop buffer down to a reasonable size */
		str = strdup( buf );
		free(buf);
		return str;
	}

	%newobject format_mnemonic;
	char * format_mnemonic( enum x86_asm_format format ) {
		char *buf, *str;
		size_t len = MAX_MNEM_STR + MAX_PREFIX_STR + 4;

		buf = (char * ) calloc( len, 1 );
		x86_format_mnemonic( self, buf, len, format );

		/* drop buffer down to a reasonable size */
		str = strdup( buf );
		free(buf);

		return str;
	}

	%newobject copy;
	x86_insn_t * copy() {
		x86_oplist_t *ptr, *list, *last = NULL;
		x86_insn_t *insn = (x86_insn_t *)
				   calloc( sizeof(x86_insn_t), 1 );

		if ( insn ) {
			memcpy( insn, self, sizeof(x86_insn_t) );
			insn->operands = NULL;
			insn->block = NULL;
			insn->function = NULL;

			/* copy operand list */
			for ( list = self->operands; list; list = list->next ) {
				ptr = x86_oplist_node_copy( list );

				if (! ptr ) {
					continue;
				}

				if ( insn->operands ) {
					last->next = ptr;
				} else {
					insn->operands = ptr;
				}
				last = ptr;
			}
		}

		return insn;
	}

	X86_OpList * operand_list( ) {
		x86_oplist_t *list = self->operands;
		X86_OpList *op_list = new_X86_OpList();

		for ( list = self->operands; list; list = list->next ) {
			X86_OpList_append( op_list, &list->op );
		}

		return op_list;
	}
}

/* ================================================================== */
/* invariant instruction class */
%inline %{
	#define X86_WILDCARD_BYTE 0xF4

	typedef struct {
        	enum x86_op_type        type;
        	enum x86_op_datatype    datatype;
        	enum x86_op_access      access;
        	enum x86_op_flags       flags;
	} x86_invariant_op_t;

	typedef struct {
		unsigned char bytes[64];
		unsigned int  size;
        	enum x86_insn_group group;
        	enum x86_insn_type type;
		x86_invariant_op_t operands[3];
	} x86_invariant_t;
%}

%extend x86_invariant_t {

	x86_invariant_t() {
		x86_invariant_t *inv = (x86_invariant_t *)
				calloc( sizeof(x86_invariant_t), 1 );
		return inv;
	}

	~x86_invariant_t() {
		free( self );
	}
}

/* ================================================================== */
/* instruction list class */
%inline %{
	typedef struct X86_InsnListNode {
		x86_insn_t *insn;
		struct X86_InsnListNode *next, *prev;
	} X86_InsnListNode;

	typedef struct X86_InsnList {
		size_t count;
		X86_InsnListNode *head, *tail, *curr;
	} X86_InsnList;
%}

%extend X86_InsnList {
	X86_InsnList () {
		X86_InsnList *list = (X86_InsnList *) 
				calloc( sizeof(X86_InsnList), 1 );
		list->count = 0;
		return list;
	}

	~X86_InsnList() {
		X86_InsnListNode *node, *next;

		node = self->head;
		while ( node ) {
			next = node->next;
			/* free( node->insn ); */
			free( node );
			node = next;
		}

		free( self );
	}

	X86_InsnListNode * first() { return self->head; }

	X86_InsnListNode * last() { return self->tail; }

	X86_InsnListNode * next() { 
		if (! self->curr ) {
			self->curr = self->head;
			return self->head;
		}

		self->curr = self->curr->next;
		return self->curr;
	}

	X86_InsnListNode * prev() { 
		if (! self->curr ) {
			self->curr = self->tail;
			return self->tail;
		}

		self->curr = self->curr->prev;
		return self->curr;
	}

	%newobject append;
	void append( x86_insn_t *insn ) {
		X86_InsnListNode *node = (X86_InsnListNode *)
					calloc( sizeof(X86_InsnListNode) , 1 );
		if (! node ) {
			return;
		}

		self->count++;
		if ( ! self->tail ) {
			self->head = self->tail = node;
		} else {
			self->tail->next = node;
			node->prev = self->tail;
			self->tail = node;
		}

		node->insn = x86_insn_t_copy( insn );
	}
}

/* ================================================================== */
/* address table class */
/* slight TODO */

/* ================================================================== */
/* Main disassembler class */
%inline %{

	enum x86_options {
		opt_none= 0,
		opt_ignore_nulls=1,
		opt_16_bit=2
		};
	enum x86_report_codes {
        	report_disasm_bounds,
        	report_insn_bounds,
        	report_invalid_insn,
        	report_unknown
	};


	typedef struct {
		enum x86_report_codes last_error;
		void * last_error_data;
		void * disasm_callback;
		void * disasm_resolver;
	} X86_Disasm;

	typedef void (*DISASM_REPORTER)( enum x86_report_codes code, 
				 	 void *data, void *arg );
	typedef void (*DISASM_CALLBACK)( x86_insn_t *insn, void * arg );
	typedef long (*DISASM_RESOLVER)( x86_op_t *op, 
					 x86_insn_t * current_insn,
				 	 void *arg );

	void x86_report_error( enum x86_report_codes code, void *data );
	int x86_init( enum x86_options options, DISASM_REPORTER reporter, 
		      void *arg);
	void x86_set_reporter( DISASM_REPORTER reporter, void *arg);
	void x86_set_options( enum x86_options options );
	enum x86_options x86_get_options( void );
	int x86_cleanup(void);
	int x86_format_header( char *buf, int len, enum x86_asm_format format);
	unsigned int x86_endian(void);
	unsigned int x86_addr_size(void);
	unsigned int x86_op_size(void);
	unsigned int x86_word_size(void);
	unsigned int x86_max_insn_size(void);
	unsigned int x86_sp_reg(void);
	unsigned int x86_fp_reg(void);
	unsigned int x86_ip_reg(void);
	size_t x86_invariant_disasm( unsigned char *buf, int buf_len, 
			  x86_invariant_t *inv );
	size_t x86_size_disasm( unsigned char *buf, unsigned int buf_len );
	int x86_disasm( unsigned char *buf, unsigned int buf_len,
	                unsigned long buf_rva, unsigned int offset,
	                x86_insn_t * insn );
	int x86_disasm_range( unsigned char *buf, unsigned long buf_rva,
	                      unsigned int offset, unsigned int len,
	                      DISASM_CALLBACK func, void *arg );
	int x86_disasm_forward( unsigned char *buf, unsigned int buf_len,
	                        unsigned long buf_rva, unsigned int offset,
	                        DISASM_CALLBACK func, void *arg,
	                        DISASM_RESOLVER resolver, void *r_arg );
	
	void x86_default_reporter( enum x86_report_codes code, 
				   void *data, void *arg ) {
		X86_Disasm *dis = (X86_Disasm *) arg;
		if ( dis ) {
			dis->last_error = code;
			dis->last_error_data = data;
		}
	}

	void x86_default_callback( x86_insn_t *insn, void *arg ) {
		X86_InsnList *list = (X86_InsnList *) arg;
		if ( list ) {
			X86_InsnList_append( list, insn );
		}
	}

	/* TODO: resolver stack, maybe a callback */
	long x86_default_resolver( x86_op_t *op, x86_insn_t *insn, void *arg ) {
		X86_Disasm *dis = (X86_Disasm *) arg;
		if ( dis ) {
			//return dis->resolver( op, insn );
			return 0;
		}

		return 0;
	}

%}

%extend X86_Disasm { 
	
	X86_Disasm( ) {
		X86_Disasm * dis = (X86_Disasm *)
				calloc( sizeof( X86_Disasm ), 1 );
		x86_init( opt_none, x86_default_reporter, dis );
		return dis;
	}

	X86_Disasm( enum x86_options options ) {
		X86_Disasm * dis = (X86_Disasm *)
				calloc( sizeof( X86_Disasm ), 1 );
		x86_init( options, x86_default_reporter, dis );
		return dis;
	}

	X86_Disasm( enum x86_options options, DISASM_REPORTER reporter ) {
		X86_Disasm * dis = (X86_Disasm *)
				calloc( sizeof( X86_Disasm ), 1 );
		x86_init( options, reporter, NULL );
		return dis;
	}

	X86_Disasm( enum x86_options options, DISASM_REPORTER reporter,
		    void * arg ) {
		X86_Disasm * dis = (X86_Disasm *)
				calloc( sizeof( X86_Disasm ), 1 );
		x86_init( options, reporter, arg );
		return dis;
	}

	~X86_Disasm() {
		x86_cleanup();
		free( self );
	}

	void set_options( enum x86_options options ) {
		return x86_set_options( options );
	}

	enum x86_options options() {
		return x86_get_options();
	}

	void set_callback( void * callback ) {
		self->disasm_callback = callback;
	}

	void set_resolver( void * callback ) {
		self->disasm_resolver = callback;
	}

	void report_error( enum x86_report_codes code ) {
		x86_report_error( code, NULL );
	}

	%newobject disasm;
	x86_insn_t * disasm( unsigned char *buf, size_t buf_len, 
		           unsigned long buf_rva, unsigned int offset ) {
		x86_insn_t *insn = calloc( sizeof( x86_insn_t ), 1 );
		x86_disasm( buf, buf_len, buf_rva, offset, insn );
		return insn;
	}

	int disasm_range( unsigned char *buf, size_t buf_len, 
	              unsigned long buf_rva, unsigned int offset,
		      unsigned int len ) {

		X86_InsnList *list = new_X86_InsnList();

		if ( len > buf_len ) {
			len = buf_len;
		}

		return x86_disasm_range( buf, buf_rva, offset, len, 
				x86_default_callback, list );
	}

	int disasm_forward( unsigned char *buf, size_t buf_len,
			    unsigned long buf_rva, unsigned int offset ) {
		X86_InsnList *list = new_X86_InsnList();

		/* use default resolver: damn SWIG callbacks! */
		return x86_disasm_forward( buf, buf_len, buf_rva, offset,
			                   x86_default_callback, list, 
					   x86_default_resolver, NULL );
	}

	size_t disasm_invariant( unsigned char *buf, size_t buf_len, 
			  x86_invariant_t *inv ) {
		return x86_invariant_disasm( buf, buf_len, inv );
	}

	size_t disasm_size( unsigned char *buf, size_t buf_len ) {
		return x86_size_disasm( buf, buf_len );
	}

	%newobject format_header;
	char * format_header( enum x86_asm_format format) {
		char *buf, *str;
		size_t len;

		switch ( format ) {
			/* these were obtained from x86_format.c */
			case xml_syntax:
				len = 679; break;
			case raw_syntax:
				len = 172; break;
			case native_syntax:
				len = 35; break;
			case intel_syntax:
				len = 23; break;
			case att_syntax:
				len = 23; break;
			case unknown_syntax:
			default:
				len = 23; break;
		}

		buf = (char * ) calloc( len + 1, 1 );
		x86_format_header( buf, len, format );

		return buf;
	}

	unsigned int endian() {
		return x86_endian();
	}

	unsigned int addr_size() {
		return x86_addr_size();
	}

	unsigned int op_size() {
		return x86_op_size();
	}

	unsigned int word_size() {
		return x86_word_size();
	}

	unsigned int max_insn_size() {
		return x86_max_insn_size();
	}

	unsigned int sp_reg() {
		return x86_sp_reg();
	}

	unsigned int fp_reg() {
		return x86_fp_reg();
	}

	unsigned int ip_reg() {
		return x86_ip_reg();
	}

	%newobject reg_from_id;
	x86_reg_t * reg_from_id( unsigned int id ) {
		x86_reg_t * reg = calloc( sizeof(x86_reg_t), 1 );
		x86_reg_from_id( id, reg );
		return reg;
	}

	unsigned char wildcard_byte() { return X86_WILDCARD_BYTE; }

	int max_register_string() { return MAX_REGNAME; }

	int max_prefix_string() { return MAX_PREFIX_STR; }

	int max_mnemonic_string() { return MAX_MNEM_STR; }

	int max_operand_string( enum x86_asm_format format ) {
		switch ( format ) {
			case xml_syntax:
				return  MAX_OP_XML_STRING;
				break;
			case raw_syntax:
				return MAX_OP_RAW_STRING;
				break;
			case native_syntax:
			case intel_syntax:
			case att_syntax:
			case unknown_syntax:
			default:
				return MAX_OP_STRING;
				break;
		}
	}


	int max_insn_string( enum x86_asm_format format ) {
		switch ( format ) {
			case xml_syntax:
				return  MAX_INSN_XML_STRING;
				break;
			case raw_syntax:
				return MAX_INSN_RAW_STRING;
				break;
			case native_syntax:
			case intel_syntax:
			case att_syntax:
			case unknown_syntax:
			default:
				return MAX_INSN_STRING;
				break;
		}
	}

	int max_num_operands( ) { return MAX_NUM_OPERANDS; }
}

/* python callback, per the manual */
/*%typemap(python,in) PyObject *pyfunc {
	if (!PyCallable_Check($source)) {
		PyErr_SetString(PyExc_TypeError, "Need a callable object!");
 		return NULL;
	}
	$target = $source;
}*/

/* python FILE * callback, per the manual */
/*
%typemap(python,in) FILE * {
  if (!PyFile_Check($source)) {
      PyErr_SetString(PyExc_TypeError, "Need a file!");
      return NULL;
  }
  $target = PyFile_AsFile($source);
}*/