void naSetUserData(naContext c, void* p);
void* naGetUserData(naContext c) GCC_PURE;
+// run GC now (may block)
+void naGC();
+
// "Save" this object in the context, preventing it (and objects
// referenced by it) from being garbage collected.
+// TODO do we need a context? It is not used anyhow...
void naSave(naContext ctx, naRef obj);
+// "Save" this object and get a key which allows do mark the object as free
+// later on (with naGCFree).
+int naGCSave(naRef obj);
+
+// Release an object previously passed to naGCSave to allow it being cleaned up
+// by the garbage collector.
+void naGCRelease(int key);
+
+// Drop all saved references
+void naClearSaved();
+
// Similar, but the object is automatically released when the
// context next runs native bytecode. Useful for saving off C-space
// temporaries to protect them before passing back into a naCall.
// naModUnlock() first if the lock is already held.
naRef naContinue(naContext ctx);
+// Does a naCall() in a given context. Wrapped here to make lock
+// tracking easier. Extension functions are called with the lock, but
+// we have to release it before making a new naCall(). So rather than
+// drop the lock in every extension function that might call back into
+// Nasal, we keep a stack depth counter here and only unlock/lock
+// around the naCall if it isn't the first one.
+naRef naCallMethodCtx( naContext ctx,
+ naRef code,
+ naRef self,
+ int argc,
+ naRef* args,
+ naRef locals );
+
+// Same as naCallMethodCtx but creates (and afterwards destroyes) a new context
+naRef naCallMethod(naRef code, naRef self, int argc, naRef* args, naRef locals);
+
+typedef void (*naErrorHandler)(naContext);
+
+// Register a handler to be called if an error is raised during the execution of
+// naCallMethodCtx or naCallMethod.
+naErrorHandler naSetErrorHandler(naErrorHandler cb);
+
// Throw an error from the current call stack. This function makes a
// longjmp call to a handler in naCall() and DOES NOT RETURN. It is
// intended for use in library code that cannot otherwise report an
int naIsFunc(naRef r) GCC_PURE;
int naIsCCode(naRef r) GCC_PURE;
+// Object equality (check for same instance, aka. pointer equality)
+int naIsIdentical(naRef l, naRef r) GCC_PURE;
+
// Allocators/generators:
naRef naNil() GCC_PURE;
naRef naNum(double num) GCC_PURE;
naRef naVec_get(naRef v, int i);
void naVec_set(naRef vec, int i, naRef o);
int naVec_append(naRef vec, naRef o);
-naRef naVec_removelast(naRef vec);
void naVec_setsize(naContext c, naRef vec, int sz);
+/**
+ * Remove and retrieve the first element of the vector.
+ *
+ * This operation reduces the size of the vector by one and moves all elements
+ * by one towards the begin of the vector.
+ *
+ * @return The element removed from the begin
+ */
+naRef naVec_removefirst(naRef vec);
+
+/**
+ * Remove and retrieve the last element of the vector.
+ *
+ * This operation reduces the size of the vector by one.
+ *
+ * @return The element removed from the end
+ */
+naRef naVec_removelast(naRef vec);
+
// Hash utilities:
int naHash_size(naRef h);
int naHash_get(naRef hash, naRef key, naRef* out);