Newsgroup: it.comp.lang.c
Titolo: Implementare un modello di chiamata a funzione

Come posso implementare un modello di chiamata a funzione?
Mi spiego meglio: possiedo il Borland Turbo C++ 1.01 che non supporta il
modello di chiamata _fastcall (passaggio dei parametri attraverso i
registri) e vorrei implementarlo. Qualcuno di voi sa come fare?
Grazie in anticipo a chi avrà la bontà di rispondermi (anche negativamente,
perchè credo proprio che ciò che io chiedo non sia fattibile).
Ciao, Giuseppe

 wrote in message
7juh6r$7ih$4...@hermes.iol.it...

Credo che l'unico modo sia farlo manualmente cioe'
type function ( void )
{
  int param1=_AX;
  int param2=_BX;
  int param3=_CX;
  int param4=_DX;
  ...oppure...
  long param=((long)_AX+(long)_DX<<16);
  ...body...
}
void main ( void )
{
  _AX = param1;
  _BX = param2;
  _CX = param3;
  _DX = param4;
  function();
  ...oppure...
  _DX = param>>16;
  _AX = param;
  function();
}
Ma sinceramente non ne vedo l'utilita'.
Quasi sempre il BorlandC++3.1 fa esattamente quello che ti ho scritto, cioe'
mette i parametri passati nei registri, in variabili automatiche nello
stack, e quindi secondo me si perde l'utilita' del _fastcall.
Per come la vedo io _fastcall ha senso solo se la funzione chiamata la
scrivi tu in assembler!
ciao
donCiccio

scrivi tu in assembler!
Infatti lho scritta io in assembler :-)
Ciao e grazie, Giuseppe

 utilizzano questo metodo. Per favore non farmici pensare... :-)
Puoi sempre scrivere una macro del tipo:
int _funz ( void )   // questa e' la funzione da chiamare
{
  ...body...
}
#define _fastcall( funname,a,b,c )   ( _AX=a, _BX=b, _CX=c, funname() )
poi la usi come
  x = _fastcall( _funz,1,2,3 );
o ancora meglio
#define funz( a,b,c )   ( _AX=(a), _BX=(b), _CX=(c), _funz() )
ciao
donCiccio

#define funz( a,b,c )   ( _AX=(a), _BX=(b), _CX=(c), _funz() )
Lo prendo come spunto ;-)
Grazie mille
Ciao, Giuseppe

 evitare il passaggio dei parametri attraverso lo stack.
Potresti utilizzare delle variabili globali, magari statiche per
migliorare la modularità.
EMG


grazie e ciao
--
San Vegeta from Hell
"...il bugzilla piů sgangherato che esista" (La Repubblica)

Qualcuno mi chiarisce il concetto?
Siamo in un contesto a 16 bit, quindi io l'ho interpretato come un metodo
per passare un parametro long al posto di un int.
"<<" definisce uno shift a sinistra di 16 bit, quindi DX diventa l'MSB (Most
Significant Bit) e AX l'LSB (Least Significant Bit).
Ciao, Giuseppe

migliorare la modularità.
Il problema è che vorrei evitare l'utilizzo di variabili globali (sarebbe lo
stesso discorso di scrivere _AX=.....; non cambia nulla).
Il problema si risolverebbe totalmente se potessi dichiarare la funzione
come una macro (lo consiglia lo stesso compilatore...) ma purtoppo è
incapsulata in una classe e non so come fare.
Ricapitolando, qualcuno sa come dichiarare un metodo come macro oppure come
implementare un modello di chiamata a funzione (ci sarà pure un modo...)?
Ciao e grazie, Giuseppe

 Qualcuno mi chiarisce il concetto?
_AX e _DX vengono prima convertiti in long poi i risultati di questa
conversione vengono sommati e alla fine il risultato di questa somma
viene shiftato di 16 bit verso sinistra. Le parentesi tonde piů esterne
sono ridondanti.
EMG

 Significant Bit) e AX l'LSB (Least Significant Bit).
L'idea era quella ma ho toppato!
Ho anche toppato a rispondere perche' ho spiegato l'arcano a EMG e non a te
che eri il diretto interessato!
Guarda il post piu' in basso....
ciao
donCiccio

 sono ridondanti.
Si ma per errore perche' quello che volevo fare era prima shiftare _DX poi
sommare.
Chiedo scusa, la linea corretta e':
   long param=(long)_AX+((long)_DX<<16);
Che comunque, sebbene giusta concettualmente, risulta errata quando il
BorlandC++3.1 la traduce in codice macchina, perche' i registri _AX e _DX
vengono usati e sporcati durante l'esecuzione dei cast a (long).
Quando la trovo vi posto la giusta sequenza di operazioni per imbrogliare il
compilatore, perche' sono sicuro di aver gia' affrontato il problema in
passato!
Tutto cio' ovviamente non serve se si puo' compilare in 386 mode, in cui
basta usare _EAX per memorizzare una variabile long.
ciao
donCiccio


La riga e' corretta cosi' com'e':
  long param=(long)_AX+((long)_DX<<16);
ma il BorlandC++3.1 la compila bene solo se si abilita l'opzione 'jump
optimization' che equivale a "#pragma option -O"
non chiedetemi il perche' ma solo cosi' i registri AX e DX non vengono
sporcati durante il cast.
ciao
donCiccio