add WREN_API declaration for proper symbol export

Brought up by @Orcolom

Detected for MSVC or similar and can be explicitly activated by defining WREN_API_DLLEXPORT (or manually defining WREN_API to __declspec( dllexport ) before include).

Can be disabled by using a blank `#define WREN_API` before include.

Note: to use the import variant, `#define WREN_API __declspec(dllimport)` before including the wren header.

Author: ruby0x1

src/include/wren.h

@@ -19,6 +19,14 @@
                              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
@@ -291,24 +299,24 @@ typedef enum
 // 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
@@ -319,7 +327,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.
@@ -331,11 +339,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
@@ -375,23 +383,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].
 //
@@ -403,19 +411,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].
 //
@@ -424,25 +432,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].
@@ -453,89 +461,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].
-void wrenSetSlotNewMap(WrenVM* vm, int 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]. 
-void wrenSetListElement(WrenVM* vm, int listSlot, int index, int 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].
-int wrenGetMapCount(WrenVM* vm, int slot);
+WREN_API int wrenGetMapCount(WrenVM* vm, int slot);
 
 // Returns true if the key in [keySlot] is found in the map placed in [mapSlot].
-bool wrenGetMapContainsKey(WrenVM* vm, int mapSlot, int keySlot);
+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].
-void wrenGetMapValue(WrenVM* vm, int mapSlot, int keySlot, int 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].
-void wrenSetMapValue(WrenVM* vm, int mapSlot, int keySlot, int valueSlot);
+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.
-void wrenRemoveMapValue(WrenVM* vm, int mapSlot, int keySlot,
+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.
-bool wrenHasVariable(WrenVM* vm, const char* module, const char* name);
+WREN_API bool wrenHasVariable(WrenVM* vm, const char* module, const char* name);
 
 // Returns true if [module] has been imported/resolved before, false if not.
-bool wrenHasModule(WrenVM* vm, const char* module);
+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