How to implement offsetof?

[codehz]

It seems hard to use c's offsetof directly

[codehz]

Ok I found the solution:

## local offsetof = expr_macro(function (T, field)
  return #[T.value.fields[field].offset]#
## end)

But it has downside: you need to use the ugly syntax #[offsetof]#(Struct, "field")

Use poly function

global function offsetof(T: type, field: string <comptime>): integer <inline>
  return #[T.value.fields[field.value].offset]#
end

problem: not comptime function

[edubart]

But it has downside: you need to use the ugly syntax #[offsetof]#(Struct, "field")

The ugly syntax is desired, because it explicitly differentiate for the user eyes what is being processed at compile-time from what is being processed at runtime. Hiding away things processed at compile-time to look as usual runtime code is a non goal, otherwise this would be problematic as macros are in C, where the reader can't know if a call is either a function or a macro.

[edubart]

I will show 5 possible ways to achieve that:

local MyRecord = @record{
  a: uint32,
  b: uint32
}

-- First way, poly function using C `offsetof` (known only at runtime, calculated by the C compiler)
local function c_offsetof(T: type, field: string <comptime>): isize <inline>
  local off: isize <noinit>
  ##[[
  cinclude '<stddef.h>'
  local type, field = T.value, field.value
  cemit(function(emitter)
    emitter:add_indent_ln('off = offsetof(', type, ', ', field, ');')
  end)
  ]]
  return off
end
assert(c_offsetof(MyRecord, 'b') == 4)

-- Second way, poly function (known at runtime, calculated by the Nelua compiler)
global function func_offsetof(T: type, field: string <comptime>): integer <inline>
  return #[T.value.fields[field.value].offset]#
end
assert(func_offsetof(MyRecord, 'b') == 4)

-- Third way, macro of offsetof (known at compile-time, calculated by the Nelua compiler)
## function macro_offsetof(T, field) return T.value.fields[field].offset end

assert(#[macro_offsetof(MyRecord, 'b')]# == 4)

-- Forth way, macro offsetof (known at compile-time, calculated by the Nelua compiler)
## exprmacro_offsetof = expr_macro(function (T, field)
  return #[T.value.fields[field].offset]#
## end)

assert(#[exprmacro_offsetof]#(MyRecord, 'b') == 4)

-- Fifth way, inline macro (known at compile-time, calculated by the Nelua compiler)
assert(#[MyRecord.value.fields['b'].offset]# == 4)

Also be warned that the field offset may not be defined for incomplete records, because it's possible to import records with missing fields from C headers using the <cincomplete> annotation, some libraries bindings like pthread does that as seen here, because the record size/offset is platform dependent while the bindings are cross platform, thus Nelua compiler cannot infer the offset/size of those records at compile-time, in that case the only possible way to get the offset will be using the first way (relying in C offsetof). But if all your records is completely defined in Nelua you should be fine.