Diff: sqmbed/src/interruptin.cpp

Revision:

0:6f55c7651ccc

Child:

1:540008bb92a2

diff -r 000000000000 -r 6f55c7651ccc sqmbed/src/interruptin.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sqmbed/src/interruptin.cpp	Tue Dec 16 12:54:53 2014 +0000
@@ -0,0 +1,142 @@
+/*
+  @License@
+*/
+
+#include <sqmbed/interruptin.h>
+#include <sqmbed/pointerstorage.h>
+
+namespace
+{
+
+class Interrupts : public SqMbed::PointerStorage<SqMbed::InterruptIn>
+{
+public:
+    static void notify(PinName pin) {
+        // Do not store pointers here. Who knows, maybe the handler creates a
+        // new InterruptIn and then both s_nSpace and s_ppInterrupts may change.
+        for (uint32_t i = 0; i < s_nSpace; ++i) {
+            SqMbed::InterruptIn* pInterrupt = s_ppObjects[i];
+
+            if (pInterrupt && (pInterrupt->pin() == pin)) {
+                pInterrupt->call();
+            }
+        }
+    }
+};
+
+}
+
+template<>
+struct SqBindAllocator<SqMbed::InterruptIn> {
+    static SQBIND_INLINE SqMbed::InterruptIn *construct(HSQUIRRELVM) {
+        return NULL; // make it not able to construct
+    }
+
+    static SQBIND_INLINE SqMbed::InterruptIn *copy_construct(const SqMbed::InterruptIn* p_from) {
+        return NULL; // make it not able to copy-construct
+    }
+
+    static SQBIND_INLINE bool assign(SqMbed::InterruptIn* p_val, const SqMbed::InterruptIn* p_from) {
+        return false; // make it not able to assign
+    }
+
+    static SQBIND_INLINE void destruct(SqMbed::InterruptIn* p_instance) {
+        delete p_instance;
+    }
+
+    static SQBIND_INLINE SqMbed::InterruptIn& get_empty() {
+        // if someone tries to assign, this will crash.
+        // however, this will likely never be called anyway.
+        static SqMbed::InterruptIn *crashplease=NULL;
+        return *crashplease;
+    }
+};
+
+namespace SqMbed
+{
+
+InterruptIn::InterruptIn(HSQUIRRELVM vm, PinName pin)
+    : m_vm(vm)
+    , m_pin(pin)
+    , m_intIn(pin)
+{
+    m_object._type = OT_NULL;
+
+    Interrupts::add(this);
+}
+
+void InterruptIn::rise(HSQOBJECT o)
+{
+    if (m_object._type != OT_NULL) {
+        sq_release(m_vm, &m_object);
+        m_object._type = OT_NULL;
+    }
+
+    m_object = o;
+    sq_addref(m_vm, &m_object);
+
+    m_intIn.rise(this, &InterruptIn::raised);
+}
+
+InterruptIn::~InterruptIn()
+{
+    Interrupts::remove(this);
+}
+
+void InterruptIn::raised()
+{
+    InterruptIn::postponeInterrupt(m_pin);
+}
+
+void InterruptIn::call()
+{
+    int top = sq_gettop(m_vm);
+    sq_pushobject(m_vm, m_object); // The function
+    sq_pushroottable(m_vm);        // This
+    sq_call(m_vm, 1, 0, 0);        // Only this as argument.
+    sq_settop(m_vm, top);          // Restore the stack.
+}
+
+// static
+void InterruptIn::deliver(PinName pin)
+{
+    Interrupts::notify(pin);
+}
+
+// static
+void InterruptIn::bind(HSQUIRRELVM vm)
+{
+    SqBind<InterruptIn>::init(vm, _SC("InterruptIn"));
+    SqBind<InterruptIn>::set_custom_constructor(&InterruptIn::constructor);
+
+    sqbind_method(vm, "rise", &InterruptIn::rise);
+    sqbind_method(vm, "call", &InterruptIn::call);
+}
+
+// static
+InterruptIn* InterruptIn::constructor(HSQUIRRELVM vm)
+{
+    InterruptIn* pThis = 0;
+
+    int nParams = sq_gettop(vm);
+
+    if (nParams == 2) { // Need 1 (sic) params.
+        SQInteger i;
+
+        if (!SQ_FAILED(sq_getinteger(vm, 2, &i))) {
+            if (Interrupts::reserve()) {
+                pThis = new InterruptIn(vm, static_cast<PinName>(i));
+            } else {
+                printf("error: Out of memory.\n");
+            }
+        } else {
+            printf("error: Could not get integer.\n");
+        }
+    } else {
+        printf("error: nParams != 2\n");
+    }
+
+    return pThis;
+}
+
+}