From 772c6da9f1790448196cbc6c978e913ca7008b7f Mon Sep 17 00:00:00 2001 From: hinus Date: Thu, 16 Jul 2020 23:50:15 +0800 Subject: [PATCH] =?UTF-8?q?Summary:=20=E5=A4=9A=E6=AC=A1GC=E5=AF=BC?= =?UTF-8?q?=E8=87=B4=E5=86=85=E9=83=A8=E6=8C=87=E9=92=88=E9=94=99=E8=AF=AF?= =?UTF-8?q?=20Issue:=20https://gitee.com/hinus/HiLang/issues/I1O3TI=20Desc?= =?UTF-8?q?ription:=201.=20=E4=BD=BF=E7=94=A8=E9=9D=99=E6=80=81=E6=96=B9?= =?UTF-8?q?=E6=B3=95new=5Finstance=E6=8E=A7=E5=88=B6HiList=E7=9A=84?= =?UTF-8?q?=E5=88=9D=E5=A7=8B=E5=8C=96=E9=A1=BA=E5=BA=8F=202.=20=E4=BD=BF?= =?UTF-8?q?=E7=94=A8=E9=9D=99=E6=80=81=E6=96=B9=E6=B3=95new=5Finstance?= =?UTF-8?q?=E6=8E=A7=E5=88=B6HiDict=E7=9A=84=E5=88=9D=E5=A7=8B=E5=8C=96?= =?UTF-8?q?=E9=A1=BA=E5=BA=8F=203.=20=E9=87=8D=E6=9E=84Handles=EF=BC=8C?= =?UTF-8?q?=E6=AD=A3=E7=A1=AE=E4=BD=BF=E7=94=A8Handles=E7=BB=B4=E6=8A=A4?= =?UTF-8?q?=E6=A0=88=E4=B8=8A=E6=8C=87=E9=92=88=20LLT:=20function.hi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/vm/CMakeLists.txt | 2 +- src/main/vm/code/binaryFileParser.cpp | 16 ++-- src/main/vm/code/binaryFileParser.hpp | 2 +- src/main/vm/object/hiDict.cpp | 45 +++++---- src/main/vm/object/hiDict.hpp | 6 +- src/main/vm/object/hiDouble.cpp | 2 +- src/main/vm/object/hiFile.cpp | 5 +- src/main/vm/object/hiInteger.cpp | 2 +- src/main/vm/object/hiList.cpp | 59 +++++++++--- src/main/vm/object/hiList.hpp | 17 ++-- src/main/vm/object/hiLong.cpp | 6 +- src/main/vm/object/hiObject.cpp | 2 +- src/main/vm/object/hiString.cpp | 2 +- src/main/vm/object/hiTuple.cpp | 7 +- src/main/vm/object/klass.cpp | 37 +++++--- src/main/vm/runtime/cellObject.cpp | 2 +- src/main/vm/runtime/frameObject.cpp | 125 ++++++++++++++++--------- src/main/vm/runtime/frameObject.hpp | 7 +- src/main/vm/runtime/functionObject.cpp | 6 +- src/main/vm/runtime/generator.cpp | 3 +- src/main/vm/runtime/interpreter.cpp | 60 +++++++----- src/main/vm/runtime/module.cpp | 11 ++- src/main/vm/runtime/traceback.cpp | 4 +- src/main/vm/runtime/universe.cpp | 6 +- src/main/vm/util/arrayList.cpp | 3 +- src/main/vm/util/arrayList.hpp | 5 +- src/main/vm/util/handles.cpp | 78 ++++++++++++--- src/main/vm/util/handles.hpp | 39 +++++--- src/test/hilang/function.hi | 17 +++- 29 files changed, 386 insertions(+), 190 deletions(-) diff --git a/src/main/vm/CMakeLists.txt b/src/main/vm/CMakeLists.txt index e91b7cb..02fdb28 100644 --- a/src/main/vm/CMakeLists.txt +++ b/src/main/vm/CMakeLists.txt @@ -68,6 +68,6 @@ ADD_LIBRARY(hivm SHARED ${SOURCE_FILE}) # libmath ADD_LIBRARY(math SHARED extlib/math.cpp) -TARGET_LINK_LIBRARIES(hivm) +TARGET_LINK_LIBRARIES(hivm -ldl) TARGET_LINK_LIBRARIES(math hivm) TARGET_LINK_LIBRARIES(railgun hivm math) diff --git a/src/main/vm/code/binaryFileParser.cpp b/src/main/vm/code/binaryFileParser.cpp index 47d64c7..b00c865 100644 --- a/src/main/vm/code/binaryFileParser.cpp +++ b/src/main/vm/code/binaryFileParser.cpp @@ -2,12 +2,14 @@ #include #include "code/binaryFileParser.hpp" -#include "runtime/universe.hpp" #include "object/hiList.hpp" #include "object/hiDouble.hpp" +#include "runtime/universe.hpp" +#include "memory/heap.hpp" BinaryFileParser::BinaryFileParser(BufferedInputStream* buf_file_stream) { file_stream = buf_file_stream; + _string_table = NEW_ARRAYLIST(HiString*, 8); } CodeObject* BinaryFileParser::parse() { @@ -73,11 +75,11 @@ HiString* BinaryFileParser::get_name() { } else if (ch == 't') { HiString* str = get_string(); - _string_table.add(str); + _string_table->add(str); return str; } else if (ch == 'R') { - return _string_table.get(file_stream->read_int()); + return _string_table->get(file_stream->read_int()); } return NULL; @@ -153,7 +155,7 @@ ArrayList* BinaryFileParser::get_tuple() { int length = file_stream->read_int(); HiString * str; - ArrayList* list = new ArrayList(length); + ArrayList* list = NEW_ARRAYLIST(HiObject*, length); for (int i = 0; i < length; i++) { char obj_type = file_stream->read(); @@ -174,16 +176,16 @@ ArrayList* BinaryFileParser::get_tuple() { case 't': str = get_string(); list->add(str); - _string_table.add(str); + _string_table->add(str); break; case 's': list->add(get_string()); break; case 'R': - list->add(_string_table.get(file_stream->read_int())); + list->add(_string_table->get(file_stream->read_int())); break; case '(': - list->add(new HiList(get_tuple())); + list->add(HiList::new_instance(get_tuple())); break; default: printf("parser, unrecognized type : %c\n", obj_type); diff --git a/src/main/vm/code/binaryFileParser.hpp b/src/main/vm/code/binaryFileParser.hpp index a798ec4..1c3d8a3 100644 --- a/src/main/vm/code/binaryFileParser.hpp +++ b/src/main/vm/code/binaryFileParser.hpp @@ -12,7 +12,7 @@ class BinaryFileParser { private: BufferedInputStream* file_stream; int cur; - ArrayList _string_table; + ArrayList* _string_table; public: BinaryFileParser(BufferedInputStream* stream); diff --git a/src/main/vm/object/hiDict.cpp b/src/main/vm/object/hiDict.cpp index 047475d..6ac079c 100644 --- a/src/main/vm/object/hiDict.cpp +++ b/src/main/vm/object/hiDict.cpp @@ -6,6 +6,9 @@ #include "runtime/universe.hpp" #include "runtime/stringTable.hpp" #include "memory/oopClosure.hpp" +#include "memory/heap.hpp" +#include "util/handles.hpp" + #include DictKlass* DictKlass::instance = NULL; @@ -22,7 +25,7 @@ DictKlass::DictKlass() { } void DictKlass::initialize() { - HiDict* klass_dict = new HiDict(); + HiDict* klass_dict = HiDict::new_instance(); klass_dict->put(new HiString("setdefault"), new FunctionObject(dict_set_default)); klass_dict->put(new HiString("remove"), @@ -94,7 +97,7 @@ void DictKlass::del_subscr(HiObject* x, HiObject* y) { } HiDict::HiDict() { - _map = new Map(); + _map = NULL; set_klass(DictKlass::get_instance()); } @@ -103,6 +106,13 @@ HiDict::HiDict(Map* x) { set_klass(DictKlass::get_instance()); } +HiDict* HiDict::new_instance() { + Map* tmap = new Map(); + HiDict* td = new HiDict(); + td->set_map(tmap); + return td; +} + void HiDict::update(HiDict* dict) { for (int i = 0; i < dict->size(); i++) { put(dict->map()->get_key(i), @@ -132,7 +142,7 @@ DictIteratorKlass::DictIteratorKlass() { "dictionary-valueiterator", "dictionary-itemiterator", }; - set_klass_dict(new HiDict()); + set_klass_dict(HiDict::new_instance()); set_name(new HiString(klass_names[iter_type])); } @@ -162,42 +172,39 @@ HiObject* dict_remove(ObjList args) { } HiObject* dict_keys(ObjList args) { - HiDict* x = (HiDict*)(args->get(0)); - - HiList* keys = new HiList(); + Handle x((HiDict*)args->get(0)); + Handle keys(HiList::new_instance(x->size())); for (int i = 0; i < x->size(); i++) { keys->append(x->map()->get_key(i)); } - return keys; + return keys(); } HiObject* dict_values(ObjList args) { - HiDict* x = (HiDict*)(args->get(0)); - - HiList* values = new HiList(); + Handle x((HiDict*)args->get(0)); + Handle values(HiList::new_instance(x->size())); for (int i = 0; i < x->size(); i++) { values->append(x->map()->get_value(i)); } - return values; + return values(); } HiObject* dict_items(ObjList args) { - HiDict* x = (HiDict*)(args->get(0)); - - HiList* items = new HiList(); + Handle x((HiDict*)(args->get(0))); + Handle items(HiList::new_instance(x->size())); for (int i = 0; i < x->size(); i++) { - HiList* item = new HiList(); + Handle item(HiList::new_instance(2)); item->append(x->map()->get_key(i)); item->append(x->map()->get_value(i)); - items->append(item); + items->append(item()); } - return items; + return items(); } HiObject* dict_iterkeys(ObjList args) { @@ -235,7 +242,7 @@ HiObject* DictIteratorKlass::next(HiObject* x) { obj = adict->map()->get_value(iter_cnt); } else if (iter_type == ITER_ITEM) { - HiList* lobj = new HiList(); + HiList* lobj = HiList::new_instance(8); lobj->append(adict->map()->get_key(iter_cnt)); lobj->append(adict->map()->get_value(iter_cnt)); obj = lobj; @@ -250,7 +257,7 @@ HiObject* DictIteratorKlass::next(HiObject* x) { HiObject* DictKlass::allocate_instance(HiObject* callable, ArrayList* args) { if (!args || args->length() == 0) - return new HiDict(); + return HiDict::new_instance(); else return NULL; } diff --git a/src/main/vm/object/hiDict.hpp b/src/main/vm/object/hiDict.hpp index 5b0f114..d3249b5 100644 --- a/src/main/vm/object/hiDict.hpp +++ b/src/main/vm/object/hiDict.hpp @@ -32,12 +32,14 @@ class HiDict : public HiObject { friend class DictKlass; private: Map* _map; - -public: HiDict(); HiDict(Map* map); +public: + static HiDict* new_instance(); + Map* map() { return _map; } + void set_map(Map* map) { _map = map; } void put(HiObject* k, HiObject* v) { _map->put(k, v); } HiObject* get(HiObject* k) { return _map->get(k); } bool has_key(HiObject* k) { return _map->has_key(k); } diff --git a/src/main/vm/object/hiDouble.cpp b/src/main/vm/object/hiDouble.cpp index 40f9ab9..f89e6d2 100644 --- a/src/main/vm/object/hiDouble.cpp +++ b/src/main/vm/object/hiDouble.cpp @@ -15,7 +15,7 @@ DoubleKlass::DoubleKlass() { } void DoubleKlass::initialize() { - set_klass_dict(new HiDict()); + set_klass_dict(HiDict::new_instance()); set_name(new HiString("int")); (new HiTypeObject())->set_own_klass(this); add_super(ObjectKlass::get_instance()); diff --git a/src/main/vm/object/hiFile.cpp b/src/main/vm/object/hiFile.cpp index ccdf3c7..8a67d2d 100644 --- a/src/main/vm/object/hiFile.cpp +++ b/src/main/vm/object/hiFile.cpp @@ -6,6 +6,7 @@ #include "runtime/universe.hpp" #include "runtime/stringTable.hpp" #include "memory/oopClosure.hpp" +#include "memory/heap.hpp" #include #include @@ -19,7 +20,7 @@ FileKlass* FileKlass::get_instance() { } FileKlass::FileKlass() { - HiDict * klass_dict = new HiDict(); + HiDict * klass_dict = HiDict::new_instance(); klass_dict->put(new HiString("close"), new FunctionObject(file_close)); klass_dict->put(new HiString("read"), @@ -77,7 +78,7 @@ int HiFile::close() { void HiFile::clear_buffer() { if (_buffer == NULL) { - _buffer = new ArrayList(); + _buffer = new ArrayList(8, Universe::heap->allocate(sizeof(char)*8)); } else { _buffer->clear(); diff --git a/src/main/vm/object/hiInteger.cpp b/src/main/vm/object/hiInteger.cpp index 4232ebb..56b03a1 100644 --- a/src/main/vm/object/hiInteger.cpp +++ b/src/main/vm/object/hiInteger.cpp @@ -14,7 +14,7 @@ IntegerKlass::IntegerKlass() { } void IntegerKlass::initialize() { - set_klass_dict(new HiDict()); + set_klass_dict(HiDict::new_instance()); set_name(new HiString("int")); (new HiTypeObject())->set_own_klass(this); add_super(ObjectKlass::get_instance()); diff --git a/src/main/vm/object/hiList.cpp b/src/main/vm/object/hiList.cpp index 255744e..ac551ec 100644 --- a/src/main/vm/object/hiList.cpp +++ b/src/main/vm/object/hiList.cpp @@ -7,6 +7,8 @@ #include "runtime/universe.hpp" #include "runtime/functionObject.hpp" #include "memory/oopClosure.hpp" +#include "memory/heap.hpp" +#include "util/handles.hpp" #include ListKlass* ListKlass::instance = NULL; @@ -22,7 +24,7 @@ ListKlass::ListKlass() { } void ListKlass::initialize() { - HiDict * klass_dict = new HiDict(); + HiDict * klass_dict = HiDict::new_instance(); klass_dict->put(new HiString("append"), new FunctionObject(list_append)); klass_dict->put(new HiString("pop"), @@ -52,13 +54,13 @@ HiObject* ListKlass::add(HiObject* x, HiObject* y) { HiList* ly = (HiList*)y; assert(ly && ly->klass() == (Klass*) this); - HiList* z = new HiList(); + HiList* z = HiList::new_instance(4); for (int i = 0; i < lx->size(); i++) { - z->inner_list()->set(i, lx->inner_list()->get(i)); + z->set(i, lx->inner_list()->get(i)); } for (int i = 0; i < ly->size(); i++) { - z->inner_list()->set(i + lx->size(), + z->set(i + lx->size(), ly->inner_list()->get(i)); } @@ -71,10 +73,10 @@ HiObject* ListKlass::mul(HiObject* x, HiObject* y) { HiInteger* iy = (HiInteger*)y; assert(iy && iy->klass() == IntegerKlass::get_instance()); - HiList* z = new HiList(); + HiList* z = HiList::new_instance(4); for (int i = 0; i < iy->value(); i++) { for (int j = 0; j < lx->size(); j++) { - z->inner_list()->set(i * lx->size() + j, + z->set(i * lx->size() + j, lx->inner_list()->get(j)); } } @@ -135,7 +137,7 @@ void ListKlass::store_subscr(HiObject* x, HiObject* y, HiObject* z) { HiList * lx = (HiList*)x; HiInteger* iy = (HiInteger*)y; - lx->inner_list()->set(iy->value(), z); + lx->set(iy->value(), z); } void ListKlass::del_subscr(HiObject* x, HiObject* y) { @@ -199,7 +201,7 @@ HiObject* ListKlass::less(HiObject* x, HiObject* y) { HiList::HiList() { set_klass(ListKlass::get_instance()); - _inner_list = new ArrayList(); + _inner_list = NULL; } HiList::HiList(ObjList ol) { @@ -207,6 +209,32 @@ HiList::HiList(ObjList ol) { _inner_list = ol; } +HiList* HiList::new_instance(int n) { + Handle*> h_array(NEW_ARRAYLIST(HiObject*, n)); + HiList* lst = new HiList(); + lst->set_inner_list(h_array()); + return lst; +} + +HiList* HiList::new_instance(ArrayList* lst) { + Handle*> h_array(lst); + HiList* tlist = new HiList(); + tlist->set_inner_list(h_array()); + return tlist; +} + +int HiList::size() { + return _inner_list->size(); +} + +void HiList::append(HiObject* o) { + return _inner_list->add(o); +} + +void HiList::set(int i, HiObject* o) { + return _inner_list->set(i, o); +} + HiObject* list_append(ObjList args) { ((HiList*)(args->get(0)))->append(args->get(1)); return Universe::HiNone; @@ -257,7 +285,7 @@ HiObject* list_remove(ObjList args) { assert(list && list->klass() == ListKlass::get_instance()); - for (int i = 0; i < list->inner_list()->size(); i++) { + for (int i = 0; i < list->size(); i++) { if (list->get(i)->equal(target) == (HiObject*)Universe::HiTrue) { list->inner_list()->delete_index(i); } @@ -299,7 +327,7 @@ HiObject* list_index(ObjList args) { assert(list && list->klass() == ListKlass::get_instance()); - for (int i = 0; i < list->inner_list()->size(); i++) { + for (int i = 0; i < list->size(); i++) { if (list->get(i)->equal(target) == (HiObject*)Universe::HiTrue) { return new HiInteger(i); } @@ -313,7 +341,7 @@ HiObject* list_getitem(ObjList args) { HiObject* y = (HiObject*)(args->get(1)); HiInteger* iy = (HiInteger*)y; - return list->inner_list()->get(iy->value()); + return list->get(iy->value()); } /* @@ -329,7 +357,7 @@ ListIteratorKlass* ListIteratorKlass::get_instance() { } ListIteratorKlass::ListIteratorKlass() { - HiDict* klass_dict = new HiDict(); + HiDict* klass_dict = HiDict::new_instance(); klass_dict->put(new HiString("next"), new FunctionObject(listiterator_next)); set_klass_dict(klass_dict); @@ -346,7 +374,7 @@ HiObject* listiterator_next(ObjList args) { HiList* alist = iter->owner(); int iter_cnt = iter->iter_cnt(); - if (iter_cnt < alist->inner_list()->size()) { + if (iter_cnt < alist->size()) { HiObject* obj = alist->get(iter_cnt); iter->inc_cnt(); return obj; @@ -357,8 +385,9 @@ HiObject* listiterator_next(ObjList args) { HiObject* ListKlass::allocate_instance(HiObject* callable, ArrayList* args) { - if (!args || args->length() == 0) - return new HiList(); + if (!args || args->length() == 0) { + return HiList::new_instance(); + } else return new HiList(args); } diff --git a/src/main/vm/object/hiList.hpp b/src/main/vm/object/hiList.hpp index c3107c0..2030c55 100644 --- a/src/main/vm/object/hiList.hpp +++ b/src/main/vm/object/hiList.hpp @@ -42,19 +42,24 @@ friend class ListKlass; private: ArrayList* _inner_list; - -public: HiList(); HiList(ObjList ol); - ArrayList* inner_list() { return _inner_list; } - int size() { return _inner_list->size(); } - void append(HiObject* obj) { _inner_list->add(obj); } +public: + static HiList* new_instance(int n = 8); + static HiList* new_instance(ArrayList* lst); + + int size(); + void append(HiObject* obj); + void set(int i, HiObject* o); + HiObject* pop() { return _inner_list->pop(); } HiObject* get(int index) { return _inner_list->get(index); } - void set(int i, HiObject* o) { _inner_list->set(i, o); } HiObject* top() { return get(size() - 1); } + ArrayList* inner_list() { return _inner_list; } + void set_inner_list(ArrayList* lst) { _inner_list = lst; } + // used by internal int index(HiObject* obj); void delete_index(int index) { _inner_list->delete_index(index); } diff --git a/src/main/vm/object/hiLong.cpp b/src/main/vm/object/hiLong.cpp index eaed7a9..91745ba 100644 --- a/src/main/vm/object/hiLong.cpp +++ b/src/main/vm/object/hiLong.cpp @@ -2,7 +2,7 @@ #include "object/hiDict.hpp" #include "object/hiDouble.hpp" #include "object/hiString.hpp" -#include "object/HiLong.hpp" +#include "object/hiLong.hpp" #include "runtime/universe.hpp" #include @@ -14,7 +14,7 @@ LongKlass::LongKlass() { } void LongKlass::initialize() { - set_klass_dict(new HiDict()); + set_klass_dict(HiDict::new_instance()); set_name(new HiString("int")); (new HiTypeObject())->set_own_klass(this); add_super(ObjectKlass::get_instance()); @@ -37,7 +37,7 @@ void LongKlass::print(HiObject* obj) { assert(long_obj && (long_obj->klass()) == this); - printf("%ld", long_obj->value()); + printf("%lld", long_obj->value()); } HiObject* LongKlass::allocate_instance(HiObject* callable, diff --git a/src/main/vm/object/hiObject.cpp b/src/main/vm/object/hiObject.cpp index 1e801de..ebd520b 100644 --- a/src/main/vm/object/hiObject.cpp +++ b/src/main/vm/object/hiObject.cpp @@ -182,7 +182,7 @@ void HiTypeObject::set_own_klass(Klass* k) { } void HiObject::init_dict() { - _obj_dict = new HiDict(); + _obj_dict = HiDict::new_instance(); } /* diff --git a/src/main/vm/object/hiString.cpp b/src/main/vm/object/hiString.cpp index fccd0d8..a281922 100644 --- a/src/main/vm/object/hiString.cpp +++ b/src/main/vm/object/hiString.cpp @@ -22,7 +22,7 @@ StringKlass::StringKlass() { void StringKlass::initialize() { (new HiTypeObject())->set_own_klass(this); - HiDict* klass_dict = new HiDict(); + HiDict* klass_dict = HiDict::new_instance(); klass_dict->put(new HiString("upper"), new FunctionObject(string_upper)); klass_dict->put(new HiString("join"), new FunctionObject(string_join)); set_klass_dict(klass_dict); diff --git a/src/main/vm/object/hiTuple.cpp b/src/main/vm/object/hiTuple.cpp index bfaf543..72666a6 100644 --- a/src/main/vm/object/hiTuple.cpp +++ b/src/main/vm/object/hiTuple.cpp @@ -7,6 +7,7 @@ #include "runtime/universe.hpp" #include "runtime/functionObject.hpp" #include "memory/oopClosure.hpp" +#include "memory/heap.hpp" #include TupleKlass* TupleKlass::instance = NULL; @@ -22,7 +23,7 @@ TupleKlass::TupleKlass() { } void TupleKlass::initialize() { - HiDict * klass_dict = new HiDict(); + HiDict * klass_dict = HiDict::new_instance(); klass_dict->put(new HiString("index"), new FunctionObject(tuple_index)); klass_dict->put(new HiString("__getitem__"), @@ -158,7 +159,7 @@ HiObject* TupleKlass::less(HiObject* x, HiObject* y) { HiTuple::HiTuple() { set_klass(TupleKlass::get_instance()); - _inner_list = new ArrayList(); + _inner_list = NEW_ARRAYLIST(HiObject*, 8); } HiTuple::HiTuple(ObjList ol) { @@ -213,7 +214,7 @@ TupleIteratorKlass* TupleIteratorKlass::get_instance() { } TupleIteratorKlass::TupleIteratorKlass() { - HiDict* klass_dict = new HiDict(); + HiDict* klass_dict = HiDict::new_instance(); klass_dict->put(new HiString("next"), new FunctionObject(tupleiterator_next)); set_klass_dict(klass_dict); diff --git a/src/main/vm/object/klass.cpp b/src/main/vm/object/klass.cpp index 161df89..f55ddc8 100644 --- a/src/main/vm/object/klass.cpp +++ b/src/main/vm/object/klass.cpp @@ -11,6 +11,7 @@ #include "object/hiString.hpp" #include "memory/heap.hpp" #include "memory/oopClosure.hpp" +#include "util/handles.hpp" #define ST(x) StringTable::get_instance()->STR(x) #define STR(x) x##_str @@ -65,29 +66,32 @@ HiObject* Klass::create_klass(HiObject* x, HiObject* supers, HiObject* name) { } HiObject* Klass::allocate_instance(HiObject* callable, ArrayList* args) { - HiObject* inst = NULL; + Handle inst(NULL); + Handle h_callable((HiTypeObject*)callable); + Handle*> h_args(args); + if (_mro->index(IntegerKlass::get_instance()->type_object()) >= 0) inst = new HiInteger(0); else if (_mro->index(StringKlass::get_instance()->type_object()) >= 0) inst = new HiString(""); else if (_mro->index(ListKlass::get_instance()->type_object()) >= 0) - inst = new HiList(); + inst = HiList::new_instance(8); else if (_mro->index(DictKlass::get_instance()->type_object()) >= 0) - inst = new HiDict(); + inst = HiDict::new_instance(); else inst = new HiObject(); - inst->set_klass(((HiTypeObject*)callable)->own_klass()); + inst->set_klass(((HiTypeObject*)h_callable())->own_klass()); HiObject* constructor = inst->get_klass_attr(ST(init)); if (constructor != Universe::HiNone) { - Interpreter::get_instance()->call_virtual(constructor, args); + Interpreter::get_instance()->call_virtual(constructor, h_args()); } - return inst; + return inst(); } HiObject* Klass::add(HiObject* lhs, HiObject* rhs) { - ObjList args = new ArrayList(); + ObjList args = NEW_ARRAYLIST(HiObject*, 1); args->add(rhs); return find_and_call(lhs, args, ST(add)); } @@ -110,13 +114,14 @@ HiObject* Klass::len(HiObject* x) { } HiObject* Klass::subscr(HiObject* x, HiObject* y) { - ObjList args = new ArrayList(); + ObjList args = NEW_ARRAYLIST(HiObject*, 1); args->add(y); return find_and_call(x, args, ST(getitem)); } void Klass::store_subscr(HiObject* x, HiObject* y, HiObject* z) { - ObjList args = new ArrayList(); + ObjList args = NEW_ARRAYLIST(HiObject*, 2); + args->add(y); args->add(y); args->add(z); find_and_call(x, args, ST(setitem)); @@ -138,7 +143,7 @@ HiObject* Klass::getattr(HiObject* x, HiObject* y) { HiObject* func = find_in_parents(x, ST(getattr)); if (func->klass() == FunctionKlass::get_instance()) { func = new MethodObject((FunctionObject*)func, x); - ObjList args = new ArrayList(); + ObjList args = NEW_ARRAYLIST(HiObject*, 1); args->add(y); return Interpreter::get_instance()->call_virtual(func, args); } @@ -158,7 +163,7 @@ HiObject* Klass::setattr(HiObject* x, HiObject* y, HiObject* z) { HiObject* func = x->klass()->klass_dict()->get(ST(setattr)); if (func->klass() == FunctionKlass::get_instance()) { func = new MethodObject((FunctionObject*)func, x); - ObjList args = new ArrayList(); + ObjList args = NEW_ARRAYLIST(HiObject*, 2); args->add(y); args->add(z); return Interpreter::get_instance()->call_virtual(func, args); @@ -173,8 +178,9 @@ HiObject* Klass::setattr(HiObject* x, HiObject* y, HiObject* z) { } void Klass::add_super(Klass* klass) { - if (_super == NULL) - _super = new HiList(); + if (_super == NULL) { + _super = HiList::new_instance(8); + } _super->append(klass->type_object()); } @@ -201,8 +207,9 @@ void Klass::order_supers() { if (_super == NULL) return; - if (_mro == NULL) - _mro = new HiList(); + if (_mro == NULL) { + _mro = HiList::new_instance(8); + } int cur = -1; for (int i = 0; i < _super->size(); i++) { diff --git a/src/main/vm/runtime/cellObject.cpp b/src/main/vm/runtime/cellObject.cpp index 43a8bd9..d945e68 100644 --- a/src/main/vm/runtime/cellObject.cpp +++ b/src/main/vm/runtime/cellObject.cpp @@ -15,7 +15,7 @@ CellKlass* CellKlass::get_instance() { } CellKlass::CellKlass() { - set_klass_dict(new HiDict()); + set_klass_dict(HiDict::new_instance()); set_name(new HiString("cell")); } diff --git a/src/main/vm/runtime/frameObject.cpp b/src/main/vm/runtime/frameObject.cpp index ce2bab5..46ab139 100644 --- a/src/main/vm/runtime/frameObject.cpp +++ b/src/main/vm/runtime/frameObject.cpp @@ -1,109 +1,145 @@ #include "runtime/frameObject.hpp" #include "runtime/functionObject.hpp" +#include "runtime/universe.hpp" #include "object/hiString.hpp" #include "object/hiList.hpp" #include "object/hiDict.hpp" #include "memory/oopClosure.hpp" +#include "memory/heap.hpp" +#include "util/handles.hpp" + +FrameObject::FrameObject() { + _func = NULL; + _args = NULL; + + _consts = NULL; + _names = NULL; + + _locals = NULL; + _globals = NULL; + _fast_locals = NULL; + _closure = NULL; + + _stack = NULL; + _loop_stack = NULL; + + _codes = NULL; + _pc = 0; + _sender = NULL; + _entry_frame = false; +} // this constructor is used for module only. FrameObject::FrameObject(CodeObject* codes) { + _func = NULL; + _args = NULL; + + _codes = codes; _consts = codes->_consts; _names = codes->_names; - _locals = new HiDict(); + /* Attention: never user 'codes' after allocation, because of gc */ + /* unless you use Handle to hold the pointer.*/ + _locals = HiDict::new_instance(); _globals = _locals; _fast_locals = NULL; _closure = NULL; - _stack = new HiList(); - _loop_stack = new ArrayList(); + _stack = HiList::new_instance(8); + _loop_stack = NEW_ARRAYLIST(Block, 8); - _codes = codes; _pc = 0; _sender = NULL; _entry_frame = false; } -FrameObject::FrameObject (FunctionObject* func, ObjList args, int op_arg) { +void FrameObject::initialize (FunctionObject* func, ObjList args, int op_arg) { assert((args && op_arg != 0) || (args == NULL && op_arg == 0)); - _codes = func->_func_code; + _func = func; + _args = args; + + _codes = _func->_func_code; _consts = _codes->_consts; _names = _codes->_names; - _locals = new HiDict(); - _globals = func->_globals; - _fast_locals = new HiList(); + _locals = HiDict::new_instance(); + _globals = _func->_globals; + _fast_locals = HiList::new_instance(8); + const int argcnt = _codes->_argcount; const int na = op_arg & 0xff; const int nk = op_arg >> 8; int kw_pos = argcnt; - if (func->_defaults) { - int dft_num = func->_defaults->length(); + if (_func->_defaults) { + int dft_num = _func->_defaults->length(); int arg_num = _codes->_argcount; while (dft_num--) { - _fast_locals->set(--arg_num, func->_defaults->get(dft_num)); + _fast_locals->set(--arg_num, _func->_defaults->get(dft_num)); } } - HiList* alist = NULL; - HiDict* adict = NULL; + Handle alist(NULL); + Handle adict(NULL); if (argcnt < na) { int i = 0; for (; i < argcnt; i++) { - _fast_locals->set(i, args->get(i)); + _fast_locals->set(i, _args->get(i)); } - alist = new HiList(); + + alist = HiList::new_instance(8); for (; i < na; i++) { - alist->append(args->get(i)); + alist->append(_args->get(i)); } } else { for (int i = 0; i < na; i++) { - _fast_locals->set(i, args->get(i)); + _fast_locals->set(i, _args->get(i)); } } for (int i = 0; i < nk; i++) { - HiObject* key = args->get(na + i * 2); - HiObject* val = args->get(na + i * 2 + 1); + Handle key(_args->get(na + i * 2)); + Handle val(_args->get(na + i * 2 + 1)); - int index = _codes->_var_names->index(key); + int index = _codes->_var_names->index(key()); if (index >= 0) { - _fast_locals->set(index, val); + _fast_locals->set(index, val()); } else { - if (adict == NULL) - adict = new HiDict(); + if (adict() == NULL) + adict = HiDict::new_instance(); - adict->put(key, val); + adict->put(key(), val()); } } if (_codes->_flag & FunctionObject::CO_VARARGS) { - if (alist == NULL) - alist = new HiList(); - _fast_locals->set(argcnt, alist); + if (alist() == NULL) { + alist = HiList::new_instance(8); + } + + _fast_locals->set(argcnt, alist()); kw_pos += 1; } else { // give more parameters than need. - if (alist != NULL) { + if (alist() != NULL) { printf("takes more extend parameters.\n"); assert(false); } } if (_codes->_flag & FunctionObject::CO_VARKEYWORDS) { - if (adict == NULL) - adict = new HiDict(); + if (adict() == NULL) + adict = HiDict::new_instance(); - _fast_locals->set(kw_pos, adict); + _fast_locals->set(kw_pos, adict()); } else { - if (adict != NULL) { + if (adict() != NULL) { printf("takes more extend kw parameters.\n"); assert(false); } @@ -111,29 +147,25 @@ FrameObject::FrameObject (FunctionObject* func, ObjList args, int op_arg) { _closure = NULL; - ArrayList* cells = _codes->_cell_vars; - if (cells && cells->size() > 0) { - _closure = new HiList(); + Handle cells(_codes->_cell_vars); + if (cells() && cells->size() > 0) { + _closure = HiList::new_instance(8); for (int i = 0; i < cells->size(); i++) { _closure->append(NULL); } } - if (func->closure() && func->closure()->size() > 0) { + if (_func->closure() && _func->closure()->size() > 0) { if (_closure == NULL) - _closure = func->closure(); + _closure = _func->closure(); else { - _closure = (HiList*)_closure->add(func->closure()); + _closure = (HiList*)_closure->add(_func->closure()); } } - _stack = new HiList(); - _loop_stack = new ArrayList(); - - _pc = 0; - _sender = NULL; - _entry_frame = false; + _stack = HiList::new_instance(8); + _loop_stack = NEW_ARRAYLIST(Block, 8); } int FrameObject::get_op_arg() { @@ -151,6 +183,9 @@ bool FrameObject::has_more_codes() { } void FrameObject::oops_do(OopClosure* f) { + f->do_oop((HiObject**)&_func); + f->do_array_list(&_args); + f->do_array_list(&_consts); f->do_array_list(&_names); diff --git a/src/main/vm/runtime/frameObject.hpp b/src/main/vm/runtime/frameObject.hpp index a9b5151..1f241da 100644 --- a/src/main/vm/runtime/frameObject.hpp +++ b/src/main/vm/runtime/frameObject.hpp @@ -42,10 +42,15 @@ public: class FrameObject { public: + FrameObject(); FrameObject(CodeObject* codes); - FrameObject(FunctionObject* func, ObjList args, int op_arg); ~FrameObject() {}; + void initialize(FunctionObject* func, ObjList args, int op_arg); + + FunctionObject* _func; + ArrayList* _args; + HiList* _stack; ArrayList* _loop_stack; diff --git a/src/main/vm/runtime/functionObject.cpp b/src/main/vm/runtime/functionObject.cpp index 93daed7..f352f83 100644 --- a/src/main/vm/runtime/functionObject.cpp +++ b/src/main/vm/runtime/functionObject.cpp @@ -19,7 +19,7 @@ FunctionKlass* FunctionKlass::get_instance() { FunctionKlass::FunctionKlass() { add_super(ObjectKlass::get_instance()); set_name(new HiString("function")); - set_klass_dict(new HiDict()); + set_klass_dict(HiDict::new_instance()); HiTypeObject* tp_obj = new HiTypeObject(); tp_obj->set_own_klass(this); } @@ -77,7 +77,7 @@ void FunctionObject::set_default(ArrayList* defaults) { return; } - _defaults = new ArrayList(defaults->length()); + _defaults = NEW_ARRAYLIST(HiObject*, _defaults->length()); for (int i = 0; i < defaults->length(); i++) { _defaults->set(i, defaults->get(i)); @@ -100,7 +100,7 @@ NativeFunctionKlass* NativeFunctionKlass::get_instance() { NativeFunctionKlass::NativeFunctionKlass() { add_super(FunctionKlass::get_instance()); set_name(new HiString("native function")); - set_klass_dict(new HiDict()); + set_klass_dict(HiDict::new_instance()); HiTypeObject* tp_obj = new HiTypeObject(); tp_obj->set_own_klass(this); } diff --git a/src/main/vm/runtime/generator.cpp b/src/main/vm/runtime/generator.cpp index dd0f258..c089a92 100644 --- a/src/main/vm/runtime/generator.cpp +++ b/src/main/vm/runtime/generator.cpp @@ -42,7 +42,8 @@ void GeneratorKlass::oops_do(OopClosure* f, HiObject* obj) { } Generator::Generator(FunctionObject* func, ArrayList* args, int arg_cnt) { - _frame = new FrameObject(func, args, arg_cnt); + _frame = new FrameObject(); + _frame->initialize(func, args, arg_cnt); set_klass(GeneratorKlass::get_instance()); } diff --git a/src/main/vm/runtime/interpreter.cpp b/src/main/vm/runtime/interpreter.cpp index 51b6dff..0a47ee4 100644 --- a/src/main/vm/runtime/interpreter.cpp +++ b/src/main/vm/runtime/interpreter.cpp @@ -17,6 +17,7 @@ #include "object/hiDict.hpp" #include "object/hiFile.hpp" #include "memory/oopClosure.hpp" +#include "memory/heap.hpp" #include #include @@ -52,7 +53,7 @@ Interpreter::Interpreter() { _int_status = IS_OK; // prepare for import builtin, this should be created first - _builtins = new ModuleObject(new HiDict()); + _builtins = new ModuleObject(HiDict::new_instance()); _builtins->put(new HiString("object"), ObjectKlass::get_instance()->type_object()); _builtins->put(new HiString("True"), Universe::HiTrue); _builtins->put(new HiString("False"), Universe::HiFalse); @@ -80,7 +81,7 @@ void Interpreter::initialize() { _builtins->extend(ModuleObject::import_module(new HiString("builtin"))); Universe::stop_iteration = _builtins->get(new HiString("StopIteration")); - _modules = new HiDict(); + _modules = HiDict::new_instance(); _modules->put(new HiString("__builtins__"), _builtins); } @@ -93,7 +94,7 @@ void Interpreter::build_frame(HiObject* callable, ObjList args, int op_arg) { // return value is ignored here, because they are handled // by other pathes. if (!args) { - args = new ArrayList(1); + args = NEW_ARRAYLIST(HiObject*, 1); } args->insert(0, method->owner()); build_frame(method->func(), args, op_arg + 1); @@ -104,9 +105,14 @@ void Interpreter::build_frame(HiObject* callable, ObjList args, int op_arg) { return; } else if (callable->klass() == FunctionKlass::get_instance()) { - FrameObject* frame = new FrameObject((FunctionObject*) callable, args, op_arg); + FrameObject* frame = new FrameObject(); frame->set_sender(_frame); _frame = frame; + /* + * GC may occur in initialization of FrameObject, + * do init after linking new frame in. + */ + _frame->initialize((FunctionObject*) callable, args, op_arg); } else if (callable->klass() == TypeKlass::get_instance()) { HiObject* inst = ((HiTypeObject*)callable)->own_klass()-> @@ -137,25 +143,33 @@ void Interpreter::destroy_frame() { } HiObject* Interpreter::call_virtual(HiObject* func, ObjList args) { - if (func->klass() == NativeFunctionKlass::get_instance()) { + Handle h_func(func); + Handle h_args(args); + + if (h_func->klass() == NativeFunctionKlass::get_instance()) { // we do not create a virtual frame, but native frame. - return ((FunctionObject*)func)->call(args); + return ((FunctionObject*)h_func())->call(h_args()); } - else if (func->klass() == MethodKlass::get_instance()) { - MethodObject* method = (MethodObject*) func; - if (!args) { - args = new ArrayList(1); + else if (h_func->klass() == MethodKlass::get_instance()) { + if (!h_args()) { + h_args = NEW_ARRAYLIST(HiObject*, 1); } - args->insert(0, method->owner()); - return call_virtual(method->func(), args); + h_args->insert(0, ((MethodObject*)h_func())->owner()); + return call_virtual(((MethodObject*)h_func())->func(), h_args()); } - else if (MethodObject::is_function(func)) { - int size = args ? args->size() : 0; - FrameObject* frame = new FrameObject((FunctionObject*) func, args, size); - frame->set_entry_frame(true); + else if (MethodObject::is_function(h_func())) { + int size = h_args() ? h_args()->size() : 0; + + FrameObject* frame = new FrameObject(); + enter_frame(frame); + _frame->initialize((FunctionObject*) h_func(), h_args(), size); + _frame->set_entry_frame(true); + eval_frame(); + destroy_frame(); + return _ret_value; } @@ -451,7 +465,7 @@ void Interpreter::eval_frame() { fo->set_closure((HiList*)(POP())); fo->set_globals(_frame->globals()); if (op_arg > 0) { - args = new ArrayList(op_arg); + args = NEW_ARRAYLIST(HiObject*, op_arg); while (op_arg--) { args->set(op_arg, POP()); } @@ -472,7 +486,7 @@ void Interpreter::eval_frame() { fo = new FunctionObject(v); fo->set_globals(_frame->globals()); if (op_arg > 0) { - args = new ArrayList(op_arg); + args = NEW_ARRAYLIST(HiObject*, op_arg); while (op_arg--) { args->set(op_arg, POP()); } @@ -491,7 +505,7 @@ void Interpreter::eval_frame() { int na = op_arg & 0xff; int nk = op_arg >> 8; int arg_cnt = na + 2 * nk; - args = new ArrayList(arg_cnt); + args = NEW_ARRAYLIST(HiObject*, arg_cnt); while (arg_cnt--) { args->set(arg_cnt, POP()); } @@ -692,7 +706,7 @@ void Interpreter::eval_frame() { break; case ByteCode::BUILD_LIST: - v = new HiList(); + v = HiList::new_instance(8); while (op_arg--) { ((HiList*)v)->set(op_arg, POP()); } @@ -700,7 +714,7 @@ void Interpreter::eval_frame() { break; case ByteCode::BUILD_MAP: - v = new HiDict(); + v = HiDict::new_instance(); PUSH(v); break; @@ -778,7 +792,7 @@ void Interpreter::eval_frame() { int na = op_arg & 0xff; int nk = op_arg >> 8; int arg_cnt = na + 2 * nk; - args = new ArrayList(); + args = NEW_ARRAYLIST(HiObject*, 8); while (arg_cnt--) { args->set(arg_cnt, POP()); } @@ -933,7 +947,7 @@ Interpreter::Status Interpreter::do_raise(HiObject* exc, HiObject* val, HiObject } HiObject* Interpreter::eval_generator(Generator* g) { - Handle handle(g); + Handle handle(g); enter_frame(g->frame()); g->frame()->set_entry_frame(true); eval_frame(); diff --git a/src/main/vm/runtime/module.cpp b/src/main/vm/runtime/module.cpp index c06c352..3cc2261 100644 --- a/src/main/vm/runtime/module.cpp +++ b/src/main/vm/runtime/module.cpp @@ -7,6 +7,7 @@ #include "util/bufferedInputStream.hpp" #include "code/binaryFileParser.hpp" #include "memory/oopClosure.hpp" +#include "memory/heap.hpp" #include "inc/railgun.hpp" #include @@ -28,7 +29,7 @@ ModuleKlass::ModuleKlass() { } void ModuleKlass::initialize() { - HiDict* dict = new HiDict(); + HiDict* dict = HiDict::new_instance(); set_klass_dict(dict); set_name(new HiString("module")); (new HiTypeObject())->set_own_klass(this); @@ -43,7 +44,7 @@ ModuleObject::ModuleObject(HiDict* dict) { ModuleObject* ModuleObject::import_module(HiObject* x) { HiString* mod_name = (HiString*)x; - HiList* so_list = new HiList(); + HiList* so_list = HiList::new_instance(3); so_list->append(ST(libdir_pre)); so_list->append(mod_name); so_list->append(ST(so_suf)); @@ -55,7 +56,7 @@ ModuleObject* ModuleObject::import_module(HiObject* x) { file_name = (HiString*)(mod_name->add(ST(pyc_suf))); if (access(file_name->value(), R_OK) == -1) { - HiList* pyc_list = new HiList(); + HiList* pyc_list = HiList::new_instance(3); pyc_list->append(ST(libdir_pre)); pyc_list->append(mod_name); pyc_list->append(ST(pyc_suf)); @@ -115,11 +116,11 @@ ModuleObject* ModuleObject::import_so(HiString* mod_name) { } RGMethod* ml = init_func(); - ModuleObject* mod = new ModuleObject(new HiDict()); + ModuleObject* mod = new ModuleObject(HiDict::new_instance()); for (; ml->meth_name != NULL; ml++) { mod->put(new HiString(ml->meth_name), new FunctionObject(ml->meth)); } return mod; -} \ No newline at end of file +} diff --git a/src/main/vm/runtime/traceback.cpp b/src/main/vm/runtime/traceback.cpp index 72d9a0a..eae8e0b 100644 --- a/src/main/vm/runtime/traceback.cpp +++ b/src/main/vm/runtime/traceback.cpp @@ -2,7 +2,9 @@ #include "object/hiList.hpp" #include "runtime/traceback.hpp" #include "runtime/frameObject.hpp" +#include "runtime/universe.hpp" #include "memory/oopClosure.hpp" +#include "memory/heap.hpp" StackElementKlass* StackElementKlass::_instance = NULL; TracebackKlass* TracebackKlass::_instance = NULL; @@ -69,7 +71,7 @@ size_t TracebackKlass::size() { } Traceback::Traceback() { - _stack_elements = new HiList(); + _stack_elements = HiList::new_instance(8); set_klass(TracebackKlass::get_instance()); } diff --git a/src/main/vm/runtime/universe.cpp b/src/main/vm/runtime/universe.cpp index 3a0866e..2fa50b4 100644 --- a/src/main/vm/runtime/universe.cpp +++ b/src/main/vm/runtime/universe.cpp @@ -24,7 +24,7 @@ ArrayList* Universe::klasses = NULL; void Universe::genesis() { heap = Heap::get_instance(); - klasses = new ArrayList(); + klasses = NEW_ARRAYLIST(Klass*, 8); HiTrue = new HiString("True"); HiFalse = new HiString("False"); @@ -51,8 +51,8 @@ void Universe::genesis() { TupleKlass::get_instance()->initialize(); ModuleKlass::get_instance()->initialize(); - type_klass->set_klass_dict(new HiDict()); - object_klass->set_klass_dict(new HiDict()); + type_klass->set_klass_dict(HiDict::new_instance()); + object_klass->set_klass_dict(HiDict::new_instance()); type_klass->set_name(new HiString("type")); object_klass->set_name(new HiString("object")); diff --git a/src/main/vm/util/arrayList.cpp b/src/main/vm/util/arrayList.cpp index 81636d0..58291fb 100644 --- a/src/main/vm/util/arrayList.cpp +++ b/src/main/vm/util/arrayList.cpp @@ -8,10 +8,9 @@ #include template -ArrayList::ArrayList(int n) { +ArrayList::ArrayList(int n, void* temp) { _length = n; _size = 0; - void* temp = Universe::heap->allocate(sizeof(T) * n); _array = new(temp)T[n]; } diff --git a/src/main/vm/util/arrayList.hpp b/src/main/vm/util/arrayList.hpp index d8bf142..706a9d1 100644 --- a/src/main/vm/util/arrayList.hpp +++ b/src/main/vm/util/arrayList.hpp @@ -15,7 +15,7 @@ private: void expand(); public: - ArrayList(int n = 8); + ArrayList(int n, void* temp); void add(T t); void insert(int index, T t); @@ -37,4 +37,7 @@ public: class HiObject; typedef ArrayList* ObjList; +#define NEW_ARRAYLIST(T, size) \ + new ArrayList((size), Universe::heap->allocate(sizeof(T)*(size))) + #endif diff --git a/src/main/vm/util/handles.cpp b/src/main/vm/util/handles.cpp index 6e82a30..6ce7a82 100644 --- a/src/main/vm/util/handles.cpp +++ b/src/main/vm/util/handles.cpp @@ -1,4 +1,6 @@ #include "util/handles.hpp" +#include "object/hiList.hpp" +#include "object/hiDict.hpp" #include "memory/oopClosure.hpp" #include @@ -17,36 +19,86 @@ HandleMark* HandleMark::get_instance() { } void HandleMark::oops_do(OopClosure* f) { - Handle* cur = _head; + LinkedList* cur = _head; while (cur) { cur->oops_do(f); cur = cur->_next; } } -Handle::Handle(HiObject* t) { - _value = t; +void HandleMark::set_head(LinkedList* node) { + if (_head) { + _head->_prev = node; + } + node->_next = _head; + _head = node; +} + +void HandleMark::del_handle(LinkedList* node) { + LinkedList* prev = node->_prev; + LinkedList* next = node->_next; + + if (prev) { + prev->_next = next; + } + + if (next) { + next->_prev = prev; + } + + if (_head == node) { + _head = next; + } +} - _next = HandleMark::get_instance()->head(); +LinkedList::LinkedList() { + _next = NULL; + _prev = NULL; +} + +template +Handle::Handle(T t) : LinkedList() { + _value = t; HandleMark::get_instance()->set_head(this); } -Handle::~Handle() { +template +Handle::~Handle() { _value = 0x0; - - HandleMark::get_instance()->set_head(_next); - _next = 0x0; + HandleMark::get_instance()->del_handle(this); } -HiObject* Handle::operator ->() { +template +T Handle::operator ->() { return _value; } -void Handle::oops_do(OopClosure* f) { - f->do_oop(&_value); +template +void Handle::oops_do(OopClosure* f) { + f->do_oop((HiObject**)&_value); } -HiObject* Handle::resolve() { - return _value; +template<> +void Handle*>::oops_do(OopClosure* f) { + f->do_array_list(&_value); } +class HiObject; +template class Handle; + +class HiString; +template class Handle; + +class HiList; +template class Handle; + +class HiDict; +template class Handle; + +class Generator; +template class Handle; + +class HiTypeObject; +template class Handle; + +template class Handle*>; diff --git a/src/main/vm/util/handles.hpp b/src/main/vm/util/handles.hpp index f183cd2..5318ce0 100644 --- a/src/main/vm/util/handles.hpp +++ b/src/main/vm/util/handles.hpp @@ -3,35 +3,52 @@ class HiObject; class OopClosure; +class HiList; +class HiDict; -class Handle { +template +class ArrayList; + +class LinkedList { friend class HandleMark; private: - HiObject* _value; - Handle* _next; + LinkedList* _next; + LinkedList* _prev; public: - Handle(HiObject* t); + LinkedList(); + + virtual void oops_do(OopClosure* f) = 0; +}; + +template +class Handle : public LinkedList { +protected: + T _value; + +public: + Handle(T t); ~Handle(); - void oops_do(OopClosure* f); - HiObject* operator ->(); - HiObject* operator ()() { return _value; } - HiObject* resolve(); + virtual void oops_do(OopClosure* f); + T operator ->(); + T operator ()() { return _value; } + void operator =(T v) { _value = v; } }; class HandleMark { private: static HandleMark* instance; - Handle* _head; + LinkedList* _head; public: HandleMark(); static HandleMark* get_instance(); void oops_do(OopClosure* f); - Handle* head() { return _head; } - void set_head(Handle* x) { _head = x; } + LinkedList* head() { return _head; } + void set_head(LinkedList* x); + void del_handle(LinkedList* x); }; #endif diff --git a/src/test/hilang/function.hi b/src/test/hilang/function.hi index 79cb8ee..b46709d 100644 --- a/src/test/hilang/function.hi +++ b/src/test/hilang/function.hi @@ -12,7 +12,20 @@ func fact(n) { } } -hassert(fact(6) == 720, "wrong calculation in fact"); +i = 0; +# test gc +while (i < 100000) { + n = fact(6); + if (n != 720) { + print(n); + } + hassert(n == 720, "wrong calculation in fact"); + i += 1; + + if (i % 1000 == 0) { + print(i); + } +} func fib(n) { i = 0; @@ -30,4 +43,4 @@ func fib(n) { fib(10); -hassert(False, "I hope line no is 33"); +hassert(False, "I hope line no is 46"); -- Gitee