Newsgroup: it.comp.lang.c
Titolo: Errore che non capisco...

Salve a tutti,
qualcuno sa dirmi perchè alla dichiarazione:
void AttivaServizio(dword dwArgc, lptstr *lptszArgv);
il compilatore mi risponde con l'errore:
ntservice.h(28) : error C2146: syntax error : missing ')' before identifier
'dwArgc'
--
*****************************************************
Attilio Gelosa
attilio...@galactica.it
Offical Symantec Products Beta Tester
*****************************************************

 'dwArgc'
E' un prototipo di funzione quello? Se si non devi mettere i
nomi delle variabili (dipende dal tipo di compilatore che hai).
Nell'ansi C il prototipo sarebbe
void AttivaServizio(dword, lptstr *);
Ciao.

 hai). 
  Questo mi suona molto nuovo...
	Alla prossima,
		Marco

 'dwArgc'
Perché i tipi vanno scritti in questo modo:
void AttivaServizio(DWORD dwArgc, LPSTR *lptszArgv);
EMG

 void AttivaServizio(dword, lptstr *);
Non è vero. I nomi delle variabili possono anche essere messi (a puro
scopo di documentazione).
EMG

'dwArgc'
Di solito (almeno nei miei due compilatori) questo tipo di errore è dovuto
al mancato riconoscimento del tipo dword. Lo interpreta come il nome di una
variabile e quando trova l'identificatore successivo senza prima una virgola
non sa che pesci pigliare.
Ciao, Giuseppe

 scopo di documentazione).
Ok, non ne ero sicuro. So che una volta mi "sgridarono" perche' mettevo
i nomi delle variabili nei prototipi dei .h, il mio compilatore li
compilava,
ma allora io, ingenuamente, credetti che alcuni compilatori facevano
fatica
a digerire quel tipo di prototipo.

you wrote :
#Di solito (almeno nei miei due compilatori) questo tipo di errore č dovuto
#al mancato riconoscimento del tipo dword. Lo interpreta come il nome di una
#variabile e quando trova l'identificatore successivo senza prima una virgola
#non sa che pesci pigliare.
Come una "variabile" ?
Forse come un nome di tipo ...
Andrea Laforgia        (
andrea_...@bigfoot.com
)
----------------------------------------------------
There is nothing better for understanding a kangaroo
than seeing it jump.
----------------------------------------------------

Forse come un nome di tipo ...
Dato che non conosce "dword" cerca di interpretare la dichiarazione di
funzione come se fosse scritta in stile pre-ANSI:
void AttivaServizio(dword, dwArgc, lptstr, lptszArgv)
tipo_dato dword;
tipo_dato dwArgc;
ecc.....
{
  corpo_funz
};
ma non trovando alcun separatore dopo "dword" (una virgola o la parentesi
chiusa) da errore. Una cosa è sicura però: il tipo dword non lo conosce
(prova con DWORD).
Ciao, Giuseppe

you wrote :
#Dato che non conosce "dword" cerca di interpretare la dichiarazione di
#funzione come se fosse scritta in stile pre-ANSI:
No, scusami, qui si parla di ...
void AttivaServizio(dword dwArgc, lptstr *lptszArgv);
                                                    ^...prototipi... 


                                                    ^...prototipi...
L'errore č cosě definito:
<MSDN>
Compiler Error C2146
syntax error : missing 'token' before identifier 'identifier'
The compiler expected the given token to appear before the given identifier.
This error is usually preceeded by error C2065. The most typical cause of
this error is a typographical problem. For example:
void main(void)               // <- void main lo ha scritto l'MSDN  :-)
{
   intt x; //Syntax error: missing semicolon before 'x'
}
</MSDN>
Credo che il discorso sia lo stesso sia per i prototipi che per le
implementazioni di funzione. Non riconoscendo dword come identificatore di
tipo, cerca di interpretare il tutto secondo lo stile pre-ANSI (ma anche se
non lo fa non cambia nulla) e non trovando una virgola (o un ;) prima del
successivo identificatore genera un errore.
Ciao, Giuseppe

you wrote :
#syntax error : missing 'token' before identifier 'identifier'
#void main(void)               // <- void main lo ha scritto l'MSDN  :-)
#{
#   intt x; //Syntax error: missing semicolon before 'x'
#}
#Credo che il discorso sia lo stesso sia per i prototipi che per le
#implementazioni di funzione. Non riconoscendo dword come identificatore di
#tipo, cerca di interpretare il tutto secondo lo stile pre-ANSI (ma anche se
#non lo fa non cambia nulla) e non trovando una virgola (o un ;) prima del
#successivo identificatore genera un errore.
Chiedo scusa, ma a me sembra una segnalazione d'errore abbastanza
assurda.
Che senso ha segnalare che manca il ; prima di x se anche intt non ha
senso scritto come "intt ;" ?
Secondo me, invece, in questo caso dovrebbe segnalare che "intt" non
e' un tipo valido.
Posso capire che nel caso di una funzione il compilatore stia
presupponendo che si tratti di una definizione in stile pre-ANSI (tra
l'altro se non facesse cosi' non sarebbe la stessa cosa, in quanto
dword verrebbe interpretato come nome di *tipo* e non come
identificatore) e quindi interpreta il token come identificatore, ma
nel caso di una dichiarazione come quella dell'esempio non credo abbia
molto senso, o sbaglio ?


molto senso, o sbaglio ?
Premetto che non conosco bene le dichiarazioni pre-ANSI. Comunque secondo me
dovrebbe avere senso perché anche nella dichiarazione di un prototipo
appaiono solo gli identificatori dei parametri:
void AttivaServizio(dwArgc, lptszArgv);
Solo nell'implementazione della funzione vengono specificati i tipi per i
parametri:
void AttivaServizio(dwArgc, lptszArgv)
dword dwArgc;
lptstr *lptszArgv;
{
// corpo funzione
};
Ciao, Giuseppe
---------------------------------------------------------------------------
_Guybrush su IRCNet canale #programmazione
---------------------------------------------------------------------------

you wrote :
#Assurda per noi umani ma non per il compilatore :-)
E gia', pero' il compilatore lo progettano gli umani !!! (o no ?)
#>Secondo me, invece, in questo caso dovrebbe segnalare che "intt" non
#>e' un tipo valido.
#Infatti č cosě. Il compilatore prima genera un errore del tipo
#error C2065: 'dword' : undeclared identifier
No ! "undeclared identifier" mi fa capire che dword viene preso come
identificatore e non come nome di tipo (c'e' una bella differenza).
Questo compilatore supporta il codice pre-ANSI, ma ribadisco che per
me ha poco senso una tale segnalazione per una dichiarazione di
variabile.
#Secondo il nostro punto di vista non ha senso, ma secondo la logica con cui
#č stato progettato il compilatore quella č la giusta sequenza di errori da
#generare: (1) token sconosciuto, 
Il problema e' proprio questo : token sconosciuto non significa nulla.
O e' interpretato come nome di tipo o come identificatore.
Dato che precedentemente manca il nome di tipo viene riconosciuto come
identificatore.
#E credo proprio che la interpreti come nome di tipo (niente pre-ANSI) dato
#che da l'errore "undeclared identifier"
No, la interpreta come pre-ANSI, altrimenti segnalerebbe un errore di
sintassi.


identificatore.
Il problema non si pone: non lo riconosce nč come nome di tipo nč come
identificatore.
