Merge pull request #69 from keent/master

Problem: libfilemq not building properly

Author: hintjens

builds/msvc/vs2010/czmq.import.props

@@ -25,7 +25,7 @@
       <PreprocessorDefinitions Condition="'$(Linkage-czmq)' == 'static' Or '$(Linkage-czmq)' == 'ltcg'">LIBCZMQ_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
-      <AdditionalDependencies Condition="'$(Linkage-czmq)' != ''">libczmq.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies Condition="'$(Linkage-czmq)' != ''">czmq.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <AdditionalLibraryDirectories Condition="$(Configuration.IndexOf('Debug')) != -1">$(ProjectDir)..\..\..\..\..\czmq\bin\$(PlatformName)\Debug\$(PlatformToolset)\$(Linkage-czmq)\;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <AdditionalLibraryDirectories Condition="$(Configuration.IndexOf('Release')) != -1">$(ProjectDir)..\..\..\..\..\czmq\bin\$(PlatformName)\Release\$(PlatformToolset)\$(Linkage-czmq)\;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
     </Link>
@@ -35,24 +35,24 @@
 
   <Target Name="Linkage-czmq-dynamic" AfterTargets="AfterBuild" Condition="'$(Linkage-czmq)' == 'dynamic'">
     <Copy Condition="$(Configuration.IndexOf('Debug')) != -1"
-          SourceFiles="$(ProjectDir)..\..\..\..\..\czmq\bin\$(PlatformName)\Debug\$(PlatformToolset)\dynamic\libczmq.dll"
-          DestinationFiles="$(TargetDir)libczmq.dll"
+          SourceFiles="$(ProjectDir)..\..\..\..\..\czmq\bin\$(PlatformName)\Debug\$(PlatformToolset)\dynamic\czmq.dll"
+          DestinationFiles="$(TargetDir)czmq.dll"
           SkipUnchangedFiles="true" />
     <Copy Condition="$(Configuration.IndexOf('Debug')) != -1"
-          SourceFiles="$(ProjectDir)..\..\..\..\..\czmq\bin\$(PlatformName)\Debug\$(PlatformToolset)\dynamic\libczmq.pdb"
-          DestinationFiles="$(TargetDir)libczmq.pdb"
+          SourceFiles="$(ProjectDir)..\..\..\..\..\czmq\bin\$(PlatformName)\Debug\$(PlatformToolset)\dynamic\czmq.pdb"
+          DestinationFiles="$(TargetDir)czmq.pdb"
           SkipUnchangedFiles="true" />
     <Copy Condition="$(Configuration.IndexOf('Release')) != -1"
-          SourceFiles="$(ProjectDir)..\..\..\..\..\czmq\bin\$(PlatformName)\Release\$(PlatformToolset)\dynamic\libczmq.dll"
-          DestinationFiles="$(TargetDir)libczmq.dll"
+          SourceFiles="$(ProjectDir)..\..\..\..\..\czmq\bin\$(PlatformName)\Release\$(PlatformToolset)\dynamic\czmq.dll"
+          DestinationFiles="$(TargetDir)czmq.dll"
           SkipUnchangedFiles="true" />
   </Target>
 
   <!-- Messages -->
 
   <Target Name="czmq-info" BeforeTargets="AfterBuild" Condition="'$(Linkage-czmq)' == 'dynamic'">
-    <Message Text="Copying libczmq.dll -&gt; $(TargetDir)libczmq.dll" Importance="high"/>
-    <Message Text="Copying libczmq.pdb -&gt; $(TargetDir)libczmq.pdb" Importance="high" Condition="$(Configuration.IndexOf('Debug')) != -1" />
+    <Message Text="Copying czmq.dll -&gt; $(TargetDir)czmq.dll" Importance="high"/>
+    <Message Text="Copying czmq.pdb -&gt; $(TargetDir)czmq.pdb" Importance="high" Condition="$(Configuration.IndexOf('Debug')) != -1" />
   </Target>
 <!--
 ################################################################################

include/filemq_library.h

@@ -50,6 +50,7 @@
 //  Opaque class structures to allow forward references
 
 //  Draft APIs, excluded by default in stable releases
+#define WITH_DRAFTS
 #ifdef WITH_DRAFTS
 typedef struct _fmq_msg_t fmq_msg_t;
 #define FMQ_MSG_T_DEFINED
@@ -63,6 +64,7 @@ typedef struct _fmq_client_t fmq_client_t;
 
 //  Draft APIs, excluded by default in stable releases
 #ifdef WITH_DRAFTS
+#include "filemq_prelude.h"
 #include "fmq_msg.h"
 #include "fmq_server.h"
 #include "fmq_client.h"

include/filemq_prelude.h

@@ -0,0 +1,17 @@
+//- Non-portable declaration specifiers -------------------------------------
+
+#define LIBFMQ_EXPORTS // temporary declaration
+
+#if defined (__WINDOWS__)
+#   if defined LIBFMQ_STATIC
+#       define FMQ_EXPORT
+#   elif defined LIBFMQ_EXPORTS
+#       define FMQ_EXPORT __declspec(dllexport)
+#   else
+#       define FMQ_EXPORT __declspec(dllimport)
+#   endif
+#else
+#   define FMQ_EXPORT
+#endif
+
+

include/fmq_client.h

@@ -24,6 +24,7 @@
 #define FMQ_CLIENT_H_INCLUDED
 
 #include <czmq.h>
+#include <filemq_prelude.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -38,59 +39,59 @@ typedef struct _fmq_client_t fmq_client_t;
 //  @interface
 //  Create a new fmq_client, return the reference if successful, or NULL
 //  if construction failed due to lack of available memory.
-fmq_client_t *
+FMQ_EXPORT fmq_client_t *
     fmq_client_new (void);
 
 //  Destroy the fmq_client and free all memory used by the object.
-void
+FMQ_EXPORT void
     fmq_client_destroy (fmq_client_t **self_p);
 
 //  Return actor, when caller wants to work with multiple actors and/or
 //  input sockets asynchronously.
-zactor_t *
+FMQ_EXPORT zactor_t *
     fmq_client_actor (fmq_client_t *self);
 
 //  Return message pipe for asynchronous message I/O. In the high-volume case,
 //  we send methods and get replies to the actor, in a synchronous manner, and
 //  we send/recv high volume message data to a second pipe, the msgpipe. In
 //  the low-volume case we can do everything over the actor pipe, if traffic
 //  is never ambiguous.
-zsock_t *
+FMQ_EXPORT zsock_t *
     fmq_client_msgpipe (fmq_client_t *self);
 
 //  Return true if client is currently connected, else false. Note that the
 //  client will automatically re-connect if the server dies and restarts after
 //  a successful first connection.
-bool
+FMQ_EXPORT bool
     fmq_client_connected (fmq_client_t *self);
 
 //  Connect to server endpoint, with specified timeout in msecs (zero means wait    
 //  forever). Connect succeeds if connection is successful.                         
 //  Returns >= 0 if successful, -1 if interrupted.
-uint8_t 
+FMQ_EXPORT uint8_t 
     fmq_client_connect (fmq_client_t *self, const char *endpoint, uint32_t timeout);
 
 //  Subscribe to a directory on the server, directory specified by path.            
 //  Returns >= 0 if successful, -1 if interrupted.
-uint8_t 
+FMQ_EXPORT uint8_t 
     fmq_client_subscribe (fmq_client_t *self, const char *path);
 
 //  Tell the api where to store files. This should be done before subscribing to    
 //  anything.                                                                       
 //  Returns >= 0 if successful, -1 if interrupted.
-uint8_t 
+FMQ_EXPORT uint8_t 
     fmq_client_set_inbox (fmq_client_t *self, const char *path);
 
 //  Return last received status
-uint8_t 
+FMQ_EXPORT uint8_t 
     fmq_client_status (fmq_client_t *self);
 
 //  Return last received reason
-const char *
+FMQ_EXPORT const char *
     fmq_client_reason (fmq_client_t *self);
 
 //  Self test of this class
-void
+FMQ_EXPORT void
     fmq_client_test (bool verbose);
 
 //  To enable verbose tracing (animation) of fmq_client instances, set

include/fmq_msg.h

@@ -83,6 +83,7 @@
 #define FMQ_MSG_RTFM                        129
 
 #include <czmq.h>
+#include <filemq_prelude.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -96,131 +97,131 @@ typedef struct _fmq_msg_t fmq_msg_t;
 
 //  @interface
 //  Create a new empty fmq_msg
-fmq_msg_t *
+FMQ_EXPORT fmq_msg_t *
     fmq_msg_new (void);
 
 //  Destroy a fmq_msg instance
-void
+FMQ_EXPORT void
     fmq_msg_destroy (fmq_msg_t **self_p);
 
 //  Receive a fmq_msg from the socket. Returns 0 if OK, -1 if
 //  there was an error. Blocks if there is no message waiting.
-int
+FMQ_EXPORT int
     fmq_msg_recv (fmq_msg_t *self, zsock_t *input);
 
 //  Send the fmq_msg to the output socket, does not destroy it
-int
+FMQ_EXPORT int
     fmq_msg_send (fmq_msg_t *self, zsock_t *output);
 
 
 //  Print contents of message to stdout
-void
+FMQ_EXPORT void
     fmq_msg_print (fmq_msg_t *self);
 
 //  Get/set the message routing id
-zframe_t *
+FMQ_EXPORT zframe_t *
     fmq_msg_routing_id (fmq_msg_t *self);
-void
+FMQ_EXPORT void
     fmq_msg_set_routing_id (fmq_msg_t *self, zframe_t *routing_id);
 
 //  Get the fmq_msg id and printable command
-int
+FMQ_EXPORT int
     fmq_msg_id (fmq_msg_t *self);
-void
+FMQ_EXPORT void
     fmq_msg_set_id (fmq_msg_t *self, int id);
-const char *
+FMQ_EXPORT const char *
     fmq_msg_command (fmq_msg_t *self);
 
 //  Get/set the path field
-const char *
+FMQ_EXPORT const char *
     fmq_msg_path (fmq_msg_t *self);
-void
+FMQ_EXPORT void
     fmq_msg_set_path (fmq_msg_t *self, const char *value);
 
 //  Get a copy of the options field
-zhash_t *
+FMQ_EXPORT zhash_t *
     fmq_msg_options (fmq_msg_t *self);
 //  Get the options field and transfer ownership to caller
-zhash_t *
+FMQ_EXPORT zhash_t *
     fmq_msg_get_options (fmq_msg_t *self);
 //  Set the options field, transferring ownership from caller
-void
+FMQ_EXPORT void
     fmq_msg_set_options (fmq_msg_t *self, zhash_t **hash_p);
 
 //  Get a copy of the cache field
-zhash_t *
+FMQ_EXPORT zhash_t *
     fmq_msg_cache (fmq_msg_t *self);
 //  Get the cache field and transfer ownership to caller
-zhash_t *
+FMQ_EXPORT zhash_t *
     fmq_msg_get_cache (fmq_msg_t *self);
 //  Set the cache field, transferring ownership from caller
-void
+FMQ_EXPORT void
     fmq_msg_set_cache (fmq_msg_t *self, zhash_t **hash_p);
 
 //  Get/set the credit field
-uint64_t
+FMQ_EXPORT uint64_t
     fmq_msg_credit (fmq_msg_t *self);
-void
+FMQ_EXPORT void
     fmq_msg_set_credit (fmq_msg_t *self, uint64_t credit);
 
 //  Get/set the sequence field
-uint64_t
+FMQ_EXPORT uint64_t
     fmq_msg_sequence (fmq_msg_t *self);
-void
+FMQ_EXPORT void
     fmq_msg_set_sequence (fmq_msg_t *self, uint64_t sequence);
 
 //  Get/set the operation field
-byte
+FMQ_EXPORT byte
     fmq_msg_operation (fmq_msg_t *self);
-void
+FMQ_EXPORT void
     fmq_msg_set_operation (fmq_msg_t *self, byte operation);
 
 //  Get/set the filename field
-const char *
+FMQ_EXPORT const char *
     fmq_msg_filename (fmq_msg_t *self);
-void
+FMQ_EXPORT void
     fmq_msg_set_filename (fmq_msg_t *self, const char *value);
 
 //  Get/set the offset field
-uint64_t
+FMQ_EXPORT uint64_t
     fmq_msg_offset (fmq_msg_t *self);
-void
+FMQ_EXPORT void
     fmq_msg_set_offset (fmq_msg_t *self, uint64_t offset);
 
 //  Get/set the eof field
-byte
+FMQ_EXPORT byte
     fmq_msg_eof (fmq_msg_t *self);
-void
+FMQ_EXPORT void
     fmq_msg_set_eof (fmq_msg_t *self, byte eof);
 
 //  Get a copy of the headers field
-zhash_t *
+FMQ_EXPORT zhash_t *
     fmq_msg_headers (fmq_msg_t *self);
 //  Get the headers field and transfer ownership to caller
-zhash_t *
+FMQ_EXPORT zhash_t *
     fmq_msg_get_headers (fmq_msg_t *self);
 //  Set the headers field, transferring ownership from caller
-void
+FMQ_EXPORT void
     fmq_msg_set_headers (fmq_msg_t *self, zhash_t **hash_p);
 
 //  Get a copy of the chunk field
-zchunk_t *
+FMQ_EXPORT zchunk_t *
     fmq_msg_chunk (fmq_msg_t *self);
 //  Get the chunk field and transfer ownership to caller
-zchunk_t *
+FMQ_EXPORT zchunk_t *
     fmq_msg_get_chunk (fmq_msg_t *self);
 //  Set the chunk field, transferring ownership from caller
-void
+FMQ_EXPORT void
     fmq_msg_set_chunk (fmq_msg_t *self, zchunk_t **chunk_p);
 
 //  Get/set the reason field
-const char *
+FMQ_EXPORT const char *
     fmq_msg_reason (fmq_msg_t *self);
-void
+FMQ_EXPORT void
     fmq_msg_set_reason (fmq_msg_t *self, const char *value);
 
 //  Self test of this class
-void
+FMQ_EXPORT void
     fmq_msg_test (bool verbose);
 //  @end
 

include/fmq_server.h

@@ -80,11 +80,11 @@ extern "C" {
 //
 //  This is the fmq_server constructor as a zactor_fn:
 //
-void
+FMQ_EXPORT void
     fmq_server (zsock_t *pipe, void *args);
 
 //  Self test of this class
-void
+FMQ_EXPORT void
     fmq_server_test (bool verbose);
 //  @end