Use ord instead of int

libplum/libplum.nim

@@ -52,42 +52,40 @@ type
   plum_log_level_t* {.
     importc: "plum_log_level_t", header: "plum.h", size: sizeof(cint)
   .} = enum
-    PLUM_LOG_LEVEL_VERBOSE = 0
-    PLUM_LOG_LEVEL_DEBUG = 1
-    PLUM_LOG_LEVEL_INFO = 2
-    PLUM_LOG_LEVEL_WARN = 3
-    PLUM_LOG_LEVEL_ERROR = 4
-    PLUM_LOG_LEVEL_FATAL = 5
-    PLUM_LOG_LEVEL_NONE = 6
+    PLUM_LOG_LEVEL_VERBOSE
+    PLUM_LOG_LEVEL_DEBUG
+    PLUM_LOG_LEVEL_INFO
+    PLUM_LOG_LEVEL_WARN
+    PLUM_LOG_LEVEL_ERROR
+    PLUM_LOG_LEVEL_FATAL
+    PLUM_LOG_LEVEL_NONE
 
   plum_ip_protocol_t* {.
     importc: "plum_ip_protocol_t", header: "plum.h", size: sizeof(cint)
   .} = enum
-    PLUM_IP_PROTOCOL_TCP = 0
-    PLUM_IP_PROTOCOL_UDP = 1
+    PLUM_IP_PROTOCOL_TCP
+    PLUM_IP_PROTOCOL_UDP
 
-  plum_protocol_t* {.
-    importc: "plum_protocol_t", header: "plum.h", size: sizeof(cint)
-  .} = enum
-    PLUM_PROTOCOL_ANY = 0
-    PLUM_PROTOCOL_PCP = 1
-    PLUM_PROTOCOL_UPNP = 2
+  plum_protocol_t* {.importc: "plum_protocol_t", header: "plum.h", size: sizeof(cint).} = enum
+    PLUM_PROTOCOL_ANY
+    PLUM_PROTOCOL_PCP
+    PLUM_PROTOCOL_UPNP
 
   plum_state_t* {.importc: "plum_state_t", header: "plum.h", size: sizeof(cint).} = enum
-    PLUM_STATE_DESTROYED = 0
-    PLUM_STATE_PENDING = 1
-    PLUM_STATE_SUCCESS = 2
-    PLUM_STATE_FAILURE = 3
-    PLUM_STATE_DESTROYING = 4
+    PLUM_STATE_DESTROYED
+    PLUM_STATE_PENDING
+    PLUM_STATE_SUCCESS
+    PLUM_STATE_FAILURE
+    PLUM_STATE_DESTROYING
 
   plum_mapping_protocol_t* {.
     importc: "plum_mapping_protocol_t", header: "plum.h", size: sizeof(cint)
   .} = enum
-    PLUM_MAPPING_PROTOCOL_UNKNOWN = 0
-    PLUM_MAPPING_PROTOCOL_PCP = 1
-    PLUM_MAPPING_PROTOCOL_NATPMP = 2
-    PLUM_MAPPING_PROTOCOL_UPNP = 3
-    PLUM_MAPPING_PROTOCOL_DIRECT = 4
+    PLUM_MAPPING_PROTOCOL_UNKNOWN
+    PLUM_MAPPING_PROTOCOL_PCP
+    PLUM_MAPPING_PROTOCOL_NATPMP
+    PLUM_MAPPING_PROTOCOL_UPNP
+    PLUM_MAPPING_PROTOCOL_DIRECT
 
   # Define the callback to receive the plum logs
   plum_log_callback_t* = proc(level: plum_log_level_t, message: cstring) {.cdecl.}
@@ -103,8 +101,7 @@ type
       # msecs, 0 means use default (10000)
     recheck_period* {.importc: "recheck_period".}: cint
       # msecs, 0 means use default (300000)
-    protocol* {.importc: "protocol".}: plum_protocol_t
-      # PLUM_PROTOCOL_ANY means try all
+    protocol* {.importc: "protocol".}: plum_protocol_t # PLUM_PROTOCOL_ANY means try all
 
   # Define the mapping struct, passed by copy (usual for struct).
   # The user_ptr is a pointer to the MappingHandle in order to receive the result

libplum/plum.nim

@@ -34,36 +34,36 @@ export results
 
 type
   PlumProtocol* = enum
-    TCP = PLUM_IP_PROTOCOL_TCP.int
-    UDP = PLUM_IP_PROTOCOL_UDP.int
+    TCP = ord(PLUM_IP_PROTOCOL_TCP)
+    UDP = ord(PLUM_IP_PROTOCOL_UDP)
 
   ProtocolFilter* {.pure.} = enum
-    Any = PLUM_PROTOCOL_ANY.int
-    PCP = PLUM_PROTOCOL_PCP.int
-    UPnP = PLUM_PROTOCOL_UPNP.int
+    Any = ord(PLUM_PROTOCOL_ANY)
+    PCP = ord(PLUM_PROTOCOL_PCP)
+    UPnP = ord(PLUM_PROTOCOL_UPNP)
 
   PlumLogLevel* {.pure.} = enum
-    Verbose = PLUM_LOG_LEVEL_VERBOSE.int
-    Debug = PLUM_LOG_LEVEL_DEBUG.int
-    Info = PLUM_LOG_LEVEL_INFO.int
-    Warn = PLUM_LOG_LEVEL_WARN.int
-    Error = PLUM_LOG_LEVEL_ERROR.int
-    Fatal = PLUM_LOG_LEVEL_FATAL.int
-    None = PLUM_LOG_LEVEL_NONE.int
+    Verbose = ord(PLUM_LOG_LEVEL_VERBOSE)
+    Debug = ord(PLUM_LOG_LEVEL_DEBUG)
+    Info = ord(PLUM_LOG_LEVEL_INFO)
+    Warn = ord(PLUM_LOG_LEVEL_WARN)
+    Error = ord(PLUM_LOG_LEVEL_ERROR)
+    Fatal = ord(PLUM_LOG_LEVEL_FATAL)
+    None = ord(PLUM_LOG_LEVEL_NONE)
 
   PlumState* = enum
-    Destroyed = PLUM_STATE_DESTROYED.int
-    Pending = PLUM_STATE_PENDING.int
-    Success = PLUM_STATE_SUCCESS.int
-    Failure = PLUM_STATE_FAILURE.int
-    Destroying = PLUM_STATE_DESTROYING.int
+    Destroyed = ord(PLUM_STATE_DESTROYED)
+    Pending = ord(PLUM_STATE_PENDING)
+    Success = ord(PLUM_STATE_SUCCESS)
+    Failure = ord(PLUM_STATE_FAILURE)
+    Destroying = ord(PLUM_STATE_DESTROYING)
 
   MappingProtocol* = enum
-    Unknown = PLUM_MAPPING_PROTOCOL_UNKNOWN.int
-    PCP = PLUM_MAPPING_PROTOCOL_PCP.int
-    NatPmp = PLUM_MAPPING_PROTOCOL_NATPMP.int
-    UPnP = PLUM_MAPPING_PROTOCOL_UPNP.int
-    Direct = PLUM_MAPPING_PROTOCOL_DIRECT.int
+    Unknown = ord(PLUM_MAPPING_PROTOCOL_UNKNOWN)
+    PCP = ord(PLUM_MAPPING_PROTOCOL_PCP)
+    NatPmp = ord(PLUM_MAPPING_PROTOCOL_NATPMP)
+    UPnP = ord(PLUM_MAPPING_PROTOCOL_UPNP)
+    Direct = ord(PLUM_MAPPING_PROTOCOL_DIRECT)
 
   PlumMapping* = object
     protocol*: PlumProtocol