問題描述

所以，我正在嘗試使用 SWIG 將 C 庫 (libnfc) 移植到 Java.

So, I'm trying to port a C library (libnfc) to Java using SWIG.

我已經到了編譯共享庫的地步，一個基本的nfc_version()"方法調用就可以了.但是，調用nfc_init()"進行設置會導致 SIGSEGV 錯誤.直接調用nfc庫就可以了.

I've got to the point of having a compiled shared library, and a basic "nfc_version()" method call will work. However, calling "nfc_init()" to set things up causes a SIGSEGV error. Calling the nfc library directly is fine.

我用來生成共享庫的命令:

The commands I used to generate the shared library:

swig -java -I../libnfc/include nfclib.i 
gcc -c -I/usr/lib/jvm/java-7-openjdk-i386/include/ -I/usr/lib/jvm/java-7-openjdk-i386/include/linux nfclib_wrap.c
gcc -shared nfclib_wrap.o ../build/libnfc/libnfc.so libnfc_wrap.so

libnfc.i 文件:

The libnfc.i file:

%module nfc
%{
#include <nfc/nfc.h>
#include <nfc/nfc-types.h>
#include <nfc/nfc-emulation.h>
%}

%include <nfc/nfc.h>
%include <nfc/nfc-types.h>
%include <nfc/nfc-emulation.h>

即它應該包括 libnfc 提供的所有方法.

I.e. it should include all the methods that libnfc provides.

這是我得到的錯誤日志:http://openetherpad.org/AyVDsO4XTg

Here is the error log I am getting: http://openetherpad.org/AyVDsO4XTg

顯然，從我提供的信息中可能無法找到特定的解決方案.但是任何關于嘗試的事情的建議都會非常感激(我在這里的知識已經結束了).

Obviously, it may be that a specific solution may not be available from the information I have provided. But any suggestions of things to try would be really appreciated (I'm sort of at the end of my knowledge here).

推薦答案

要始終自動將相同的指針傳遞給函數，這在 SWIG 中相當簡單.例如，給定頭"文件 test.h，它捕獲了問題的核心部分:

To always pass the same pointer in to a functions automatically it's fairly straightforward in SWIG. For example given the "header" file test.h, which captures the core part of your problem:

struct context; // only used for pointers

void init_context(struct context **ctx) { *ctx=malloc(1); printf("Init: %p
", *ctx); }
void release_context(struct context *ctx) { printf("Delete: %p
", ctx); free(ctx); }

void foo(struct context *ctx) { printf("foo: %p
", ctx); }

我們可以包裝它，并通過執行以下操作自動將全局上下文傳遞到預期的任何地方:

We can wrap it and automatically cause a global context to be passed in everywhere one is expected by doing something like:

%module test

%{
#include "test.h"

// this code gets put in the generated C output from SWIG, but not wrapped:
static struct context *get_global_ctx() {
  static struct context *ctx = NULL;
  if (!ctx) 
    init_context(&ctx);
  return ctx;
}
%}

%typemap(in,numinputs=0) struct context *ctx "$1=get_global_ctx();"

%ignore init_context; // redundant since we call it automatically

%include "test.h"

這會為 struct context *ctx 設置一個類型映射，而不是從 Java 中獲取輸入，而是在匹配的任何地方自動調用 get_global_ctx().

This sets a typemap for struct context *ctx that instead of taking an input from Java automatically calls get_global_ctx() everywhere it matches.

這可能足以讓 Java 開發人員使用一個健全的接口，但它并不理想:它強制上下文是全局的，這意味著沒有 Java 應用程序可以同時使用多個上下文.

That's probably sufficient to make a sane-ish interface for a Java developer to use, however it's less than ideal: it forces the context to be a global and means that no Java application can ever work with multiple contexts at once.

鑒于 Java 是一種 OO 語言，一個更好的解決方案是使上下文成為第一類對象.我們也可以讓 SWIG 為我們生成這樣的接口，盡管它有點復雜.我們的 SWIG 模塊文件變為:

A nicer solution, given that Java is an OO language, is to make the context become a first class Object. We can also make SWIG generate such an interface for us although it's a little more convoluted. Our SWIG module file becomes:

%module test

%{
#include "test.h"
%}

// These get called automatically, no need to expose:
%ignore init_context;
%ignore delete_context;

// Fake struct to convince SWIG it should be an object:
struct context {
  %extend {
    context() {
      // Constructor that gets called when this object is created from Java:
      struct context *ret = NULL;
      init_context(&ret); 
      return ret;
    }
    ~context() {
      release_context($self);
    }
  }
};

%include "test.h"

我們可以成功地運行這段代碼:

and we can exercise this code successfully:

public class run {
  public static void main(String[] argv) {
    System.loadLibrary("test");
    context ctx = new context();
    // You can't count on the finalizer if it exits:
    ctx.delete();
    ctx = null;
    // System.gc() might also do the trick and in a longer
    // running app it would happen at some point probably.
  }
}

給予:

Init: 0xb66dab40
Delete: 0xb66dab40

在動態類型語言中，這將是最難完成的部分——我們可以使用一種或另一種形式的元編程來根據需要插入成員函數.因此，我們可以完全按照預期說出類似 new context().foo(); 的內容.Java 是靜態類型的，所以我們需要更多的東西.我們可以通過多種方式在 SWIG 中執行此操作:

In a dynamically typed language that would be the hard part done - we could use meta programming of one form or another to insert a the member functions as needed. Thus we would be able to say something like new context().foo(); entirely as expected. Java is statically typed though so we need something more. We can do this in SWIG in a number of ways:

1. 接受我們現在可以非常高興地調用 test.foo(new context()); - 它看起來很像 Java 中的 C，所以我建議它可能是如果你最終編寫了大量看起來像 C 的 Java，代碼味道會很糟糕.

1. Accept that we can now call test.foo(new context()); quite happily - it looks a lot like C in Java still though so I'd suggest it might be a code smell if you end up writing lots of Java that looks like C.

使用 %extend (手動)將方法添加到上下文類中，test.i 中的 %extend 變為:

Use %extend to (manually) add the methods into the context class, the %extend in test.i becomes:

%extend {
    context() {
      // Constructor that gets called when this object is created from Java:
      struct context *ret = NULL;
      init_context(&ret); 
      return ret;
    }
    ~context() {
      release_context($self);
    }
    void foo() {
      foo($self);
    }
  }

%typemap(javacode) struct context %{
  public void foo() {
    $module.foo(this);
  }
%}

%module test

%{
#include "test.h"
%}

%inline %{
  struct context* make_context() {
    struct context *ctx;
    init_context(&ctx);
    return ctx;
  }
%}

%ignore init_context;

%include "test.h"

public class run {
  public static void main(String[] argv) {
    System.loadLibrary("test");
    // This object behaves exactly like an opaque pointer in C:
    SWIGTYPE_p_context ctx = test.make_context();
    test.foo(ctx);
    // Important otherwise it will leak, exactly like C
    test.release_context(ctx);
  }
}

%module test

%{
#include "test.h"
%}

%include <cpointer.i>

%pointer_functions(struct context *,context_ptr);

%include "test.h"

public class run {
  public static void main(String[] argv) {
    System.loadLibrary("test");
    SWIGTYPE_p_p_context ctx_ptr = test.new_context_ptr();
    test.init_context(ctx_ptr);
    SWIGTYPE_p_context ctx = test.context_ptr_value(ctx_ptr);
    // Don't leak the pointer to pointer, the thing it points at is untouched
    test.delete_context_ptr(ctx_ptr);
    test.foo(ctx);
    // Important otherwise it will leak, exactly like C
    test.release_context(ctx);
  }
}