Cast d'une fonction void ? - Page 1

pouet,

Peut-on caster une fonction void pour utiliser son résultat ?
Je fais ça : g->PdtlibRef = kernel_LibsExec ("pdtlib", 4, 1, "pdtlib", 1, &PdtlibFunctionsTable, &PdtlibOffsetsTable, g);
et il râle parce que LibsExec ne renvoie rien. Donc je fais ça : g->PdtlibRef = (LibRef*) kernel_LibsExec ("pdtlib", 4, 1, "pdtlib", 1, &PdtlibFunctionsTable, &PdtlibOffsetsTable, g);
Et il râle toujours parce qu'il comprends pas ce que je veux faire !!!

Ya un moyen de faire ça svp ?

Huh ? Si ta fonction renvoie quelque chose, pourquoi est-elle déclarée void ? Il est là le problème à la base

Si, c'est normal. Voici la doc de PreOS :

35-kernel::LibsExec(char *lib_name, WORD function, BYTE version, ...)	(Preos only)

	The parameters are pushed on the stack.
	It calls the function without modifying the registers, and it pops its argument 
	during the call (LIB_DESCRIPTOR, function, and version).
	BYTE doesn't follow the C convesion for char (Sorry). Uses macro instead.

	It relocs the library, calls the function and unreallocs the library.
	The parameters pushed on the stack are corrupted.
	If there is an error, the parameter 'lib_name' equals zero after the call.

LibsExec appelle une fonction inconnue d'une lib, et renvoie void, mais la valeur de retour de la fonction appelée dans la lib n'est pas détruite. Evidemment, LibsExec ne pouvant pas deviner de quel type va être cette valeur de retour, elle est déclarée void, mais c'est pas étonnant de vouloir utiliser une valeur de retour (en l'occurence, j'appelle via LibsExec une fonction qui renvoie un LibRef*).

Mouais

Si la valeur de retour est toujours dans d0, déclare kernel_LibsExec() comme retournant un entier 32 bits, que tu pourras caster comme tu veux ensuite.

Si ça ne suffit pas, tu peux t'en sortir en définissant un pointeur de fonction avec le type de retour kivabien, tu le fais pointer vers kernel_LibsExec() (via un cast, sinon le compilo va râler), et tu appelles la fonction à travers le pointeur. Mais c'est passablement lourd

(à vrai dire, il doit y avoir moyen de caster directement la fonction sans devoir utiliser de variable pointeur intermédiaire, mais vue la syntaxe ignoble du C pour les pointeurs de fonction, c'est à tes risques et périls ^^)

Ok, ça devrait marcher en effet.

j'aurais dit pareil que 0²

    g->PdtlibRef =((LibRef*(*)(char *, short, char, ...))kernel_LibsExec) ("pdtlib", 4, 1,
                                              "pdtlib", 1, &PdtlibFunctionsTable, &PdtlibOffsetsTable, g);

?

(edit -> rien, je suis trop con xD)

Ca marche impeccable, merci (t1 je sais même pas faire un cast de fonction ^^ ça c'est parce que dans ma tête, une fonction qui renvoie un int est un int, et pas un int (*)() ^^

J'aurais donné la même solution que PpHd (sous réserve que je me sois souvenu correctement de la syntaxe de pointeur de fonction), ça m'étonne beaucoup que ça ne fonctionne pas…
T'aurais pas une macro à la con quelque part, qui interférerait avec ton code ?

./2 > Le runtime Objective-C fonctionne comme ça par exemple: La fonction objc_msgSend_stret renvoie un void, et c'est à toi de la caster dans le bon prototype avant l'appel pour recevoir ton résultat. (En pratique, le compilateur génère l'appel à cette fonction, et pas toi, bien-sûr…)

(j'ai l'impression qu'on a crossé GC, j'avais en effet une merde dans mon code qui faisait que ça compilait pas, j'ai édité)

En effet
C'est plus logique que ça marche

Plus logique, mais tellement moche

J'ai jamais compris pourquoi fallait caster les pointeurs de fonction de façon aussi moche en C J'ai fini par m'y faire, mais quand tu vois qu'en asm, un pointeur c'est 4 octets d'une effarante banalité, tu comprends pas pourquoi c'est un tel boxon en C

Ben parce que le pointeur contient le prototype (ou signature) de la fonction. Et le prototype de la fonction te dit comment elle doit être apellée: à haut niveau pour la vérification des paramètres (etc.), et à bas niveau (assembleur) pour la génération du code.
En assembleur tes 4 octets t'as potentiellement aucune idée de ce qu'ils font, alors que là tu sais, ou tu déclares, exactement ce qu'ils font (notion de type, quoi )

Tu peux aussi mettre un typedef si t'aimes pas la syntaxe dégueu du C, ça sera peut-être plus lisible

C'est meme fortement recommande le typedef pour les pointeurs de fonction

J'en mets systématiquement, oui, c'est moins pire, mais quand même ^^

Et une fois que tu seras habitué tu pourras coder des trucs comme ça :

template<class ArgType, class ReturnType = void>
struct Delegate {
	struct FictitiousBase {} *mObj;
	ReturnType (FictitiousBase::*mFuncPtr)(ArgType);

	template<class Obj>
	Delegate(Obj *object, ReturnType(Obj::*mem_func)(ArgType)) {
		mObj = (FictitiousBase*) object;
		mFuncPtr = (ReturnType(FictitiousBase::*)(ArgType)) mem_func;
	}

	ReturnType operator ()(ArgType arg) {
		if (is_same<ReturnType, void>::value) {
			(mObj->*mFuncPtr)(arg);
		} else {
			return (mObj->*mFuncPtr)(arg);
		}
	}
};

Ca te permet de faire des appels génériques sur des objets :

struct C {
	float div2(int n) {
		return n / 2.f;
	}

	void method() {
		Delegate<int, float> d(this, &C::div2);
		float var = d(11);	// 5.5f
	}
};

Merci de me rappeler pourquoi je n'aime pas le C++ !

Clair. Tu crois lire un simple appel de fonction, c'est même pas ça. Bonsoir le débogage !

Ca, c'est encore raisonnablement inoffensif - on peut faire bien pire
div étant une fonction simple, et la paire if / else avec is_same pouvant être optimisée en temps de compilation, l'appel de fonction sera probablement généré en division inline.

C++11, c'est bien !

On voit les âmes chastes qui n'ont pas encore dû plonger dans la STL

J'en ai lu les headers, j'ai eu 3 semaines d'ITT, j'y suis plus revenu