&rvalue passed for void **

[ancient compass]

Context:

Status Allocate(void **inst, const size_t nmemb, const size_t size);

# define ref(inst, type, index)                            \
  ({                                                       \
    type *_ref = NULL;                                     \
    fail(call(Array, type, RefIdx)                         \
         with (inst, (index), &_ref));                     \
    _ref;                                                  \
  })

Usage:

fail(Allocate(&ref(inst, type, i), 1, sizeof(type)));

Problem:
Fetching for the address of rvalue.

Personal Consideration:
Rather not solving it by having another lvalue variable to store rvalue.

[hoary folio]

When your question is answered use !solved to mark the question as resolved.

Remember to ask specific questions, provide necessary details, and reduce your question to its simplest form. For tips on how to ask a good question use !howto ask.

[runic spruce]

here is a simpler example that demonstrates the problem:c int*p=&({int i=42;i;});what do you expect p to point to here

[ancient compass]

nothing, because the value is not located on memory

it's simply not possible to have a pointer pointing towards something beyond its existence

[runic spruce]

I would recommend making ref a function

instead of this macro

[ancient compass]

let me see...

[runic spruce]

also the const in Status Allocate(void **inst, const size_t nmemb, const size_t size); don't do anything

seems strange to only do it for 2/3 parameters as well

[ancient compass]

alas, the type is all about making this flexible on types. it wouldn't do if ref is a function

[runic spruce]

just have ref result in a void*, then the user does (type*)ref(...)

[ancient compass]

yeah, the const only effects in implementations, not in prototypes

[ancient compass]

oh, that would make sense

still, I have to try it before tagging this thread solved

but thanks anyway :)

[hoary folio]

@ancient compass Has your question been resolved? If so, type !solved :)

[ancient compass]

okay, I think I solved it by adding a &

# define ref(inst, type, index)                            \
  ({                                                       \
    type *_ref = NULL;                                     \
    fail(call(Array, type, RefIdx)                         \
         with (inst, (index), &_ref));                     \
    &_ref;                                                 \
  })

[runic spruce]

nice dangling pointer

[ancient compass]

oh I forgot that

snap

[runic spruce]

or if you really like using a macro for some reason, you can move most of the logic into one function

[ancient compass]

actually I was wondering why my valgrind complained and the program didn't output anything expected :'D

[runic spruce]

and just do something like #define ref(inst,type,index)((type*)ref_(inst,index))

[ancient compass]

okay, there's a reason for using macro only. you see that type in call(Array, type, RefIdx) right? that's there for something

[runic spruce]

where ref_ does everything without the type information

[ancient compass]

well, unfortunately, the type is needed for calling array operations

I tried

[runic spruce]

are fail, call, and with also macros

[ancient compass]

wait, let me see your reply again...

yes

but fail is not involved

in this case anyway

[runic spruce]

what's the reason to have all of these macros

[ancient compass]

so the thing is, it is not enough to call an array operation by giving inst and index only, the type is required because arrays are defined by types, and each time it is needed to call one of them, you specify it by type

[ancient compass]

briefly, fail is a part of error checking, and call is helped to call specific typed array

/* Converts calling function with compatible Incompleted objects. */
# define call(incompleted, type, operation)                \
  type##incompleted##_##operation

so the array operations are actually intArray_GetIdx

and since there is no dry array without type, it is required to use type on distinguishing one from another, like intArray from doubleArray

[ancient compass]

and therefor, the use of calling for getting elements from an array without specifying corresponding type is impossible. the type is not just here being used to convert.

I think I got to go the long way, using stack. anyway, it's basically solved by now, thanks again

!solve

[hoary folio]

Thank you and let us know if you have any more questions!

This thread is now set to auto-hide after an hour of inactivity