Question

我试图通过Inline :: C编写一个C函数，它将创建并返回一个对Perl的数组引用...下面是我的脚本和输出。我是否正在分配阵列并正确填充它？特别是，我创建了一个SV*的临时数组，并将它们传递给av_make，并返回使用newRV_noinc创建的引用。当我使用Devel :: Peek :: Dump查看返回的数组ref时，引用计数似乎很好，它看起来与直接在perl中创建的相同数据结构相同。

我还不明白什么是mortalization / sv_2mortal，或者我是否需要它。显然，Inline :: C会自动调用返回sv_2mortal的函数SV*，这些函数可能相关也可能不相关。

#!/usr/bin/env perl
use strict;
use warnings FATAL => "all";
use 5.010_000;
use Data::Dumper;
use autodie;

use Inline ('C');
use Devel::Peek;

my $from_perl = [0 .. 9];
my $from_c = inline_array_maker(10); #same as above but in C

say Dumper $from_perl;
Dump($from_perl);

say Dumper $from_c;
Dump($from_c);


__END__
__C__
SV* (int len){
    int i;
    SV ** tmp_buffer;
    AV * arr;

    tmp_buffer  = malloc(sizeof(SV*) * len);

    printf("allocating tmp_buffer of size %d\n", len);
    for (i = 0; i < len; i++) {
        tmp_buffer[i] = newSViv(i);
    }

    // is av_make the most efficient way of doing this?  
    printf("av_make\n");
    arr = av_make(len, tmp_buffer);

    printf("freeing tmp_buffer\n");
    for (i = 0; i < len; i++) {
        sv_free(tmp_buffer[i]);
    }
    free(tmp_buffer);

    return newRV_noinc(arr);
}

我得到以下输出。

allocating tmp_buffer of size 10
av_make
freeing tmp_buffer
$VAR1 = [
        0,
        1,
        2,
        3,
        4,
        5,
        6,
        7,
        8,
        9
        ];

SV = IV(0x20c7520) at 0x20c7530
REFCNT = 1
FLAGS = (PADMY,ROK)
RV = 0x21c0fa8
SV = PVAV(0x25c7ec8) at 0x21c0fa8
    REFCNT = 1
    FLAGS = ()
    ARRAY = 0x25a0e80
    FILL = 9
    MAX = 9
    ARYLEN = 0x0
    FLAGS = (REAL)
    Elt No. 0
    SV = IV(0x20b2dd8) at 0x20b2de8
    REFCNT = 1
    FLAGS = (IOK,pIOK)
    IV = 0
    Elt No. 1
    SV = IV(0x20b2fb8) at 0x20b2fc8
    REFCNT = 1
    FLAGS = (IOK,pIOK)
    IV = 1
    Elt No. 2
    SV = IV(0x20c69f8) at 0x20c6a08
    REFCNT = 1
    FLAGS = (IOK,pIOK)
    IV = 2
    Elt No. 3
    SV = IV(0x20c6a10) at 0x20c6a20
    REFCNT = 1
    FLAGS = (IOK,pIOK)
    IV = 3
$VAR1 = [
        0,
        1,
        2,
        3,
        4,
        5,
        6,
        7,
        8,
        9
        ];

SV = IV(0x20d25c8) at 0x20d25d8
REFCNT = 1
FLAGS = (PADMY,ROK)
RV = 0x25ac6b8
SV = PVAV(0x25c7ea0) at 0x25ac6b8
    REFCNT = 1
    FLAGS = ()
    ARRAY = 0x25b9140
    FILL = 9
    MAX = 9
    ARYLEN = 0x0
    FLAGS = (REAL)
    Elt No. 0
    SV = IV(0x25aca80) at 0x25aca90
    REFCNT = 1
    FLAGS = (IOK,pIOK)
    IV = 0
    Elt No. 1
    SV = IV(0x25ac750) at 0x25ac760
    REFCNT = 1
    FLAGS = (IOK,pIOK)
    IV = 1
    Elt No. 2
    SV = IV(0x25ac5e8) at 0x25ac5f8
    REFCNT = 1
    FLAGS = (IOK,pIOK)
    IV = 2
    Elt No. 3
    SV = IV(0x25ac930) at 0x25ac940
    REFCNT = 1
    FLAGS = (IOK,pIOK)
    IV = 3

Answer 1

您是否阅读过perldoc perlguts？它应该可以帮到你的大部分路。 Inline::C也可以处理AV*返回值。我可能会这样做：

#!/usr/bin/env perl

use strict;
use warnings;

use Inline C => <<'END';
  AV* make_arrayref (int size) {
    int i;
    AV* ret = newAV();
    sv_2mortal((SV*)ret);
    for(i=0; i<size; i++) {
      av_push(ret, newSViv(i) );
    }
    return ret;
  }
END

my $arrayref = make_arrayref(10);
print "$_\n" for @$arrayref;

Here is some code我写过这可能会有所帮助。

Answer 2

我还不知道什么是mortalization / sv_2mortal，或者我是否需要它。显然，Inline :: C会自动在返回SV *的函数上调用sv_2mortal，这可能与也可能不相关。

当您分配RV时，您就成了它的拥有者。如果你放弃了它，你需要减少它的引用量。但是，由于其他人没有提及它，因此可以在现场释放它。 Mortalising是一个延迟的refcount减少。它首先让调用者有机会抓住它（并递增其引用计数）。

所以是的，RV需要被诅咒，是的，类型图会为你返回一个SV *。

您的代码没有错误，但正如Joel Berger所示，您不需要预构建C数组。他的代码也很好。

他还表明，如果你的返回类型是AV*，那么typemap将创建一个（凡人）引用数组，但它不会使数组本身死亡。因此，您的两个主要退货选项是

// Return type = SV*
return newRV_noinc(arr);

和

// Return type = AV*
return MUTABLE_AV(sv_2mortal(MUTABLE_SV(newRV_noinc(arr)));

我应该如何在Inline :: C中创建并返回一个arrayref？

2 个答案: