void pointer naar literal

[jeroen3]

Ik probeer een module te maken welke het mogelijk maakt om configuraties uit een bestand te lezen.
De configuratie van deze module staat in ROM geheugen. Dat is logisch, want deze veranderd toch niet.
Dit is de configuratie stuct, waarvan dus een array bestaat.

C:

typedef struct {
    char *element;      // Pointer naar elementnaam string literal
    char *format;       // Pointer naar scanf format string literal
    uint16_t size;      // Lengte elementnaam (sizeof(element))
    void *target;       // Doellocatie in ram waar de instelling moet komen
    void* defaultvalue; // Pointer naar literal met standaardwaarde voor element
} element_t;

Het lezen van de instellingen op deze manier gaat prima.

Het probleem is dat de standaard instellingen niet alleen bestaan uit string literals, maar ook floats en integers of whatever. Het initialiseren van de void * met een "string literal" is geen probleem. Immers word deze in ROM gelinkt en vervangen voor het adres. Net als je char * initialiseert.
Maar hoe initialiseer je een void pointer met adres van een integer literal? Kan dat wel?

Dit alles is in C(99).

[Tribits]

Hoewel me eigenlijk een beetje ontgaat wat je nu precies probeert te doen en wat er niet lukt helpt het volgende wellicht: Pointer to literal value.

[MSalters]

Integer literals hebben geen adres. Waarom probeer je een pointer naar een integer constante op te slaan in plaats van de integer zelf? Simpeler:

C:

typedef struct {
    char *element;      // Pointer naar elementnaam string literal
    char *format;       // Pointer naar scanf format string literal
    uint16_t size;      // Lengte elementnaam (sizeof(element))
    int *target;        // Doellocatie in ram waar de instelling moet komen
    int defaultvalue; // Pointer naar literal met standaardwaarde voor element
} element_t;

[ Voor 1% gewijzigd door MSalters op 14-08-2014 20:34 . Reden: Geen markdown :( ]

[jeroen3]

Integer literals hebben geen adres

Voor dynamisch geladen processen niet nee.
Echter laad ik dit in een microcontroller en dan is alles statisch gelinkt. En zijn alle locaties en adressen voorspelbaar. Tenzij je de linker natuurlijk anders kietelt, maar dat gebeurt zelden.
Inmiddels ben ik er achter dat je niet zomaar een adres van een literal kan nemen omdat de optimizer hem in de instructie kan verwerken.

Ik zou ook een union kunnen gebruiken, maar dan moet ik bij het verwerken weten of het een pointer is.
En aangezien ik via een element_t * door de array loop is dat onmogelijk zonder een extra boolean.

Printf accepteert helaas ook geen void *, behalve met %p om het adres te printen. Ik had gehoopt dat printf het typecasten wel van mij over kon nemen op basis van de inhoud van format, maar helaas.
Toch maar alle waarden als ascii opslaan, wel zo portable.

[ Voor 30% gewijzigd door jeroen3 op 14-08-2014 21:27 ]

[farlane]

Ik snap niet waar je het over hebt ( wat heeft printf met je vraag te maken? ) maar alles wat kleiner of gelijk is aan een void* kun je direct opslaan in het void* element.

[MSalters]

jeroen3 schreef op donderdag 14 augustus 2014 @ 21:22:
[integer literal heeft geen adres]
Voor dynamisch geladen processen niet nee.

Echter laad ik dit in een microcontroller en dan is alles statisch gelinkt. En zijn alle locaties en adressen voorspelbaar. Tenzij je de linker natuurlijk anders kietelt, maar dat gebeurt zelden.
Inmiddels ben ik er achter dat je niet zomaar een adres van een literal kan nemen omdat de optimizer hem in de instructie kan verwerken.

Wat probeer je nu te zeggen? Je hebt net een reden ontdekt waarom de regel bestaat, en er zijn er meer. Integer literals hebben dus geen adres, en het is goed mogelijk dat de linker ze niet eens ziet. Dan maakt het natuurlijk niets uit hoe die linker precies werkt, statisch of dynamisch.

En dat printf het niet kan printen is logisch. Het is heel goed mogelijk dat floats in een floating-point register worden doorgegeven, en dat printf("%f", foo) dus het eerste floating-point register printf. Dan kun je niet zomaar verwachten dat een void* "magisch" in dat floating-point register belandt. Dat moet je zelf doen: printf("%f", * (float*) jouwVoidPtr)

[ Voor 18% gewijzigd door MSalters op 15-08-2014 13:43 ]