update wren to 0.4.0

deps/wren/include/wren.h

@@ -7,18 +7,26 @@
 
 // The Wren semantic version number components.
 #define WREN_VERSION_MAJOR 0
-#define WREN_VERSION_MINOR 3
+#define WREN_VERSION_MINOR 4
 #define WREN_VERSION_PATCH 0
 
 // A human-friendly string representation of the version.
-#define WREN_VERSION_STRING "0.3.0"
+#define WREN_VERSION_STRING "0.4.0"
 
 // A monotonically increasing numeric representation of the version number. Use
 // this if you want to do range checks over versions.
-#define WREN_VERSION_NUMBER (WREN_VERSION_MAJOR * 1000000 + \
-                             WREN_VERSION_MINOR * 1000 + \
+#define WREN_VERSION_NUMBER (WREN_VERSION_MAJOR * 1000000 +                    \
+                             WREN_VERSION_MINOR * 1000 +                       \
                              WREN_VERSION_PATCH)
 
+#ifndef WREN_API
+  #if defined(_MSC_VER) && defined(WREN_API_DLLEXPORT)
+    #define WREN_API __declspec( dllexport )
+  #else
+    #define WREN_API
+  #endif
+#endif //WREN_API
+
 // A single virtual machine for executing Wren code.
 //
 // Wren has no global state, so all state stored by a running interpreter lives
@@ -47,7 +55,7 @@ typedef struct WrenHandle WrenHandle;
 //
 // - To free memory, [memory] will be the memory to free and [newSize] will be
 //   zero. It should return NULL.
-typedef void* (*WrenReallocateFn)(void* memory, size_t newSize);
+typedef void* (*WrenReallocateFn)(void* memory, size_t newSize, void* userData);
 
 // A function callable from Wren code, but implemented in C.
 typedef void (*WrenForeignMethodFn)(WrenVM* vm);
@@ -65,8 +73,25 @@ typedef void (*WrenFinalizerFn)(void* data);
 typedef const char* (*WrenResolveModuleFn)(WrenVM* vm,
     const char* importer, const char* name);
 
+// Forward declare
+struct WrenLoadModuleResult;
+
+// Called after loadModuleFn is called for module [name]. The original returned result
+// is handed back to you in this callback, so that you can free memory if appropriate.
+typedef void (*WrenLoadModuleCompleteFn)(WrenVM* vm, const char* name, struct WrenLoadModuleResult result);
+
+// The result of a loadModuleFn call. 
+// [source] is the source code for the module, or NULL if the module is not found.
+// [onComplete] an optional callback that will be called once Wren is done with the result.
+typedef struct WrenLoadModuleResult
+{
+  const char* source;
+  WrenLoadModuleCompleteFn onComplete;
+  void* userData;
+} WrenLoadModuleResult;
+
 // Loads and returns the source code for the module [name].
-typedef char* (*WrenLoadModuleFn)(WrenVM* vm, const char* name);
+typedef WrenLoadModuleResult (*WrenLoadModuleFn)(WrenVM* vm, const char* name);
 
 // Returns a pointer to a foreign method on [className] in [module] with
 // [signature].
@@ -163,9 +188,9 @@ typedef struct
   // Since Wren does not talk directly to the file system, it relies on the
   // embedder to physically locate and read the source code for a module. The
   // first time an import appears, Wren will call this and pass in the name of
-  // the module being imported. The VM should return the soure code for that
-  // module. Memory for the source should be allocated using [reallocateFn] and
-  // Wren will take ownership over it.
+  // the module being imported. The method will return a result, which contains
+  // the source code for that module. Memory for the source is owned by the 
+  // host application, and can be freed using the onComplete callback.
   //
   // This will only be called once for any given module name. Wren caches the
   // result internally so subsequent imports of the same module will use the
@@ -263,34 +288,40 @@ typedef enum
   WREN_TYPE_NUM,
   WREN_TYPE_FOREIGN,
   WREN_TYPE_LIST,
+  WREN_TYPE_MAP,
   WREN_TYPE_NULL,
   WREN_TYPE_STRING,
 
   // The object is of a type that isn't accessible by the C API.
   WREN_TYPE_UNKNOWN
 } WrenType;
 
+// Get the current wren version number.
+//
+// Can be used to range checks over versions.
+WREN_API int wrenGetVersionNumber();
+
 // Initializes [configuration] with all of its default values.
 //
 // Call this before setting the particular fields you care about.
-void wrenInitConfiguration(WrenConfiguration* configuration);
+WREN_API void wrenInitConfiguration(WrenConfiguration* configuration);
 
 // Creates a new Wren virtual machine using the given [configuration]. Wren
 // will copy the configuration data, so the argument passed to this can be
 // freed after calling this. If [configuration] is `NULL`, uses a default
 // configuration.
-WrenVM* wrenNewVM(WrenConfiguration* configuration);
+WREN_API WrenVM* wrenNewVM(WrenConfiguration* configuration);
 
 // Disposes of all resources is use by [vm], which was previously created by a
 // call to [wrenNewVM].
-void wrenFreeVM(WrenVM* vm);
+WREN_API void wrenFreeVM(WrenVM* vm);
 
 // Immediately run the garbage collector to free unused memory.
-void wrenCollectGarbage(WrenVM* vm);
+WREN_API void wrenCollectGarbage(WrenVM* vm);
 
 // Runs [source], a string of Wren source code in a new fiber in [vm] in the
 // context of resolved [module].
-WrenInterpretResult wrenInterpret(WrenVM* vm, const char* module,
+WREN_API WrenInterpretResult wrenInterpret(WrenVM* vm, const char* module,
                                   const char* source);
 
 // Creates a handle that can be used to invoke a method with [signature] on
@@ -301,7 +332,7 @@ WrenInterpretResult wrenInterpret(WrenVM* vm, const char* module,
 //
 // When you are done with this handle, it must be released using
 // [wrenReleaseHandle].
-WrenHandle* wrenMakeCallHandle(WrenVM* vm, const char* signature);
+WREN_API WrenHandle* wrenMakeCallHandle(WrenVM* vm, const char* signature);
 
 // Calls [method], using the receiver and arguments previously set up on the
 // stack.
@@ -313,11 +344,11 @@ WrenHandle* wrenMakeCallHandle(WrenVM* vm, const char* signature);
 // signature.
 //
 // After this returns, you can access the return value from slot 0 on the stack.
-WrenInterpretResult wrenCall(WrenVM* vm, WrenHandle* method);
+WREN_API WrenInterpretResult wrenCall(WrenVM* vm, WrenHandle* method);
 
 // Releases the reference stored in [handle]. After calling this, [handle] can
 // no longer be used.
-void wrenReleaseHandle(WrenVM* vm, WrenHandle* handle);
+WREN_API void wrenReleaseHandle(WrenVM* vm, WrenHandle* handle);
 
 // The following functions are intended to be called from foreign methods or
 // finalizers. The interface Wren provides to a foreign method is like a
@@ -357,23 +388,23 @@ void wrenReleaseHandle(WrenVM* vm, WrenHandle* handle);
 // return, you get a very fast FFI.
 
 // Returns the number of slots available to the current foreign method.
-int wrenGetSlotCount(WrenVM* vm);
+WREN_API int wrenGetSlotCount(WrenVM* vm);
 
 // Ensures that the foreign method stack has at least [numSlots] available for
 // use, growing the stack if needed.
 //
 // Does not shrink the stack if it has more than enough slots.
 //
 // It is an error to call this from a finalizer.
-void wrenEnsureSlots(WrenVM* vm, int numSlots);
+WREN_API void wrenEnsureSlots(WrenVM* vm, int numSlots);
 
 // Gets the type of the object in [slot].
-WrenType wrenGetSlotType(WrenVM* vm, int slot);
+WREN_API WrenType wrenGetSlotType(WrenVM* vm, int slot);
 
 // Reads a boolean value from [slot].
 //
 // It is an error to call this if the slot does not contain a boolean value.
-bool wrenGetSlotBool(WrenVM* vm, int slot);
+WREN_API bool wrenGetSlotBool(WrenVM* vm, int slot);
 
 // Reads a byte array from [slot].
 //
@@ -385,19 +416,19 @@ bool wrenGetSlotBool(WrenVM* vm, int slot);
 // number of bytes in the array.
 //
 // It is an error to call this if the slot does not contain a string.
-const char* wrenGetSlotBytes(WrenVM* vm, int slot, int* length);
+WREN_API const char* wrenGetSlotBytes(WrenVM* vm, int slot, int* length);
 
 // Reads a number from [slot].
 //
 // It is an error to call this if the slot does not contain a number.
-double wrenGetSlotDouble(WrenVM* vm, int slot);
+WREN_API double wrenGetSlotDouble(WrenVM* vm, int slot);
 
 // Reads a foreign object from [slot] and returns a pointer to the foreign data
 // stored with it.
 //
 // It is an error to call this if the slot does not contain an instance of a
 // foreign class.
-void* wrenGetSlotForeign(WrenVM* vm, int slot);
+WREN_API void* wrenGetSlotForeign(WrenVM* vm, int slot);
 
 // Reads a string from [slot].
 //
@@ -406,25 +437,25 @@ void* wrenGetSlotForeign(WrenVM* vm, int slot);
 // function returns, since the garbage collector may reclaim it.
 //
 // It is an error to call this if the slot does not contain a string.
-const char* wrenGetSlotString(WrenVM* vm, int slot);
+WREN_API const char* wrenGetSlotString(WrenVM* vm, int slot);
 
 // Creates a handle for the value stored in [slot].
 //
 // This will prevent the object that is referred to from being garbage collected
 // until the handle is released by calling [wrenReleaseHandle()].
-WrenHandle* wrenGetSlotHandle(WrenVM* vm, int slot);
+WREN_API WrenHandle* wrenGetSlotHandle(WrenVM* vm, int slot);
 
 // Stores the boolean [value] in [slot].
-void wrenSetSlotBool(WrenVM* vm, int slot, bool value);
+WREN_API void wrenSetSlotBool(WrenVM* vm, int slot, bool value);
 
 // Stores the array [length] of [bytes] in [slot].
 //
 // The bytes are copied to a new string within Wren's heap, so you can free
 // memory used by them after this is called.
-void wrenSetSlotBytes(WrenVM* vm, int slot, const char* bytes, size_t length);
+WREN_API void wrenSetSlotBytes(WrenVM* vm, int slot, const char* bytes, size_t length);
 
 // Stores the numeric [value] in [slot].
-void wrenSetSlotDouble(WrenVM* vm, int slot, double value);
+WREN_API void wrenSetSlotDouble(WrenVM* vm, int slot, double value);
 
 // Creates a new instance of the foreign class stored in [classSlot] with [size]
 // bytes of raw storage and places the resulting object in [slot].
@@ -435,54 +466,89 @@ void wrenSetSlotDouble(WrenVM* vm, int slot, double value);
 // and then the constructor will be invoked when the allocator returns.
 //
 // Returns a pointer to the foreign object's data.
-void* wrenSetSlotNewForeign(WrenVM* vm, int slot, int classSlot, size_t size);
+WREN_API void* wrenSetSlotNewForeign(WrenVM* vm, int slot, int classSlot, size_t size);
 
 // Stores a new empty list in [slot].
-void wrenSetSlotNewList(WrenVM* vm, int slot);
+WREN_API void wrenSetSlotNewList(WrenVM* vm, int slot);
+
+// Stores a new empty map in [slot].
+WREN_API void wrenSetSlotNewMap(WrenVM* vm, int slot);
 
 // Stores null in [slot].
-void wrenSetSlotNull(WrenVM* vm, int slot);
+WREN_API void wrenSetSlotNull(WrenVM* vm, int slot);
 
 // Stores the string [text] in [slot].
 //
 // The [text] is copied to a new string within Wren's heap, so you can free
 // memory used by it after this is called. The length is calculated using
 // [strlen()]. If the string may contain any null bytes in the middle, then you
 // should use [wrenSetSlotBytes()] instead.
-void wrenSetSlotString(WrenVM* vm, int slot, const char* text);
+WREN_API void wrenSetSlotString(WrenVM* vm, int slot, const char* text);
 
 // Stores the value captured in [handle] in [slot].
 //
 // This does not release the handle for the value.
-void wrenSetSlotHandle(WrenVM* vm, int slot, WrenHandle* handle);
+WREN_API void wrenSetSlotHandle(WrenVM* vm, int slot, WrenHandle* handle);
 
 // Returns the number of elements in the list stored in [slot].
-int wrenGetListCount(WrenVM* vm, int slot);
+WREN_API int wrenGetListCount(WrenVM* vm, int slot);
 
 // Reads element [index] from the list in [listSlot] and stores it in
 // [elementSlot].
-void wrenGetListElement(WrenVM* vm, int listSlot, int index, int elementSlot);
+WREN_API void wrenGetListElement(WrenVM* vm, int listSlot, int index, int elementSlot);
+
+// Sets the value stored at [index] in the list at [listSlot], 
+// to the value from [elementSlot]. 
+WREN_API void wrenSetListElement(WrenVM* vm, int listSlot, int index, int elementSlot);
 
 // Takes the value stored at [elementSlot] and inserts it into the list stored
 // at [listSlot] at [index].
 //
 // As in Wren, negative indexes can be used to insert from the end. To append
 // an element, use `-1` for the index.
-void wrenInsertInList(WrenVM* vm, int listSlot, int index, int elementSlot);
+WREN_API void wrenInsertInList(WrenVM* vm, int listSlot, int index, int elementSlot);
+
+// Returns the number of entries in the map stored in [slot].
+WREN_API int wrenGetMapCount(WrenVM* vm, int slot);
+
+// Returns true if the key in [keySlot] is found in the map placed in [mapSlot].
+WREN_API bool wrenGetMapContainsKey(WrenVM* vm, int mapSlot, int keySlot);
+
+// Retrieves a value with the key in [keySlot] from the map in [mapSlot] and
+// stores it in [valueSlot].
+WREN_API void wrenGetMapValue(WrenVM* vm, int mapSlot, int keySlot, int valueSlot);
+
+// Takes the value stored at [valueSlot] and inserts it into the map stored
+// at [mapSlot] with key [keySlot].
+WREN_API void wrenSetMapValue(WrenVM* vm, int mapSlot, int keySlot, int valueSlot);
+
+// Removes a value from the map in [mapSlot], with the key from [keySlot],
+// and place it in [removedValueSlot]. If not found, [removedValueSlot] is
+// set to null, the same behaviour as the Wren Map API.
+WREN_API void wrenRemoveMapValue(WrenVM* vm, int mapSlot, int keySlot,
+                        int removedValueSlot);
 
 // Looks up the top level variable with [name] in resolved [module] and stores
 // it in [slot].
-void wrenGetVariable(WrenVM* vm, const char* module, const char* name,
+WREN_API void wrenGetVariable(WrenVM* vm, const char* module, const char* name,
                      int slot);
 
+// Looks up the top level variable with [name] in resolved [module], 
+// returns false if not found. The module must be imported at the time, 
+// use wrenHasModule to ensure that before calling.
+WREN_API bool wrenHasVariable(WrenVM* vm, const char* module, const char* name);
+
+// Returns true if [module] has been imported/resolved before, false if not.
+WREN_API bool wrenHasModule(WrenVM* vm, const char* module);
+
 // Sets the current fiber to be aborted, and uses the value in [slot] as the
 // runtime error object.
-void wrenAbortFiber(WrenVM* vm, int slot);
+WREN_API void wrenAbortFiber(WrenVM* vm, int slot);
 
 // Returns the user data associated with the WrenVM.
-void* wrenGetUserData(WrenVM* vm);
+WREN_API void* wrenGetUserData(WrenVM* vm);
 
 // Sets user data associated with the WrenVM.
-void wrenSetUserData(WrenVM* vm, void* userData);
+WREN_API void wrenSetUserData(WrenVM* vm, void* userData);
 
 #endif

deps/wren/include/wren.hpp

@@ -1,11 +1,11 @@
-#ifndef wren_hpp
-#define wren_hpp
-
-// This is a convenience header for users that want to compile Wren as C and
-// link to it from a C++ application.
-
-extern "C" {
-  #include "wren.h"
-}
-
-#endif
+#ifndef wren_hpp
+#define wren_hpp
+
+// This is a convenience header for users that want to compile Wren as C and
+// link to it from a C++ application.
+
+extern "C" {
+  #include "wren.h"
+}
+
+#endif