src/debug/debugger.h

/* 
 *      HT Editor
 *      debugger.h
 *
 *      Copyright (C) 2003 Stefan Weyergraf
 *
 *      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 __DEBUGGER_H__
#define __DEBUGGER_H__

#define HAVE_DEBUGGER

#include "tools/data.h"
#include "tools/str.h"
#include "parsehelper.h"
#include "cpu/cpu.h"

#ifdef HAVE_DEBUGGER
#include "cpu/cpu_generic/ppc_cpu.h"
#endif

enum EvalType {
        ET_INTEGER,
        ET_FLOAT,
        ET_STRING,
        ET_VARARGS
};

/**
 *      An abstract function
 */
class Function: public Object {
public:
        /* new */
        virtual EvalType        getReturnType() const = 0;
        virtual SInt64 *        evalInteger() const;
        virtual Float *         evalFloat() const;
        virtual String *        evalString() const;
        virtual uint            getArgCount() const;
        virtual Function *      getArg(uint i) const;
        virtual void            setArg(uint i, Function *f);
};

/**
 *      A constant (signed) integer function
 */
class SInt64Function: public Function {
protected:
        sint64 value;
public:
        SInt64Function(sint64 v);
        /* extends Function */
        virtual EvalType        getReturnType() const;
        virtual SInt64 *        evalInteger() const;
};

/**
 *      A GPR
 */
class GPRFunction: public Function {
protected:
        int mNumber;
public:
        GPRFunction(int number);
        /* extends Function */
        virtual EvalType        getReturnType() const;
        virtual SInt64 *        evalInteger() const;
};

class FPRFunction: public Function {
protected:
        int mNumber;
public:
        FPRFunction(int number);
        /* extends Function */
        virtual EvalType        getReturnType() const;
        virtual Float *         evalFloat() const;
};

class UInt32PFunction: public Function {
protected:
        uint32 *mValue;
public:
        UInt32PFunction(uint32 *aValue);
        /* extends Function */
        virtual EvalType        getReturnType() const;
        virtual SInt64 *        evalInteger() const;
};
/**
 *      A constant float function
 */
class FloatFunction: public Function {
protected:
        double value;
public:
        FloatFunction(double v);
/* extends Function */
        virtual EvalType        getReturnType() const;
        virtual Float *         evalFloat() const;
};

/**
 *      A constant string function
 */
class StringFunction: public Function {
protected:
        String value;
public:
        StringFunction(const byte *str, int len);
/* extends Function */
        virtual EvalType        getReturnType() const;
        virtual String *        evalString() const;
};

/**
 *      A parametrized function (implementation helper)
 */
class PFunction: public Function {
protected:
        Array mArgs;
public:
        PFunction();
/* extends Function */
        virtual uint            getArgCount() const;
        virtual Function *      getArg(uint i) const;
        virtual void            setArg(uint i, Function *f);
};

/*
 *
 */
class Watch: public Object {
        String *mName;
        Function *f;
public:
                                Watch(String *aName, Function *f);
        virtual                 ~Watch();
        virtual int             toString(char *buf, int buflen) const;

};

/*
 *      A debugger
 */
class Debugger {
protected:
        Container *mWatches;
#ifdef HAVE_DEBUGGER
        PPC_CPU_State savedCPUState;
#endif
        bool mForceSinglestep;

                Function *eval_scalarToFunction(eval_scalar &s);
        virtual Function *matchFunction(const String &name, const Enumerator &params);
public:
        bool    mAlwaysShowRegs;
        bool    mUseColors;

                Debugger();
        virtual ~Debugger();
        bool    parse(const String &str);
        void    enter();
        void    dump();
};

void debugger_init_config();

#endif /* __EVAL_H__ */
1	/*
2	* HT Editor
3	* debugger.h
4	*
5	* Copyright (C) 2003 Stefan Weyergraf
6	*
7	* This program is free software; you can redistribute it and/or modify
8	* it under the terms of the GNU General Public License version 2 as
9	* published by the Free Software Foundation.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19	*/
20
21	#ifndef __DEBUGGER_H__
22	#define __DEBUGGER_H__
23
24	#define HAVE_DEBUGGER
25
26	#include "tools/data.h"
27	#include "tools/str.h"
28	#include "parsehelper.h"
29	#include "cpu/cpu.h"
30
31	#ifdef HAVE_DEBUGGER
32	#include "cpu/cpu_generic/ppc_cpu.h"
33	#endif
34
35	enum EvalType {
36	ET_INTEGER,
37	ET_FLOAT,
38	ET_STRING,
39	ET_VARARGS
40	};
41
42	/**
43	* An abstract function
44	*/
45	class Function: public Object {
46	public:
47	/* new */
48	virtual EvalType getReturnType() const = 0;
49	virtual SInt64 * evalInteger() const;
50	virtual Float * evalFloat() const;
51	virtual String * evalString() const;
52	virtual uint getArgCount() const;
53	virtual Function * getArg(uint i) const;
54	virtual void setArg(uint i, Function *f);
55	};
56
57	/**
58	* A constant (signed) integer function
59	*/
60	class SInt64Function: public Function {
61	protected:
62	sint64 value;
63	public:
64	SInt64Function(sint64 v);
65	/* extends Function */
66	virtual EvalType getReturnType() const;
67	virtual SInt64 * evalInteger() const;
68	};
69
70	/**
71	* A GPR
72	*/
73	class GPRFunction: public Function {
74	protected:
75	int mNumber;
76	public:
77	GPRFunction(int number);
78	/* extends Function */
79	virtual EvalType getReturnType() const;
80	virtual SInt64 * evalInteger() const;
81	};
82
83	class FPRFunction: public Function {
84	protected:
85	int mNumber;
86	public:
87	FPRFunction(int number);
88	/* extends Function */
89	virtual EvalType getReturnType() const;
90	virtual Float * evalFloat() const;
91	};
92
93	class UInt32PFunction: public Function {
94	protected:
95	uint32 *mValue;
96	public:
97	UInt32PFunction(uint32 *aValue);
98	/* extends Function */
99	virtual EvalType getReturnType() const;
100	virtual SInt64 * evalInteger() const;
101	};
102	/**
103	* A constant float function
104	*/
105	class FloatFunction: public Function {
106	protected:
107	double value;
108	public:
109	FloatFunction(double v);
110	/* extends Function */
111	virtual EvalType getReturnType() const;
112	virtual Float * evalFloat() const;
113	};
114
115	/**
116	* A constant string function
117	*/
118	class StringFunction: public Function {
119	protected:
120	String value;
121	public:
122	StringFunction(const byte *str, int len);
123	/* extends Function */
124	virtual EvalType getReturnType() const;
125	virtual String * evalString() const;
126	};
127
128	/**
129	* A parametrized function (implementation helper)
130	*/
131	class PFunction: public Function {
132	protected:
133	Array mArgs;
134	public:
135	PFunction();
136	/* extends Function */
137	virtual uint getArgCount() const;
138	virtual Function * getArg(uint i) const;
139	virtual void setArg(uint i, Function *f);
140	};
141
142	/*
143	*
144	*/
145	class Watch: public Object {
146	String *mName;
147	Function *f;
148	public:
149	Watch(String aName, Function f);
150	virtual ~Watch();
151	virtual int toString(char *buf, int buflen) const;
152
153	};
154
155	/*
156	* A debugger
157	*/
158	class Debugger {
159	protected:
160	Container *mWatches;
161	#ifdef HAVE_DEBUGGER
162	PPC_CPU_State savedCPUState;
163	#endif
164	bool mForceSinglestep;
165
166	Function *eval_scalarToFunction(eval_scalar &s);
167	virtual Function *matchFunction(const String &name, const Enumerator &params);
168	public:
169	bool mAlwaysShowRegs;
170	bool mUseColors;
171
172	Debugger();
173	virtual ~Debugger();
174	bool parse(const String &str);
175	void enter();
176	void dump();
177	};
178
179	void debugger_init_config();
180
181	#endif /* __EVAL_H__ */