search

gosexy / redis

Redis client for Go that maps the full redis command list into equivalent Go functions.
MIT License
167 stars 44 forks source link

Installation failed on FreeBSD 10 #32

Closed wowi42 closed 9 years ago

wowi42 commented 10 years ago

HI, I installed hiredis, and I have this bug:

$ go get -u menteslibres.net/gosexy/redis
# menteslibres.net/gosexy/redis
cc did not produce error at completed:1
on input:
#line 31 "/home/loic/gocode/src/menteslibres.net/gosexy/redis/main.go"

#include <stdarg.h>
#include <stdlib.h>

#include "net.h"
#include "sds.h"
#include "hiredis.h"
#include "async.h"

typedef struct redisEvent {

} redisEvent;

// Redis events with goroutines.
typedef struct redisGoroutineEvents {
        redisAsyncContext *context;
} redisGoroutineEvents;

int redisGetReplyType(redisReply *);

struct timeval redisTimeVal(long, long);
void getCallback(redisAsyncContext *, void *, void *);

int redisGetReplyType(redisReply *);
int redisAsyncCommandArgvWrapper(redisAsyncContext *, void *, int, const char **, const size_t *);
redisReply *redisReplyGetElement(redisReply *, int i);

int redisGoroutineAttach(redisAsyncContext *, redisEvent *);
void redisGoroutineWriteEvent(void *);
void redisGoroutineReadEvent(void *);
void redisForceAsyncFree(redisAsyncContext *);
void redisAsyncSetCallbacks(redisAsyncContext *);

#include <sys/types.h> /* for size_t below */

/* Define intgo when compiling with GCC.  */
#ifdef __PTRDIFF_TYPE__
typedef __PTRDIFF_TYPE__ intgo;
#elif defined(_LP64)
typedef long long intgo;
#else
typedef int intgo;
#endif

typedef struct { char *p; intgo n; } _GoString_;
typedef struct { char *p; intgo n; intgo c; } _GoBytes_;
_GoString_ GoString(char *p);
_GoString_ GoStringN(char *p, int l);
_GoBytes_ GoBytes(void *p, int n);
char *CString(_GoString_);
void *_CMalloc(size_t);
#line 1 "not-declared"
void __cgo_f_1_1(void) { __typeof__(freeReplyObject) *__cgo_undefined__; }
#line 1 "not-type"
void __cgo_f_1_2(void) { freeReplyObject *__cgo_undefined__; }
#line 1 "not-const"
void __cgo_f_1_3(void) { enum { __cgo__undefined__ = (freeReplyObject)*1 }; }
#line 2 "not-declared"
void __cgo_f_2_1(void) { __typeof__(redisFree) *__cgo_undefined__; }
#line 2 "not-type"
void __cgo_f_2_2(void) { redisFree *__cgo_undefined__; }
#line 2 "not-const"
void __cgo_f_2_3(void) { enum { __cgo__undefined__ = (redisFree)*1 }; }
#line 3 "not-declared"
void __cgo_f_3_1(void) { __typeof__(redisAsyncInitialize) *__cgo_undefined__; }
#line 3 "not-type"
void __cgo_f_3_2(void) { redisAsyncInitialize *__cgo_undefined__; }
#line 3 "not-const"
void __cgo_f_3_3(void) { enum { __cgo__undefined__ = (redisAsyncInitialize)*1 }; }
#line 4 "not-declared"
void __cgo_f_4_1(void) { __typeof__(GoString) *__cgo_undefined__; }
#line 4 "not-type"
void __cgo_f_4_2(void) { GoString *__cgo_undefined__; }
#line 4 "not-const"
void __cgo_f_4_3(void) { enum { __cgo__undefined__ = (GoString)*1 }; }
#line 5 "not-declared"
void __cgo_f_5_1(void) { __typeof__(redisAsyncCommandArgvWrapper) *__cgo_undefined__; }
#line 5 "not-type"
void __cgo_f_5_2(void) { redisAsyncCommandArgvWrapper *__cgo_undefined__; }
#line 5 "not-const"
void __cgo_f_5_3(void) { enum { __cgo__undefined__ = (redisAsyncCommandArgvWrapper)*1 }; }
#line 6 "not-declared"
void __cgo_f_6_1(void) { __typeof__(size_t) *__cgo_undefined__; }
#line 6 "not-type"
void __cgo_f_6_2(void) { size_t *__cgo_undefined__; }
#line 6 "not-const"
void __cgo_f_6_3(void) { enum { __cgo__undefined__ = (size_t)*1 }; }
#line 7 "not-declared"
void __cgo_f_7_1(void) { __typeof__(redisAsyncContext) *__cgo_undefined__; }
#line 7 "not-type"
void __cgo_f_7_2(void) { redisAsyncContext *__cgo_undefined__; }
#line 7 "not-const"
void __cgo_f_7_3(void) { enum { __cgo__undefined__ = (redisAsyncContext)*1 }; }
#line 8 "not-declared"
void __cgo_f_8_1(void) { __typeof__(redisContext) *__cgo_undefined__; }
#line 8 "not-type"
void __cgo_f_8_2(void) { redisContext *__cgo_undefined__; }
#line 8 "not-const"
void __cgo_f_8_3(void) { enum { __cgo__undefined__ = (redisContext)*1 }; }
#line 9 "not-declared"
void __cgo_f_9_1(void) { __typeof__(redisGoroutineEvents) *__cgo_undefined__; }
#line 9 "not-type"
void __cgo_f_9_2(void) { redisGoroutineEvents *__cgo_undefined__; }
#line 9 "not-const"
void __cgo_f_9_3(void) { enum { __cgo__undefined__ = (redisGoroutineEvents)*1 }; }
#line 10 "not-declared"
void __cgo_f_10_1(void) { __typeof__(redisGoroutineWriteEvent) *__cgo_undefined__; }
#line 10 "not-type"
void __cgo_f_10_2(void) { redisGoroutineWriteEvent *__cgo_undefined__; }
#line 10 "not-const"
void __cgo_f_10_3(void) { enum { __cgo__undefined__ = (redisGoroutineWriteEvent)*1 }; }
#line 11 "not-declared"
void __cgo_f_11_1(void) { __typeof__(CString) *__cgo_undefined__; }
#line 11 "not-type"
void __cgo_f_11_2(void) { CString *__cgo_undefined__; }
#line 11 "not-const"
void __cgo_f_11_3(void) { enum { __cgo__undefined__ = (CString)*1 }; }
#line 12 "not-declared"
void __cgo_f_12_1(void) { __typeof__(redisConnectUnixWithTimeout) *__cgo_undefined__; }
#line 12 "not-type"
void __cgo_f_12_2(void) { redisConnectUnixWithTimeout *__cgo_undefined__; }
#line 12 "not-const"
void __cgo_f_12_3(void) { enum { __cgo__undefined__ = (redisConnectUnixWithTimeout)*1 }; }
#line 13 "not-declared"
void __cgo_f_13_1(void) { __typeof__(redisTimeVal) *__cgo_undefined__; }
#line 13 "not-type"
void __cgo_f_13_2(void) { redisTimeVal *__cgo_undefined__; }
#line 13 "not-const"
void __cgo_f_13_3(void) { enum { __cgo__undefined__ = (redisTimeVal)*1 }; }
#line 14 "not-declared"
void __cgo_f_14_1(void) { __typeof__(redisEvent) *__cgo_undefined__; }
#line 14 "not-type"
void __cgo_f_14_2(void) { redisEvent *__cgo_undefined__; }
#line 14 "not-const"
void __cgo_f_14_3(void) { enum { __cgo__undefined__ = (redisEvent)*1 }; }
#line 15 "not-declared"
void __cgo_f_15_1(void) { __typeof__(redisConnectUnixNonBlock) *__cgo_undefined__; }
#line 15 "not-type"
void __cgo_f_15_2(void) { redisConnectUnixNonBlock *__cgo_undefined__; }
#line 15 "not-const"
void __cgo_f_15_3(void) { enum { __cgo__undefined__ = (redisConnectUnixNonBlock)*1 }; }
#line 16 "not-declared"
void __cgo_f_16_1(void) { __typeof__(GoStringN) *__cgo_undefined__; }
#line 16 "not-type"
void __cgo_f_16_2(void) { GoStringN *__cgo_undefined__; }
#line 16 "not-const"
void __cgo_f_16_3(void) { enum { __cgo__undefined__ = (GoStringN)*1 }; }
#line 17 "not-declared"
void __cgo_f_17_1(void) { __typeof__(redisReplyGetElement) *__cgo_undefined__; }
#line 17 "not-type"
void __cgo_f_17_2(void) { redisReplyGetElement *__cgo_undefined__; }
#line 17 "not-const"
void __cgo_f_17_3(void) { enum { __cgo__undefined__ = (redisReplyGetElement)*1 }; }
#line 18 "not-declared"
void __cgo_f_18_1(void) { __typeof__(redisConnectWithTimeout) *__cgo_undefined__; }
#line 18 "not-type"
void __cgo_f_18_2(void) { redisConnectWithTimeout *__cgo_undefined__; }
#line 18 "not-const"
void __cgo_f_18_3(void) { enum { __cgo__undefined__ = (redisConnectWithTimeout)*1 }; }
#line 19 "not-declared"
void __cgo_f_19_1(void) { __typeof__(char) *__cgo_undefined__; }
#line 19 "not-type"
void __cgo_f_19_2(void) { char *__cgo_undefined__; }
#line 19 "not-const"
void __cgo_f_19_3(void) { enum { __cgo__undefined__ = (char)*1 }; }
#line 20 "not-declared"
void __cgo_f_20_1(void) { __typeof__(redisGoroutineReadEvent) *__cgo_undefined__; }
#line 20 "not-type"
void __cgo_f_20_2(void) { redisGoroutineReadEvent *__cgo_undefined__; }
#line 20 "not-const"
void __cgo_f_20_3(void) { enum { __cgo__undefined__ = (redisGoroutineReadEvent)*1 }; }
#line 21 "not-declared"
void __cgo_f_21_1(void) { __typeof__(int) *__cgo_undefined__; }
#line 21 "not-type"
void __cgo_f_21_2(void) { int *__cgo_undefined__; }
#line 21 "not-const"
void __cgo_f_21_3(void) { enum { __cgo__undefined__ = (int)*1 }; }
#line 22 "not-declared"
void __cgo_f_22_1(void) { __typeof__(redisConnect) *__cgo_undefined__; }
#line 22 "not-type"
void __cgo_f_22_2(void) { redisConnect *__cgo_undefined__; }
#line 22 "not-const"
void __cgo_f_22_3(void) { enum { __cgo__undefined__ = (redisConnect)*1 }; }
#line 23 "not-declared"
void __cgo_f_23_1(void) { __typeof__(redisConnectNonBlock) *__cgo_undefined__; }
#line 23 "not-type"
void __cgo_f_23_2(void) { redisConnectNonBlock *__cgo_undefined__; }
#line 23 "not-const"
void __cgo_f_23_3(void) { enum { __cgo__undefined__ = (redisConnectNonBlock)*1 }; }
#line 24 "not-declared"
void __cgo_f_24_1(void) { __typeof__(redisForceAsyncFree) *__cgo_undefined__; }
#line 24 "not-type"
void __cgo_f_24_2(void) { redisForceAsyncFree *__cgo_undefined__; }
#line 24 "not-const"
void __cgo_f_24_3(void) { enum { __cgo__undefined__ = (redisForceAsyncFree)*1 }; }
#line 25 "not-declared"
void __cgo_f_25_1(void) { __typeof__(long) *__cgo_undefined__; }
#line 25 "not-type"
void __cgo_f_25_2(void) { long *__cgo_undefined__; }
#line 25 "not-const"
void __cgo_f_25_3(void) { enum { __cgo__undefined__ = (long)*1 }; }
#line 26 "not-declared"
void __cgo_f_26_1(void) { __typeof__(__redisAsyncCopyError) *__cgo_undefined__; }
#line 26 "not-type"
void __cgo_f_26_2(void) { __redisAsyncCopyError *__cgo_undefined__; }
#line 26 "not-const"
void __cgo_f_26_3(void) { enum { __cgo__undefined__ = (__redisAsyncCopyError)*1 }; }
#line 27 "not-declared"
void __cgo_f_27_1(void) { __typeof__(redisGoroutineAttach) *__cgo_undefined__; }
#line 27 "not-type"
void __cgo_f_27_2(void) { redisGoroutineAttach *__cgo_undefined__; }
#line 27 "not-const"
void __cgo_f_27_3(void) { enum { __cgo__undefined__ = (redisGoroutineAttach)*1 }; }
#line 28 "not-declared"
void __cgo_f_28_1(void) { __typeof__(free) *__cgo_undefined__; }
#line 28 "not-type"
void __cgo_f_28_2(void) { free *__cgo_undefined__; }
#line 28 "not-const"
void __cgo_f_28_3(void) { enum { __cgo__undefined__ = (free)*1 }; }
#line 29 "not-declared"
void __cgo_f_29_1(void) { __typeof__(redisCommandArgv) *__cgo_undefined__; }
#line 29 "not-type"
void __cgo_f_29_2(void) { redisCommandArgv *__cgo_undefined__; }
#line 29 "not-const"
void __cgo_f_29_3(void) { enum { __cgo__undefined__ = (redisCommandArgv)*1 }; }
#line 30 "not-declared"
void __cgo_f_30_1(void) { __typeof__(redisAsyncSetCallbacks) *__cgo_undefined__; }
#line 30 "not-type"
void __cgo_f_30_2(void) { redisAsyncSetCallbacks *__cgo_undefined__; }
#line 30 "not-const"
void __cgo_f_30_3(void) { enum { __cgo__undefined__ = (redisAsyncSetCallbacks)*1 }; }
#line 31 "not-declared"
void __cgo_f_31_1(void) { __typeof__(redisConnectUnix) *__cgo_undefined__; }
#line 31 "not-type"
void __cgo_f_31_2(void) { redisConnectUnix *__cgo_undefined__; }
#line 31 "not-const"
void __cgo_f_31_3(void) { enum { __cgo__undefined__ = (redisConnectUnix)*1 }; }
#line 32 "not-declared"
void __cgo_f_32_1(void) { __typeof__(redisReply) *__cgo_undefined__; }
#line 32 "not-type"
void __cgo_f_32_2(void) { redisReply *__cgo_undefined__; }
#line 32 "not-const"
void __cgo_f_32_3(void) { enum { __cgo__undefined__ = (redisReply)*1 }; }
#line 33 "not-declared"
void __cgo_f_33_1(void) { __typeof__(redisGetReplyType) *__cgo_undefined__; }
#line 33 "not-type"
void __cgo_f_33_2(void) { redisGetReplyType *__cgo_undefined__; }
#line 33 "not-const"
void __cgo_f_33_3(void) { enum { __cgo__undefined__ = (redisGetReplyType)*1 }; }
#line 1 "completed"
int __cgo__1 = __cgo__2;
xiam commented 9 years ago

We no longer depend on CGO, so the build should be working again.