Import project

Original repository: https://github.com/encounter/ww

include/JSystem/JSupport/JSUFileStream.h

@@ -0,0 +1,24 @@
+#ifndef JSUFILESTREAM_H
+#define JSUFILESTREAM_H
+
+#include "JSystem/JSupport/JSURandomInputStream.h"
+
+class JKRFile;
+
+class JSUFileInputStream : public JSURandomInputStream {
+public:
+    virtual ~JSUFileInputStream() {}
+
+    // TODO: fix return values
+    /* 802DC638 */ JSUFileInputStream(JKRFile*);
+    /* 802DC67C */ u32 readData(void*, s32);
+    /* 802DC74C */ s32 seekPos(s32, JSUStreamSeekFrom);
+    /* 802DC82C */ s32 getLength() const;
+    /* 802DC85C */ s32 getPosition() const;
+
+private:
+    /* 0x08 */ JKRFile* mFile;
+    /* 0x0C */ s32 mPosition;
+};  // Size = 0x10
+
+#endif /* JSUFILESTREAM_H */

include/JSystem/JSupport/JSUInputStream.h

@@ -0,0 +1,77 @@
+#ifndef JSUINPUTSTREAM_H
+#define JSUINPUTSTREAM_H
+
+#include "JSystem/JSupport/JSUIosBase.h"
+
+enum JSUStreamSeekFrom {
+    JSUStreamSeekFrom_SET = 0,  // absolute
+    JSUStreamSeekFrom_CUR = 1,  // relative
+    JSUStreamSeekFrom_END = 2,  // relative to end
+};
+
+class JSUInputStream : public JSUIosBase {
+public:
+    JSUInputStream() {}
+    virtual ~JSUInputStream();
+
+    /* vt[3] */ virtual s32 getAvailable() const = 0;
+    /* vt[4] */ virtual s32 skip(s32);
+    /* vt[5] */ virtual u32 readData(void*, s32) = 0;
+
+    u32 readU32() {
+        u32 val;
+        this->read(&val, sizeof(val));
+        return val;
+    }
+
+    u32 read32b() {
+        u32 val;
+        this->read(&val, sizeof(val));
+        return val;
+    }
+
+    s32 readS32() {
+        s32 val;
+        this->read(&val, sizeof(val));
+        return val;
+    }
+
+    s16 readS16() {
+        s16 val;
+        this->read(&val, sizeof(val));
+        return val;
+    }
+
+    u16 readU16() {
+        u16 val;
+        this->read(&val, sizeof(val));
+        return val;
+    }
+
+    u8 readU8() {
+        u8 val;
+        this->read(&val, sizeof(val));
+        return val;
+    }
+
+    u8 read8b() {
+        u8 val;
+        this->read(&val, sizeof(val));
+        return val;
+    }
+
+    u16 read16b() {
+        u16 val;
+        this->read(&val, sizeof(val));
+        return val;
+    }
+
+    // TODO: return value probably wrong
+    /* 802DC298 */ s32 read(void*, s32);
+};  // Size = 0x8
+
+// move?
+template <typename T>
+T* JSUConvertOffsetToPtr(const void*, const void*);
+
+#endif /* JSUINPUTSTREAM_H */

include/JSystem/JSupport/JSUIosBase.h

@@ -0,0 +1,24 @@
+#ifndef JSUIOSBASE_H_
+#define JSUIOSBASE_H_
+
+#include "dolphin/types.h"
+
+enum EIoState {
+    IOS_STATE_1 = 1,
+};
+
+class JSUIosBase {
+public:
+    JSUIosBase() { mState = false; }
+
+    virtual ~JSUIosBase() {}
+
+    bool isGood() const { return mState == 0; }
+    void clrState(EIoState state) { mState &= ~state; }
+    void setState(EIoState state) { mState |= state; }
+
+private:
+    u8 mState;
+};  // Size = 0x8
+
+#endif

include/JSystem/JSupport/JSUList.h

@@ -0,0 +1,223 @@
+#ifndef JSULIST_H
+#define JSULIST_H
+
+#include "dolphin/types.h"
+
+template <typename T>
+class JSUList;
+
+//
+// Link
+//
+
+class JSUPtrList;
+class JSUPtrLink {
+public:
+    JSUPtrLink(void* object);
+    ~JSUPtrLink();
+
+    void* getObjectPtr() const { return mObject; }
+
+    JSUPtrList* getList() const { return mList; }
+
+    JSUPtrLink* getNext() const { return mNext; }
+
+    JSUPtrLink* getPrev() const { return mPrev; }
+
+public:
+    void* mObject;
+    JSUPtrList* mList;
+    JSUPtrLink* mPrev;
+    JSUPtrLink* mNext;
+};
+
+template <typename T>
+class JSULink : public JSUPtrLink {
+public:
+    JSULink(T* object) : JSUPtrLink((void*)object) {}
+
+    T* getObject() const { return (T*)getObjectPtr(); }
+
+    JSUList<T>* getSupervisor() const { return (JSUList<T>*)this->getList(); }
+
+    JSULink<T>* getNext() const { return (JSULink<T>*)this->JSUPtrLink::getNext(); }
+
+    JSULink<T>* getPrev() const { return (JSULink<T>*)this->JSUPtrLink::getPrev(); }
+};
+
+//
+// List
+//
+
+class JSUPtrList {
+public:
+    JSUPtrList() { this->initiate(); }
+    JSUPtrList(bool init);
+    ~JSUPtrList();
+
+    void initiate();
+    void setFirst(JSUPtrLink* first);
+    bool append(JSUPtrLink* ptr);
+    bool prepend(JSUPtrLink* ptr);
+    bool insert(JSUPtrLink* before, JSUPtrLink* ptr);
+    bool remove(JSUPtrLink* ptr);
+    JSUPtrLink* getNthLink(u32 i) const;
+
+    JSUPtrLink* getFirstLink() const { return mHead; }
+
+    JSUPtrLink* getLastLink() const { return mTail; }
+
+    u32 getNumLinks() const { return mLength; }
+
+private:
+    JSUPtrLink* mHead;
+    JSUPtrLink* mTail;
+    u32 mLength;
+};
+
+template <typename T>
+class JSUList : public JSUPtrList {
+public:
+    JSUList() : JSUPtrList() {}
+    JSUList(bool init) : JSUPtrList(init) {}
+
+    ~JSUList() {}
+
+    bool append(JSULink<T>* link) { return this->JSUPtrList::append((JSUPtrLink*)link); }
+
+    bool prepend(JSULink<T>* link) { return this->JSUPtrList::prepend((JSUPtrLink*)link); }
+
+    bool insert(JSULink<T>* before, JSULink<T>* link) {
+        return this->JSUPtrList::insert((JSUPtrLink*)before, (JSUPtrLink*)link);
+    }
+
+    bool remove(JSULink<T>* link) { return this->JSUPtrList::remove((JSUPtrLink*)link); }
+
+    JSULink<T>* getFirst() const { return (JSULink<T>*)getFirstLink(); }
+
+    JSULink<T>* getLast() const { return (JSULink<T>*)getLastLink(); }
+
+    JSULink<T>* getEnd() const { return NULL; }
+
+    u32 getNumLinks() const { return this->JSUPtrList::getNumLinks(); }
+};
+
+template <typename T>
+class JSUListIterator {
+public:
+    JSUListIterator() : mLink(NULL) {}
+    JSUListIterator(JSULink<T>* link) : mLink(link) {}
+    JSUListIterator(JSUList<T>* list) : mLink(list->getFirst()) {}
+
+    JSUListIterator<T>& operator=(JSULink<T>* link) {
+        this->mLink = link;
+        return *this;
+    }
+
+    T* getObject() { return this->mLink->getObject(); }
+
+    bool operator==(JSULink<T> const* other) const { return this->mLink == other; }
+    bool operator!=(JSULink<T> const* other) const { return this->mLink != other; }
+    bool operator==(JSUListIterator<T> const& other) const { return this->mLink == other.mLink; }
+    bool operator!=(JSUListIterator<T> const& other) const { return this->mLink != other.mLink; }
+
+    JSUListIterator<T> operator++(int) {
+        JSUListIterator<T> prev = *this;
+        this->mLink = this->mLink->getNext();
+        return prev;
+    }
+
+    JSUListIterator<T>& operator++() {
+        this->mLink = this->mLink->getNext();
+        return *this;
+    }
+
+    JSUListIterator<T> operator--(int) {
+        JSUListIterator<T> prev = *this;
+        this->mLink = this->mLink->getPrev();
+        return prev;
+    }
+
+    JSUListIterator<T>& operator--() {
+        this->mLink = this->mLink->getPrev();
+        return *this;
+    }
+
+    T& operator*() { return *this->getObject(); }
+
+    T* operator->() { return this->getObject(); }
+
+// private:
+    JSULink<T>* mLink;
+};
+
+//
+// Tree
+//
+
+template <typename T>
+class JSUTree : public JSUList<T>, public JSULink<T> {
+public:
+    JSUTree(T* owner) : JSUList<T>(), JSULink<T>(owner) {}
+    ~JSUTree() {}
+
+    bool appendChild(JSUTree<T>* child) { return this->append(child); }
+
+    bool removeChild(JSUTree<T>* child) { return this->remove(child); }
+
+    bool insertChild(JSUTree<T>* before, JSUTree<T>* child) { return this->insert(before, child); }
+
+    JSUTree<T>* getEndChild() const { return NULL; }
+
+    JSUTree<T>* getFirstChild() const { return (JSUTree<T>*)this->getFirst(); }
+
+    JSUTree<T>* getLastChild() const { return (JSUTree<T>*)this->getLast(); }
+
+    JSUTree<T>* getNextChild() const { return (JSUTree<T>*)this->getNext(); }
+
+    JSUTree<T>* getPrevChild() const { return (JSUTree<T>*)this->getPrev(); }
+
+    u32 getNumChildren() const { return this->getNumLinks(); }
+
+    T* getObject() const { return (T*)this->getObjectPtr(); }
+
+    JSUTree<T>* getParent() const { return (JSUTree<T>*)this->getList(); }
+};
+
+template <typename T>
+class JSUTreeIterator {
+public:
+    JSUTreeIterator() : mTree(NULL) {}
+    JSUTreeIterator(JSUTree<T>* tree) : mTree(tree) {}
+
+    JSUTreeIterator<T>& operator=(JSUTree<T>* tree) {
+        this->mTree = tree;
+        return *this;
+    }
+
+    T* getObject() { return this->mTree->getObject(); }
+
+    bool operator==(JSUTree<T>* other) { return this->mTree == other; }
+
+    bool operator!=(JSUTree<T>* other) { return this->mTree != other; }
+
+    JSUTreeIterator<T> operator++(int) {
+        JSUTreeIterator<T> prev = *this;
+        this->mTree = this->mTree->getNextChild();
+        return prev;
+    }
+
+    JSUTreeIterator<T>& operator++() {
+        this->mTree = this->mTree->getNextChild();
+        return *this;
+    }
+
+    T& operator*() { return *this->getObject(); }
+
+    T* operator->() { return this->getObject(); }
+
+private:
+    JSUTree<T>* mTree;
+};
+
+#endif /* JSULIST_H */

include/JSystem/JSupport/JSUMemoryStream.h

@@ -0,0 +1,23 @@
+#ifndef JSUMEMORYSTREAM_H
+#define JSUMEMORYSTREAM_H
+
+#include "JSystem/JSupport/JSURandomInputStream.h"
+
+class JSUMemoryInputStream : public JSURandomInputStream {
+public:
+    JSUMemoryInputStream(const void* res, u32 size) { setBuffer(res, size); }
+
+    /* 802552B8 */ virtual ~JSUMemoryInputStream() {}
+    /* 802DC520 */ void setBuffer(void const*, s32);
+    /* 802DC534 */ u32 readData(void*, s32);
+    /* 802DC5AC */ s32 seekPos(s32, JSUStreamSeekFrom);
+    /* 802DC628 */ s32 getLength() const;
+    /* 802DC630 */ s32 getPosition() const;
+
+private:
+    /* 0x08 */ const void* mBuffer;
+    /* 0x0C */ s32 mLength;
+    /* 0x10 */ s32 mPosition;
+};  // Size = 0x14
+
+#endif /* JSUMEMORYSTREAM_H */

include/JSystem/JSupport/JSURandomInputStream.h

@@ -0,0 +1,24 @@
+#ifndef JSURANDOMINPUTSTREAM_H_
+#define JSURANDOMINPUTSTREAM_H_
+
+#include "JSystem/JSupport/JSUInputStream.h"
+
+class JSURandomInputStream : public JSUInputStream {
+public:
+    JSURandomInputStream() {}
+    virtual ~JSURandomInputStream() {}
+
+    /* vt[3] */ virtual s32 getAvailable() const; /* override */
+    /* vt[4] */ virtual s32 skip(s32);            /* override */
+    /* vt[5] */ virtual u32 readData(void*, s32) = 0;
+    /* vt[6] */ virtual s32 getLength() const = 0;
+    /* vt[7] */ virtual s32 getPosition() const = 0;
+    /* vt[8] */ virtual s32 seekPos(s32, JSUStreamSeekFrom) = 0;
+
+    // TODO: fix return types
+    /* 802DC370 */ s32 align(s32);
+    /* 802DC458 */ s32 peek(void*, s32);
+    /* 802DC4DC */ s32 seek(s32, JSUStreamSeekFrom);
+};  // Size = 0x8
+
+#endif

include/JSystem/JSupport/JSupport.h

@@ -0,0 +1,27 @@
+#ifndef JSUPPORT_H
+#define JSUPPORT_H
+
+
+template <typename T>
+T* JSUConvertOffsetToPtr(const void* ptr, const void* offset) {
+    if (offset == NULL) {
+        return NULL;
+    } else {
+        return (T*)((s32)ptr + (s32)offset);
+    }
+}
+
+inline u8 JSULoNibble(u8 param_0) { return param_0 & 0x0f; }
+inline u8 JSUHiNibble(u8 param_0) {return param_0 >> 4; }
+
+inline u8 JSULoByte(u16 in) {
+    return in & 0xff;
+}
+
+inline u8 JSUHiByte(u16 in) {
+    return in >> 8;
+}
+
+inline u16 JSULoHalf(u32 param_0) {return param_0; }
+
+#endif