https://linen.dev logo
Powered by
# haxe-ui
  • r
    It a C struct with the following fields:
    Copy code
    c
struct dirent {
  int d_ino;
  int d_off;
  unsigned short d_reclen;
  unsigned char d_type;
  char[20] d_name;
};
    Yes it's an extern to a linux specific structure for a oom-killer that I was writing
  • b
    fyi:
    Copy code
    haxe
var x:Star<Int16>;
var y:RawPointer<Int16>;
    generates:
    Copy code
    cpp
short * x;
short* y;
    So yeah, same, i prefer RawPointer personally, but good to know
  • r
    The first 4 were easy to figure out
  • r
    It's good to know this, it can come in handy
  • b
    right, but you, presumably are going to pass this into a function?
  • b
    (the dirent struct)
  • r
    No, the 
    readdir
    C function returns a pointer to a 
    struct dirent
    but the d_name field returns 
    true
    for some reason
  • b
    i think thats because its non-zero (ie, not null)
  • r
    If it were a *char I could have just used 
    cpp.Star<Char>
  • b
    but you are now trying to use it in haxe, char* doesnt mean anything... you, presumably, have a pointer to a string in memory, now you just need to turn it into a haxe string
  • b
    what does your extern look like?
  • b
    i mean, for 
    struct dirent
  • r
    Copy code
    haxe
@:include("dirent.h")
@:native("struct dirent")
@:structAccess
extern class DirEnt {
    @:native("d_ino")
    var inodeNumber:Int;

    @:native("d_off")
    var offset:Int;

    @:native("d_reclen")
    var recordLength:UInt16;

    @:native("d_type")
    var type:UInt8;

    @:native("d_name")
    var name:Star<Char>;
}
  • b
    feels fine... i mean, its a char pointer... but who cares, you arent writing to it
  • b
    maybe even make it a ConstCharStar for good measure
  • b
    then i think can turn it into a haxe string implicitly
  • b
    Copy code
    haxe
var c:ConstCharStar = "haxe string";
var s:String = c;
  • r
    These are instead my externs for the C functions
    Copy code
    haxe
@:include("dirent.h")
extern class DirEntFunctions {
    @:native("opendir")
    static function open(path:ConstCharStar):Star<DIR>;

    @:native("readdir")
    static function read(dir:Star<DIR>):Star<DirEnt>;

    @:native("closedir")
    static function close(dir:Star<DIR>):Int;
}
  • r
    Then I just use the 
    Pointer.fromStar
    to get a managed pointer
  • b
    maybe? I dont use Star personally, no reason, just dont use / know it
  • b
    also, why do you want a managed pointer for the return value? (i presume you mean for the return value?)
  • r
    To access the class or I can do that without a 
    cpp.Pointer
    ?
  • b
    i use Pointer.fromRaw... not sure what the difference is tbh
  • b
    so "my" way would be: 
    static function open(path:ConstCharStar):RawPointer<DIR>;
    and then if i wanted to wrap it: 
    Pointer.fromRaw(DirEntFunctions.open(...))
  • b
    though, if im honest, i would create a simple wrapper around 
    RawPointer<DIR>
    ... feels easier
  • r
    Yeah I was doing just that right now, maybe tomorrow will get to it
  • b
    ... maybe hxWidgets might help you more than raylib-haxe, its far, far more complex: https://github.com/haxeui/hxWidgets
  • r
    Thanks! That can help me, maybe tomorrow tho Thank you for the insights of how hxcpp handles this kind of stuff
  • b
    no worries, good luck! Let me know how you get on 🙂
  • r
    Sure! 👍
1...827828829...1687Latest