How do I call gmtime from C?

[sa-]

I would like to get the current year from the seconds since the epoch, and thought it would be fun to try figuring out the FFI. Also had no idea how to use DLHandle from the FFI module since we don't have examples yet

This is what I have so far but this is the error that I get:

'pop.cast' op result #0 must be whose element type is either unbound, integral, bool or float dtype, but got '!pop.scalar<address>'
    return Pointer[C_tm](tm_address).load()
                         ^

alias _CLOCK_REALTIME = 0

@value
@register_passable("trivial")
struct C_tm:
    var tm_sec: Int
    var tm_min: Int
    var tm_hour: Int
    var tm_mday: Int
    var tm_mon: Int
    var tm_year: Int
    var tm_wday: Int
    var tm_yday: Int
    var tm_isdst: Int
    
    fn __init__() -> Self:
        return Self {
            tm_sec: 0,
            tm_min: 0,
            tm_hour: 0,
            tm_mday: 0,
            tm_mon: 0,
            tm_year: 0,
            tm_wday: 0,
            tm_yday: 0,
            tm_isdst: 0
        }

@value
@register_passable("trivial")
struct _CTimeSpec:
    var tv_sec: Int  # Seconds
    var tv_nsec: Int  # NanoSeconds

    fn __init__() -> Self:
        return Self {tv_sec: 0, tv_nsec: 0}

    fn as_nanoseconds(self) -> Int:
        return self.tv_sec * 1_000_000_000 + self.tv_nsec


@always_inline
fn _clock_gettime(clockid: Int) -> _CTimeSpec:
    """Low-level call to the clock_gettime libc function"""
    var ts = _CTimeSpec()
    let ts_pointer = Pointer[_CTimeSpec].address_of(ts)

    let clockid_si32 = __mlir_op.`pop.cast`[
        _type : __mlir_type.`!pop.scalar<si32>`,
    ](clockid.value)

    # Call libc's clock_gettime.
    __mlir_op.`pop.external_call`[
        func : "clock_gettime".value,
        _type:None,
    ](clockid_si32, ts_pointer.address)

    return ts

@always_inline
fn _ts_to_tm(owned ts: _CTimeSpec) -> C_tm:
    let ts_pointer = Pointer[_CTimeSpec].address_of(ts)

    # Call libc's clock_gettime.
    let tm_address = __mlir_op.`pop.external_call`[
        func : "gmtime".value,
        _type:Int,
    ](ts_pointer.address)

    return Pointer[C_tm](tm_address).load()

var ts = _clock_gettime(_CLOCK_REALTIME)
var tm = _ts_to_tm(ts)
print(tm.tm_year)

[czheo]

This works

alias int = SI32
@value
@register_passable("trivial")
struct C_tm:
    var tm_sec: int
    var tm_min: int
    var tm_hour: int
    var tm_mday: int
    var tm_mon: int
    var tm_year: int
    var tm_wday: int
    var tm_yday: int
    var tm_isdst: int
    
    fn __init__() -> Self:
        return Self {
            tm_sec: 0,
            tm_min: 0,
            tm_hour: 0,
            tm_mday: 0,
            tm_mon: 0,
            tm_year: 0,
            tm_wday: 0,
            tm_yday: 0,
            tm_isdst: 0
        }

let rawTime : Int
let rawTimePtr = Pointer[Int].address_of(rawTime)
__mlir_op.`pop.external_call`[
        func : "time".value,
        _type: None,
    ](rawTimePtr.address)

let tm = __mlir_op.`pop.external_call`[
        func : "gmtime".value,
        _type: Pointer[C_tm],
    ](rawTimePtr).load()

print(tm.tm_hour, ":", tm.tm_min, ":", tm.tm_sec)

[sa-]

Good catch on the types being SI32 and not Int