1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* 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 3 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, see <http://www.gnu.org/licenses/>.
*
*/
#ifndef ULTIMA8_USECODE_UCMACHINE_H
#define ULTIMA8_USECODE_UCMACHINE_H
#include "ultima/ultima8/misc/common_types.h"
#include "ultima/shared/std/string.h"
#include "ultima/shared/std/containers.h"
#include "ultima/ultima8/usecode/intrinsics.h"
namespace Ultima {
namespace Ultima8 {
class Debugger;
class Process;
class UCProcess;
class ConvertUsecode;
class GlobalStorage;
class UCList;
class idMan;
class UCMachine {
friend class Debugger;
public:
UCMachine(const Intrinsic *iset, unsigned int icount);
~UCMachine();
static UCMachine *get_instance() {
return _ucMachine;
}
void reset();
void execProcess(UCProcess *proc);
const Std::string &getString(uint16 str) const;
UCList *getList(uint16 l);
void freeString(uint16 s);
void freeStringList(uint16 l);
void freeList(uint16 l);
uint16 duplicateString(uint16 str);
void usecodeStats() const;
static uint32 listToPtr(uint16 l);
static uint32 stringToPtr(uint16 s);
static uint32 stackToPtr(uint16 pid, uint16 offset);
static uint32 globalToPtr(uint16 offset);
static uint32 objectToPtr(uint16 objID);
static uint16 ptrToObject(uint32 ptr);
bool assignPointer(uint32 ptr, const uint8 *data, uint32 size);
bool dereferencePointer(uint32 ptr, uint8 *data, uint32 size);
void saveGlobals(Common::WriteStream *ws) const;
void saveStrings(Common::WriteStream *ws) const;
void saveLists(Common::WriteStream *ws) const;
bool loadGlobals(Common::ReadStream *rs, uint32 version);
bool loadStrings(Common::ReadStream *rs, uint32 version);
bool loadLists(Common::ReadStream *rs, uint32 version);
INTRINSIC(I_true);
INTRINSIC(I_false);
INTRINSIC(I_dummyProcess);
INTRINSIC(I_getName);
INTRINSIC(I_urandom);
INTRINSIC(I_rndRange);
INTRINSIC(I_numToStr);
protected:
void loadIntrinsics(const Intrinsic *i, unsigned int icount);
private:
ConvertUsecode *_convUse;
const Intrinsic *_intrinsics;
unsigned int _intrinsicCount;
GlobalStorage *_globals;
Common::HashMap<uint16, UCList *> _listHeap;
Common::HashMap<uint16, Std::string> _stringHeap;
// Add a string to the list (copies the string)
uint16 assignString(const char *str);
uint16 assignList(UCList *l);
idMan *_listIDs;
idMan *_stringIDs;
static UCMachine *_ucMachine;
// tracing
bool _tracingEnabled;
bool _traceAll;
Std::set<ObjId> _traceObjIDs;
Std::set<ProcId> _tracePIDs;
Std::set<uint16> _traceClasses;
inline bool trace_show(ProcId pid, ObjId objid, uint16 ucclass) {
if (!_tracingEnabled) return false;
if (_traceAll) return true;
if (_traceObjIDs.find(objid) != _traceObjIDs.end()) return true;
if (_tracePIDs.find(pid) != _tracePIDs.end()) return true;
if (_traceClasses.find(ucclass) != _traceClasses.end()) return true;
return false;
}
};
} // End of namespace Ultima8
} // End of namespace Ultima
#endif
|
