Skip to content

Commit a3be003

Browse files
MetsukiMioMetsukiMio
committed
VM: 从 pixeltower 移除 result/option 设计
1 parent 1c500cb commit a3be003

7 files changed

Lines changed: 172 additions & 292 deletions

File tree

‎include/openminecraft/vm/pixeltower/om_pixeltower.hpp‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -18,11 +18,11 @@ class OMPixelTower
1818
OMPixelTower();
1919
~OMPixelTower();
2020

21-
util::OMResult<std::any, err::OMValidationError> loadClass(std::shared_ptr<classfile::OMClassFile> file);
22-
util::OMResult<std::any, err::OMValidationError> loadClass(std::shared_ptr<std::istream> file);
23-
util::OMResult<std::shared_ptr<OMClass>, err::OMValidationError> fetchClass(std::string name);
21+
void loadClass(std::shared_ptr<classfile::OMClassFile> file);
22+
void loadClass(std::shared_ptr<std::istream> file);
23+
std::shared_ptr<OMClass> fetchClass(std::string name);
2424

25-
util::OMResult<std::any, err::OMValidationError> execute(std::string clazz, std::string name, std::string desc);
25+
void execute(std::string clazz, std::string name, std::string desc);
2626

2727
void *allocate(std::shared_ptr<OMClass> cls);
2828
void *allocateArray(std::shared_ptr<OMClass> cls, int length);

‎include/openminecraft/vm/pixeltower/om_pixeltower_classloader.hpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -17,14 +17,14 @@ class OMClassLoader
1717
OMClassLoader(std::any interpreter);
1818
~OMClassLoader();
1919

20-
util::OMResult<std::shared_ptr<OMClass>, err::OMValidationError> forName(std::string name);
20+
std::shared_ptr<OMClass> forName(std::string name);
2121
void appendStagingClass(std::shared_ptr<classfile::OMClassFile> file);
2222
std::unordered_map<uint64_t, std::shared_ptr<OMClass>> classes;
2323

2424
bool isClassCompat(OMClass *src, std::shared_ptr<OMClass> target);
2525

2626
protected:
27-
util::OMResult<std::any, err::OMValidationError> loadClass(std::shared_ptr<classfile::OMClassFile> file);
27+
void loadClass(std::shared_ptr<classfile::OMClassFile> file);
2828

2929
private:
3030
std::list<std::shared_ptr<classfile::OMClassFile>> stagingClasses;

‎include/openminecraft/vm/pixeltower/om_pixeltower_interpreter.hpp‎

Lines changed: 14 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -21,32 +21,23 @@ class OMInterpreter
2121
OMInterpreter(OMPixelTower &tower);
2222
~OMInterpreter();
2323

24-
util::OMResult<std::any, err::OMValidationError> execute(std::string clazz, std::string method, std::string sig)
24+
void execute(std::string clazz, std::string method, std::string sig)
2525
{
26-
auto cls = tower.fetchClass(clazz);
27-
if (cls.type == util::Err)
28-
{
29-
return util::OMResult<std::any, err::OMValidationError>::err(cls.unwrap_err());
30-
}
31-
return execute(cls.unwrap(), method, sig);
26+
return execute(tower.fetchClass(clazz), method, sig);
3227
}
33-
util::OMResult<std::any, err::OMValidationError> execute(std::shared_ptr<OMClass> clazz, std::string method,
34-
std::string sig);
35-
util::OMResult<std::any, err::OMValidationError> executeDynamic(std::string clazz, std::string method,
36-
std::string sig,
37-
std::shared_ptr<OMFrameMetadata> frame);
38-
util::OMResult<std::any, err::OMValidationError> execute(std::shared_ptr<OMClass> clazz,
39-
std::shared_ptr<OMMethodInfo> mi);
28+
void execute(std::shared_ptr<OMClass> clazz, std::string method, std::string sig);
29+
void executeDynamic(std::string clazz, std::string method, std::string sig, std::shared_ptr<OMFrameMetadata> frame);
30+
void execute(std::shared_ptr<OMClass> clazz, std::shared_ptr<OMMethodInfo> mi);
4031

4132
std::unordered_map<std::thread::id, std::stack<std::any>> stack;
4233

43-
util::OMResult<std::any, err::OMValidationError> operand_invokeany(std::shared_ptr<OMFrameMetadata> frame);
34+
void operand_invokeany(std::shared_ptr<OMFrameMetadata> frame);
4435
void operand_dup(std::shared_ptr<OMFrameMetadata> frame);
45-
util::OMResult<std::any, err::OMValidationError> operand_return(std::shared_ptr<OMFrameMetadata> frame);
46-
util::OMResult<std::any, err::OMValidationError> operand_ireturn(std::shared_ptr<OMFrameMetadata> frame);
36+
void operand_return(std::shared_ptr<OMFrameMetadata> frame);
37+
void operand_ireturn(std::shared_ptr<OMFrameMetadata> frame);
4738
void operand_new(std::shared_ptr<OMFrameMetadata> frame);
4839
void operand_aload_n(std::shared_ptr<OMFrameMetadata> frame);
49-
util::OMResult<std::any, err::OMValidationError> operand_if_acmpne(std::shared_ptr<OMFrameMetadata> frame);
40+
void operand_if_acmpne(std::shared_ptr<OMFrameMetadata> frame);
5041
void operand_iconst_n(std::shared_ptr<OMFrameMetadata> frame);
5142
void operand_lconst_n(std::shared_ptr<OMFrameMetadata> frame);
5243
void operand_fconst_n(std::shared_ptr<OMFrameMetadata> frame);
@@ -56,19 +47,18 @@ class OMInterpreter
5647
void operand_pop(std::shared_ptr<OMFrameMetadata> frame);
5748
void operand_astore_n(std::shared_ptr<OMFrameMetadata> frame);
5849
void operand_istore_n(std::shared_ptr<OMFrameMetadata> frame);
59-
util::OMResult<std::any, err::OMValidationError> operand_invokeinterface(std::shared_ptr<OMFrameMetadata> frame);
60-
util::OMResult<std::any, err::OMValidationError> operand_putstatic(std::shared_ptr<OMFrameMetadata> frame);
61-
util::OMResult<std::any, err::OMValidationError> operand_putfield(std::shared_ptr<OMFrameMetadata> frame);
50+
void operand_invokeinterface(std::shared_ptr<OMFrameMetadata> frame);
51+
void operand_putstatic(std::shared_ptr<OMFrameMetadata> frame);
52+
void operand_putfield(std::shared_ptr<OMFrameMetadata> frame);
6253

6354
void *newString(std::string data);
6455

6556
private:
66-
util::OMResult<std::any, err::OMValidationError> checkType(std::shared_ptr<OMFrameMetadata> frame, std::any data,
67-
std::string desc);
57+
void checkType(std::shared_ptr<OMFrameMetadata> frame, std::any data, std::string desc);
6858
std::string fetchName(OMArrayType type);
6959
void writeStackTop(void *target, std::string desc, std::shared_ptr<OMFrameMetadata> frame);
7060
std::string fetchCurrentPosition(std::shared_ptr<OMFrameMetadata> frame);
71-
util::OMResult<std::any, err::OMValidationError> popFrame(std::shared_ptr<OMFrameMetadata> frame);
61+
void popFrame(std::shared_ptr<OMFrameMetadata> frame);
7262

7363
OMPixelTower &tower;
7464
log::OMLogger logger;

‎src/boot/entrypoint.cpp‎

Lines changed: 16 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -152,32 +152,26 @@ int boot(std::vector<std::string> args)
152152
{
153153
if (commandBuffer[1] == "loadcls")
154154
{
155-
auto l = pt->loadClass(std::make_shared<std::ifstream>(commandBuffer[2], std::ios::binary));
156-
switch (l.type)
155+
try
157156
{
158-
case Ok:
159-
break;
160-
case Err:
161-
throw l.unwrap_err();
157+
pt->loadClass(std::make_shared<std::ifstream>(commandBuffer[2], std::ios::binary));
158+
159+
auto cls = pt->fetchClass("java/lang/String");
160+
void *arr = pt->allocateArray(cls, 1);
161+
void *str = std::any_cast<std::shared_ptr<runtime::OMInterpreter>>(pt->interpreter)
162+
->newString("--debug");
163+
164+
ARRAY_ACCESS(arr, void *)[0] = str;
165+
std::any_cast<std::shared_ptr<runtime::OMInterpreter>>(pt->interpreter)
166+
->stack[std::this_thread::get_id()]
167+
.push(arr);
168+
pt->execute("openminecraft/Test", "main", "([Ljava/lang/String;)V");
162169
}
163-
164-
auto cls = pt->fetchClass("java/lang/String");
165-
if (cls.type == Err)
170+
catch (vm::err::OMValidationError err)
166171
{
167-
logger->warn(cls.unwrap_err().what());
168-
break;
172+
logger->error(err.what());
169173
}
170-
void *arr = pt->allocateArray(cls.unwrap(), 1);
171-
void *str = std::any_cast<std::shared_ptr<runtime::OMInterpreter>>(pt->interpreter)
172-
->newString("--debug");
173-
174-
ARRAY_ACCESS(arr, void *)[0] = str;
175-
std::any_cast<std::shared_ptr<runtime::OMInterpreter>>(pt->interpreter)
176-
->stack[std::this_thread::get_id()]
177-
.push(arr);
178-
auto c = pt->execute("openminecraft/Test", "main", "([Ljava/lang/String;)V");
179174

180-
logger->info(c.unwrap_err().what());
181175
commandBuffer.clear();
182176
}
183177
else if (commandBuffer[1] == "init")
@@ -186,11 +180,7 @@ int boot(std::vector<std::string> args)
186180
searchDir(m, std::filesystem::directory_iterator(commandBuffer[2]));
187181
for (auto a : m)
188182
{
189-
auto resu = pt->loadClass(std::make_shared<std::ifstream>(a, std::ios::binary));
190-
if (resu.type == Err)
191-
{
192-
throw resu.unwrap_err();
193-
}
183+
pt->loadClass(std::make_shared<std::ifstream>(a, std::ios::binary));
194184
}
195185

196186
commandBuffer.clear();

‎src/vm/pixeltower/om_pixeltower.cpp‎

Lines changed: 9 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@
22
#include "openminecraft/log/om_log_ansi.hpp"
33
#include "openminecraft/log/om_log_common.hpp"
44
#include "openminecraft/log/om_log_threadname.hpp"
5+
#include "openminecraft/util/om_util_result.hpp"
56
#include "openminecraft/vm/bytecode/om_bytecode_checker.hpp"
67
#include "openminecraft/vm/pixeltower/om_pixeltower_array_structdef.hpp"
78
#include "openminecraft/vm/pixeltower/om_pixeltower_classloader.hpp"
@@ -26,7 +27,7 @@ OMPixelTower::OMPixelTower() : logger("OMPixelTower", this)
2627
OMPixelTower::~OMPixelTower()
2728
{
2829
}
29-
util::OMResult<std::any, err::OMValidationError> OMPixelTower::loadClass(std::shared_ptr<classfile::OMClassFile> file)
30+
void OMPixelTower::loadClass(std::shared_ptr<classfile::OMClassFile> file)
3031
{
3132
auto chk = std::make_unique<bytecode::OMBytecodeChecker>(file);
3233
auto cons = chk->constantCheck();
@@ -35,36 +36,34 @@ util::OMResult<std::any, err::OMValidationError> OMPixelTower::loadClass(std::sh
3536
case util::Ok:
3637
break;
3738
case util::Err:
38-
return util::OMResult<std::any, err::OMValidationError>::err(cons.unwrap_err());
39+
throw cons.unwrap_err();
3940
}
4041
// chk->detail();
4142

4243
classloader->appendStagingClass(file);
43-
return util::OMResult<std::any, err::OMValidationError>::ok(nullptr);
4444
}
45-
util::OMResult<std::any, err::OMValidationError> OMPixelTower::loadClass(std::shared_ptr<std::istream> file)
45+
void OMPixelTower::loadClass(std::shared_ptr<std::istream> file)
4646
{
4747
auto parser = std::make_shared<classfile::OMClassFileParser>(file);
4848
auto clsres = parser->parse();
4949
switch (clsres.type)
5050
{
5151
case util::Ok: {
52-
return loadClass(clsres.unwrap());
52+
loadClass(clsres.unwrap());
5353
break;
5454
}
5555
case util::Err: {
56-
return util::OMResult<std::any, err::OMValidationError>::err(clsres.unwrap_err());
56+
throw clsres.unwrap_err();
5757
}
5858
}
5959
}
60-
util::OMResult<std::shared_ptr<OMClass>, err::OMValidationError> OMPixelTower::fetchClass(std::string name)
60+
std::shared_ptr<OMClass> OMPixelTower::fetchClass(std::string name)
6161
{
6262
return classloader->forName(name);
6363
}
64-
util::OMResult<std::any, err::OMValidationError> OMPixelTower::execute(std::string clazz, std::string name,
65-
std::string desc)
64+
void OMPixelTower::execute(std::string clazz, std::string name, std::string desc)
6665
{
67-
return std::any_cast<std::shared_ptr<runtime::OMInterpreter>>(interpreter)->execute(clazz, name, desc);
66+
std::any_cast<std::shared_ptr<runtime::OMInterpreter>>(interpreter)->execute(clazz, name, desc);
6867
}
6968
void OMPixelTower::debugStackStatus()
7069
{

‎src/vm/pixeltower/om_pixeltower_classloader.cpp‎

Lines changed: 13 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -19,38 +19,28 @@ OMClassLoader::OMClassLoader(std::any interpreter) : logger("pixeltower/OMClassL
1919
OMClassLoader::~OMClassLoader()
2020
{
2121
}
22-
util::OMResult<std::any, err::OMValidationError> OMClassLoader::loadClass(std::shared_ptr<OMClassFile> file)
22+
void OMClassLoader::loadClass(std::shared_ptr<OMClassFile> file)
2323
{
2424
auto clsdata = std::make_shared<OMClass>();
2525
clsdata->name = file->mapping[file->mapping[file->thisClass]->to<OMClassConstantClass>()->nameIndex]
2626
->to<OMClassConstantUtf8>()
2727
->data;
2828
if (file->superClass != 0)
2929
{
30-
auto superClassResult =
30+
clsdata->superClass =
3131
forName(file->mapping[file->mapping[file->superClass]->to<OMClassConstantClass>()->nameIndex]
3232
->to<OMClassConstantUtf8>()
3333
->data);
34-
if (superClassResult.type == util::Err)
35-
{
36-
return util::OMResult<std::any, err::OMValidationError>::err(superClassResult.unwrap_err());
37-
}
38-
clsdata->superClass = superClassResult.unwrap();
3934
}
4035
if (file->superClass == 0 && clsdata->name != "java/lang/Object")
4136
{
4237
logger.warn("class {} doesn't have its super class!", clsdata->name);
4338
}
4439
for (auto inter : file->interfaces)
4540
{
46-
auto interfaceResult = forName(file->mapping[file->mapping[inter]->to<OMClassConstantClass>()->nameIndex]
47-
->to<OMClassConstantUtf8>()
48-
->data);
49-
if (interfaceResult.type == util::Err)
50-
{
51-
return util::OMResult<std::any, err::OMValidationError>::err(interfaceResult.unwrap_err());
52-
}
53-
clsdata->interfaces.push_back(interfaceResult.unwrap());
41+
clsdata->interfaces.push_back(forName(file->mapping[file->mapping[inter]->to<OMClassConstantClass>()->nameIndex]
42+
->to<OMClassConstantUtf8>()
43+
->data));
5444
}
5545

5646
for (auto field : file->fields)
@@ -82,8 +72,8 @@ util::OMResult<std::any, err::OMValidationError> OMClassLoader::loadClass(std::s
8272
break;
8373
}
8474
default:
85-
return util::OMResult<std::any, err::OMValidationError>::err(
86-
{err::ClassLoader, fmt::format("unknown field descriptor {}", m), clsdata->name});
75+
throw err::OMValidationError{err::ClassLoader, fmt::format("unknown field descriptor {}", m),
76+
clsdata->name};
8777
}
8878
clsdata->fields.push_back(f);
8979
}
@@ -125,12 +115,11 @@ util::OMResult<std::any, err::OMValidationError> OMClassLoader::loadClass(std::s
125115
if (me->name == "<clinit>")
126116
{
127117
logger.info("{} loaded with class init func", clsdata->name);
128-
return std::any_cast<std::shared_ptr<runtime::OMInterpreter>>(interpreter)->execute(clsdata, me);
118+
std::any_cast<std::shared_ptr<runtime::OMInterpreter>>(interpreter)->execute(clsdata, me);
129119
}
130120
}
131121

132122
logger.info("{} loaded", clsdata->name);
133-
return util::OMResult<std::any, err::OMValidationError>::ok(nullptr);
134123
}
135124
bool OMClassLoader::isClassCompat(OMClass *src, std::shared_ptr<OMClass> target)
136125
{
@@ -162,7 +151,7 @@ bool OMClassLoader::isClassCompat(OMClass *src, std::shared_ptr<OMClass> target)
162151

163152
return false;
164153
}
165-
util::OMResult<std::shared_ptr<OMClass>, err::OMValidationError> OMClassLoader::forName(std::string name)
154+
std::shared_ptr<OMClass> OMClassLoader::forName(std::string name)
166155
{
167156
if (name[0] == '[')
168157
{
@@ -172,8 +161,7 @@ util::OMResult<std::shared_ptr<OMClass>, err::OMValidationError> OMClassLoader::
172161
if (classes.count(hash_compile_time(name.c_str())))
173162
{
174163
find_class:
175-
return util::OMResult<std::shared_ptr<OMClass>, err::OMValidationError>::ok(
176-
classes[hash_compile_time(name.c_str())]);
164+
return classes[hash_compile_time(name.c_str())];
177165
}
178166
else // try to load the class from staging area!
179167
{
@@ -189,18 +177,11 @@ util::OMResult<std::shared_ptr<OMClass>, err::OMValidationError> OMClassLoader::
189177
}
190178
}
191179

192-
return util::OMResult<std::shared_ptr<OMClass>, err::OMValidationError>::err(
193-
{err::ClassLoader, "class not found", name});
180+
throw err::OMValidationError{err::ClassLoader, "class not found", name};
194181
subclass_loading:
195182
stagingClasses.remove(cls);
196-
auto result = loadClass(cls);
197-
switch (result.type)
198-
{
199-
case util::Ok:
200-
goto find_class;
201-
case util::Err:
202-
return util::OMResult<std::shared_ptr<OMClass>, err::OMValidationError>::err(result.unwrap_err());
203-
}
183+
loadClass(cls);
184+
goto find_class;
204185
}
205186
}
206187
void OMClassLoader::appendStagingClass(std::shared_ptr<classfile::OMClassFile> file)

0 commit comments

Comments
 (0)