Zxc200611/pocketpy
1
0
Fork 0
mirror of https://github.com/pocketpy/pocketpy synced 2025-11-09 21:20:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

WIP: added some more functionality -> changed int to arbitrary objects

Browse Source
This commit is contained in:
S. Mahmudul Hasan 2023-10-10 05:17:00 -04:00
parent 795c7b65c6
commit 836f0506fa
2 changed files with 288 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
include/pocketpy/collections.h
View File

@ -9,35 +9,37 @@
namespace pkpy namespace pkpy
{ {
struct DequeNode{ struct DequeNode
int obj; //TODO: change to PyObject* {
DequeNode* prev; PyObject *obj;
DequeNode* next; DequeNode *prev;
DequeNode(){ DequeNode *next;
this->obj = -1; // ignored value DequeNode()
{
this->obj = nullptr; // ignored value, sentinnel
this->prev = nullptr; this->prev = nullptr;
this->next = nullptr; this->next = nullptr;
} }
DequeNode(int obj){ DequeNode(PyObject *obj)
{
this->obj = obj; this->obj = obj;
this->prev = nullptr; this->prev = nullptr;
this->next = nullptr; this->next = nullptr;
} }
~DequeNode(){
}
void printNode(){ ~DequeNode()
printf("%d ", this->obj); {
} }
}; };
struct MyDoublyLinkedList{ struct MyDoublyLinkedList
{
int len; int len;
DequeNode* head; DequeNode *head;
DequeNode* tail; DequeNode *tail;
MyDoublyLinkedList(){ //creates an empty list MyDoublyLinkedList()
{ // creates an empty list
this->len = 0; this->len = 0;
this->head = new DequeNode(); // dummy this->head = new DequeNode(); // dummy
this->tail = new DequeNode(); // dummy this->tail = new DequeNode(); // dummy
@ -45,21 +47,25 @@ namespace pkpy
this->tail->prev = this->head; this->tail->prev = this->head;
} }
~MyDoublyLinkedList(){ ~MyDoublyLinkedList()
if(this->head == nullptr) return; {
if (this->head == nullptr)
return;
this->makeListEmpty(); this->makeListEmpty();
delete this->head; delete this->head;
delete this->tail; delete this->tail;
} }
void push_back(DequeNode* node){ void push_back(DequeNode *node)
{
node->prev = this->tail->prev; node->prev = this->tail->prev;
node->next = this->tail; node->next = this->tail;
this->tail->prev->next = node; this->tail->prev->next = node;
this->tail->prev = node; this->tail->prev = node;
this->len++; this->len++;
} }
void push_front(DequeNode* node){ void push_front(DequeNode *node)
{
node->prev = this->head; node->prev = this->head;
node->next = this->head->next; node->next = this->head->next;
this->head->next->prev = node; this->head->next->prev = node;
@ -67,27 +73,34 @@ namespace pkpy
this->len++; this->len++;
} }
DequeNode* pop_back(){ DequeNode *pop_back()
if(this->empty()) throw std::runtime_error("DoubleLinkedList::pop_back() called on empty list"); {
DequeNode* node = this->tail->prev; if (this->empty())
throw std::runtime_error("DoubleLinkedList::pop_back() called on empty list");
DequeNode *node = this->tail->prev;
this->tail->prev->prev->next = this->tail; this->tail->prev->prev->next = this->tail;
this->tail->prev = this->tail->prev->prev; this->tail->prev = this->tail->prev->prev;
this->len--; this->len--;
return node; return node;
} }
DequeNode* pop_front(){ DequeNode *pop_front()
if(this->empty()) throw std::runtime_error("DoubleLinkedList::pop_front() called on empty list"); {
DequeNode* node = this->head->next; if (this->empty())
throw std::runtime_error("DoubleLinkedList::pop_front() called on empty list");
DequeNode *node = this->head->next;
this->head->next->next->prev = this->head; this->head->next->next->prev = this->head;
this->head->next = this->head->next->next; this->head->next = this->head->next->next;
this->len--; this->len--;
return node; return node;
} }
bool empty() const { bool empty() const
if(this->len == 0){ {
if(this->head->next != this->tail || this->tail->prev != this->head){ if (this->len == 0)
{
if (this->head->next != this->tail || this->tail->prev != this->head)
{
throw std::runtime_error("DoubleLinkedList::size() returned 0 but the list is not empty"); throw std::runtime_error("DoubleLinkedList::size() returned 0 but the list is not empty");
} }
return true; return true;
@ -95,60 +108,68 @@ namespace pkpy
return false; return false;
} }
int count(int obj){ // TODO: change to PyObject* int count(VM *vm, PyObject *obj)
{
int cnt = 0; int cnt = 0;
DequeNode* p = this->head->next; DequeNode *p = this->head->next;
while(p != this->tail){ while (p != this->tail)
if(p->obj == obj) cnt++; {
if (vm->py_equals(p->obj, obj))
cnt++;
p = p->next; p = p->next;
} }
return cnt; return cnt;
} }
void makeListEmpty(){ int size() const
while(!this->empty()){ {
return this->len;
}
void makeListEmpty()
{
while (!this->empty())
{
this->pop_back(); this->pop_back();
} }
} }
void printList(){ void reverse()
if(this->empty()){ {
printf("Empty List\n"); DequeNode *p = this->head->next;
return; while (p != this->tail)
{
DequeNode *tmp = p->next;
p->next = p->prev;
p->prev = tmp;
p = tmp;
} }
DequeNode* p = this->head->next; DequeNode *tmp = this->head->next;
while(p != this->tail){ this->head->next = this->tail->prev;
p->printNode(); this->tail->prev = tmp;
p = p->next;
}
printf("\n");
} }
}; };
// STARTING HERE // STARTING HERE
struct PyDeque struct PyDeque
{ {
PY_CLASS(PyDeque, collections, deque); PY_CLASS(PyDeque, mycollections, deque);
// some fields can be defined here // some fields can be defined here
int len;
MyDoublyLinkedList *dequeItems; MyDoublyLinkedList *dequeItems;
void appendLeft(int item); // TODO: change to PyObject* void appendLeft(PyObject *item);
void append(int item); // TODO: change to PyObject* void append(PyObject *item);
int popLeft(); // TODO: change to PyObject* PyObject *popLeft();
int pop(); // TODO: change to PyObject* PyObject *pop();
int count(int obj); // TODO: change to PyObject* std::stringstream getRepr(VM *vm);
void reverse();
int count(VM *vm, PyObject *obj); // vm is needed for the py_equals
void clear(); void clear();
void print(VM *vm);
PyDeque(): len(0), dequeItems(new MyDoublyLinkedList()){} PyDeque() : dequeItems(new MyDoublyLinkedList()) {}
PyDeque(VM *vm) : len(0), dequeItems(new MyDoublyLinkedList()){}
void printHelloWorld();
static void _register(VM *vm, PyObject *mod, PyObject *type); static void _register(VM *vm, PyObject *mod, PyObject *type);
void _gc_mark() const; // needed for container types void _gc_mark() const; // needed for container types

334
src/collections.cpp
View File

@ -2,150 +2,230 @@
namespace pkpy namespace pkpy
{ {
void PyDeque::_register(VM *vm, PyObject *mod, PyObject *type) void PyDeque::_register(VM *vm, PyObject *mod, PyObject *type)
{ {
vm->bind_default_constructor<PyDeque>(type); vm->bind_default_constructor<PyDeque>(type);
vm->bind(type, "__len__(self) -> int", vm->bind(type, "__len__(self) -> int",
[](VM *vm, ArgsView args) [](VM *vm, ArgsView args)
{ {
PyDeque &self = _CAST(PyDeque &, args[0]); PyDeque &self = _CAST(PyDeque &, args[0]);
return VAR(self.len); return VAR(self.dequeItems->size());
}); });
vm->bind(type, "printHelloWorld(self) -> None", vm->bind(type, "append(self, item) -> None",
[](VM *vm, ArgsView args) [](VM *vm, ArgsView args)
{ {
printf("TESTING HELLO WORLD!!\n"); PyDeque &self = _CAST(PyDeque &, args[0]);
PyObject *item = args[1];
self.append(item);
return vm->None;
});
PyDeque &self = _CAST(PyDeque &, args[0]); vm->bind(type, "appendleft(self, item) -> None",
self.printHelloWorld(); [](VM *vm, ArgsView args)
{
PyDeque &self = _CAST(PyDeque &, args[0]);
PyObject *item = args[1];
self.appendLeft(item);
return vm->None;
});
printf("TESTED HELLO WORLD!!\n"); vm->bind(type, "clear(self) -> None",
return vm->None; [](VM *vm, ArgsView args)
}); {
PyDeque &self = _CAST(PyDeque &, args[0]);
self.clear();
return vm->None;
});
vm->bind(type, "appendleft(self, item) -> None", vm->bind(type, "copy(self) -> deque",
[](VM *vm, ArgsView args) [](VM *vm, ArgsView args)
{ {
PyDeque &self = _CAST(PyDeque &, args[0]); // followed implementation of dict.copy()
int item = _CAST(int, args[1]); // TODO: change to PyObject* // PyDeque &self = _CAST(PyDeque &, args[0]);
self.appendLeft(item); // return VAR(self);
return vm->None; //todo: implement
}); printf("TODO: implement deque.copy()");
return vm->None;
});
vm->bind(type, "append(self, item) -> None", vm->bind(type, "count(self, obj) -> int",
[](VM *vm, ArgsView args) [](VM *vm, ArgsView args)
{ {
PyDeque &self = _CAST(PyDeque &, args[0]); PyDeque &self = _CAST(PyDeque &, args[0]);
int item = _CAST(int, args[1]); // TODO: change to PyObject* PyObject *obj = args[1];
self.append(item); int cnt = self.count(vm, obj);
return vm->None; return VAR(cnt);
}); });
vm->bind(type, "popleft(self) -> PyObject", vm->bind(type, "extend(self, iterable) -> None",
[](VM *vm, ArgsView args) [](VM *vm, ArgsView args)
{ {
PyDeque &self = _CAST(PyDeque &, args[0]); PyDeque &self = _CAST(PyDeque &, args[0]);
int tmp = self.popLeft(); // TODO: change to PyObject*
return py_var(vm, tmp);
});
vm->bind(type,"pop(self) -> PyObject", PyObject *it = vm->py_iter(args[1]); // strong ref
[](VM *vm, ArgsView args) PyObject *obj = vm->py_next(it);
{ while (obj != vm->StopIteration)
PyDeque &self = _CAST(PyDeque &, args[0]); {
int tmp = self.pop(); // TODO: change to PyObject* self.append(obj);
return py_var(vm, tmp); obj = vm->py_next(it);
}); }
return vm->None;
});
vm->bind(type, "extendleft(self, iterable) -> None",
[](VM *vm, ArgsView args)
{
PyDeque &self = _CAST(PyDeque &, args[0]);
vm->bind(type, "count(self, obj) -> int", PyObject *it = vm->py_iter(args[1]); // strong ref
[](VM *vm, ArgsView args) PyObject *obj = vm->py_next(it);
{ while (obj != vm->StopIteration)
PyDeque &self = _CAST(PyDeque &, args[0]); {
int obj = _CAST(int, args[1]); // TODO: change to PyObject* self.appendLeft(obj);
int cnt = self.count(obj); obj = vm->py_next(it);
return VAR(cnt); }
}); return vm->None;
});
vm->bind(type, "index(self, obj, start=0, stop=None) -> int",
[](VM *vm, ArgsView args)
{
// TODO: implement and validate
printf("TODO: implement deque.index()");
return vm->None;
});
vm->bind(type, "print(self) -> None", // TODO: remove this later vm->bind(type, "insert(self, index, obj) -> None",
[](VM *vm, ArgsView args) [](VM *vm, ArgsView args)
{ {
PyDeque &self = _CAST(PyDeque &, args[0]); // TODO: implement and validate
self.print(vm);
return vm->None;
});
vm->bind(type, "clear(self) -> None", printf("TODO: implement deque.insert()");
[](VM *vm, ArgsView args) return vm->None;
{ });
PyDeque &self = _CAST(PyDeque &, args[0]);
self.clear();
return vm->None;
});
}
void PyDeque::_gc_mark() const vm->bind(type, "__repr__(self) -> str",
{ [](VM *vm, ArgsView args)
// TODO: implement {
} PyDeque &self = _CAST(PyDeque &, args[0]);
void PyDeque::appendLeft(int item) // TODO: change to PyObject* std::stringstream ss = self.getRepr(vm);
{ return VAR(ss.str());
DequeNode *node = new DequeNode(item); });
this->dequeItems->push_front(node);
}
void PyDeque::append(int item) // TODO: change to PyObject*
{
// int val = _CAST(int, item);
DequeNode *node = new DequeNode(item);
this->dequeItems->push_back(node);
}
int PyDeque::popLeft() // TODO: change to PyObject* vm->bind(type, "pop(self) -> PyObject",
{ [](VM *vm, ArgsView args)
if (this->dequeItems->empty()) {
{ PyDeque &self = _CAST(PyDeque &, args[0]);
throw std::runtime_error("pop from an empty deque"); return self.pop();
} });
DequeNode *node = this->dequeItems->pop_front();
return node->obj;
}
int PyDeque::pop() // TODO: change to PyObject* vm->bind(type, "popleft(self) -> PyObject",
{ [](VM *vm, ArgsView args)
if (this->dequeItems->empty()) {
{ PyDeque &self = _CAST(PyDeque &, args[0]);
throw std::runtime_error("pop from an empty deque"); return self.popLeft();
} });
DequeNode *node = this->dequeItems->pop_back();
return node->obj;
}
int PyDeque::count(int obj) // TODO: change to PyObject* vm->bind(type, "remove(self, obj) -> None",
{ [](VM *vm, ArgsView args)
return this->dequeItems->count(obj); {
} // TODO: implement and validate
void PyDeque::clear() printf("TODO: implement deque.index()");
{ return vm->None;
this->dequeItems->makeListEmpty(); });
}
void PyDeque::print(VM *vm)
{
// TODO: Helper function to print the deque, will be removed later
this->dequeItems->printList();
}
void PyDeque::printHelloWorld() vm->bind(type, "reverse(self) -> None",
{ [](VM *vm, ArgsView args)
printf("Hello World!\n"); {
return; PyDeque &self = _CAST(PyDeque &, args[0]);
} self.reverse();
return vm->None;
});
vm->bind(type,"rotate(self, n=1) -> None",
[](VM *vm, ArgsView args)
{
//TODO: implement and validate
printf("TODO: implement deque.rotate()");
return vm->None;
});
// vm->bind(type,"maxlen",
// [](VM *vm, ArgsView args)
// {
// return VAR(-1);
// });
}
void add_module_mycollections(VM *vm) void PyDeque::_gc_mark() const
{ {
PyObject *mycollections = vm->new_module("collections"); // TODO: implement
PyDeque::register_class(vm, mycollections); }
} std::stringstream PyDeque::getRepr(VM *vm)
{
std::stringstream ss;
ss << "deque([";
DequeNode *p = this->dequeItems->head->next;
while (p != this->dequeItems->tail)
{
ss << CAST(Str &, vm->py_repr(p->obj));
if (p->next != this->dequeItems->tail)
ss << ", ";
p = p->next;
}
ss << "])";
return ss;
}
void PyDeque::reverse()
{
this->dequeItems->reverse();
}
void PyDeque::appendLeft(PyObject *item)
{
DequeNode *node = new DequeNode(item);
this->dequeItems->push_front(node);
}
void PyDeque::append(PyObject *item)
{
DequeNode *node = new DequeNode(item);
this->dequeItems->push_back(node);
}
PyObject *PyDeque::popLeft()
{
if (this->dequeItems->empty())
{
throw std::runtime_error("pop from an empty deque");
}
DequeNode *node = this->dequeItems->pop_front();
return node->obj;
}
PyObject *PyDeque::pop()
{
if (this->dequeItems->empty())
{
throw std::runtime_error("pop from an empty deque");
}
DequeNode *node = this->dequeItems->pop_back();
return node->obj;
}
int PyDeque::count(VM *vm, PyObject *obj)
{
return this->dequeItems->count(vm, obj);
}
void PyDeque::clear()
{
this->dequeItems->makeListEmpty();
}
void add_module_mycollections(VM *vm)
{
PyObject *mycollections = vm->new_module("mycollections");
PyDeque::register_class(vm, mycollections);
}
} // namespace pkpypkpy } // namespace pkpypkpy