Here is what happens when you write a small pure C function and build it with Inline::C.

Start with the C function and the Inline::C support structure:

#! perl -slw
use strict; use Config;
use Inline C => Config => BUILD_NOISY => 1, CCFLAGS => $Config{ccflags
+}." -DDEBUG=1";
use Inline C => <<'END_C',  NAME => 'ICexample', CLEAN_AFTER_BUILD =>0
+;

int add( int a, int b ) {
    int result;
    result = a + b;
    return result;
}
END_C

my $a = 12345;
my $b = 23456;
my $c = add( $a, $b );

print $c;
[download]

When you run that, Inline::C wraps that C function up with an XS function to call it into a .XS file which gets XS-preprocessed to a .c file which is what gets compiled to create the dynamic llibrary (.dll/.so). Here I've thrown away a lot of boilerplate code to make it easier to see what is going on. The resultant .c file contains 3 functions.

The original C function:

int add( int a, int b ) {
    int result;
    result = a + b;
    return result;
}
[download]

A wrapper function that unpacks the input arguments from their Perl variables; calls the C function with the extracted values; and then wraps up the return value from the C function into a Perl variable for returning to the Perl code:

XS_EUPXS(XS_main_add) {
    dVAR; dXSARGS;
    int    a = (int)SvIV(ST(0))
    int    b = (int)SvIV(ST(1))
    int    RETVAL;
    dXSTARG;

    RETVAL = add(a, b);
    XSprePUSH; 
    PUSHi((IV)RETVAL);
    XSRETURN(1);
}
[download]

And finally, it adds a bootstrap function who purpose is two-fold:

1. to provide a known entrypoint that bootstrap can call in the .dll/.so; The name is always 'boot_' + the name of the dll/.so file.
2. To return the Perlish names of the function the .dll/.so exports -- these are the XS wrappers around the C functions -- and their entrypoint addresses so these can be fixed up in the Perl programs symbol table and thus become callable from Perl.

XS_EXTERNAL(boot_ICexample) {
    dVAR; dXSARGS;
    const char* file = __FILE__;

    XS_VERSION_BOOTCHECK;

    newXS("main::add", XS_main_add, file);
   XSRETURN_YES;
}
[download]

So, you should be able to see from this that you cannot avoid the XS wrapper functions because the C code would not know what to do with perl variables. And you cannot do away with the 'boot_module' entrypoint because perl would not know what functions are exported by the .dll/.so.

I strongly urge you to play with Inline::C and explore the files it creates. You'll learn far more, far more quickly that banging your head on the wall of ignorance trying to go your own way.