Newsgroup: it.comp.lang.pascal
Titolo: Commenti scomodi

Un saluto a tutti quelli del NG; sono alle prese con un programma che deve
contare le occorrenze delle parole riservate "begin" ed "end" nel proprio
file sorgente. Per l'estrazione della parola non ci sono problemi, ma devo
trascurare i "begin" e gli "end" all'interno dei commenti. Qualcuno mi puň
dare qualche idea, tenendo conto del fatto che i commenti possono essere
scritti cosě?:
(* parola *),
(*parola*)
{parola}
{ parola }
(****** parola ******)   [con un numero di asterischi casuale]
{{{{{{ parola }}}}}}}      [con un numero di graffe casuale]



Prendendo in considerazione l'ultimo esemio potresti utilizzare un
contatore per le parentesi che all'inizio e' zero, quando trovi { lo
incrementi di 1 e quando trovi } lo decrementi sempre di 1. Ora per il
conteggio delle 'begin' e delle 'end' anche qui utilizzi dei contatori
ma che incrementi solo quando il contatore delle parentesi e' zero.
Un 'altro modo per farlo sarebbe quello di utilizzare una procedura
ricorsiva.
Mi sembra tutto abbastanza facile da fare ma se ci sono ancora
problemi fammelo sapere, e soprattutto facci sapere poi come e'
finita.
Ciao,  Fabio
fabi...@rocketmail.com

Potresti altrimenti aggiungere un while che funziona quando trova una { e (*
e continua a scandire il file carattere per carattere, senza far nulla , il
ciclo finisce quando
trova } o *), e tu rinizi a contare le occorenze dei begin e end
Ciaooo


Ciaooo
Non credo che cosi' possa funzionare. Il problema e' che dopo la prima
parentesi aperta se ne potrebbe incontrare un'altra sempre aperta. A
quel punto con il tuo metodo cosa faresti?
Ciao,  Fabio
fabi...@rocketmail.com

 >{parola}
....
Ciao Fabio...
si č diventati esperti di Pascal! 
Forse quello che facciamo in laboratorio non č proprio male...
Ciao...

Ciao...
Non ti ho capito.
Fabio
fabi...@rocketmail.com

{{{{{{ parola }}}}}}}      [con un numero di graffe casuale]
Se vuoi prendilo come spunto per la tua versione facendoci poi le
dovute modifiche per le altre sintassi dei commenti.
Le variabili NB, NE sono le occorrenze della ' BEGIN' e della 'END',
P e' il contatore utilizzato per le parantesi.
Program  occorrenze_begin_end;
var      f:text;
         nb,ne,p,i,l:integer;
         s,nf:string;
begin
         writeln;
         write('Nome File: ');  readln(nf);
         assign(f,nf);
         reset(f);
         nb:=0; ne:=0; p:=0;
         while not eof(f) do begin
             writeln;
             readln(f,s);
             l:=length(s);
             for i:=1 to l do        { begin }
                 s[i]:=UpCase(s[i]);
             i:=0;
             while i<l do begin
                inc(i); write(s[i]);
                if s[i]=#123 then begin
                   inc(p);
                   write(#7);
                   while p>0 do begin
                      if i<l then begin
                         inc(i); write(s[i]);
                         if s[i]=#123 then inc(p);
                         if s[i]=#125 then dec(p)
                      end
                      else begin
                         writeln;
                         readln(f,s);
                         l:=length(s);
                         for i:=1 to l do
                             s[i]:=UpCase(s[i]);
                         i:=0
                      end
                   end
                end
                else
                    if copy(s,i,5)='BEGIN' then
                       inc(nb)
                    else
                       if copy(s,i,3)='END' then
                          inc(ne)
             end
         end;
         close(f);
         writeln;
         writeln('Occorrenze BEGIN = ',nb);
         writeln;
         writeln('Occorrenze END   = ',ne);
         writeln
end.
Ciao,  Fabio.
fabi...@rocketmail.com

Guarda che quando apri un commento tutto quello che e' dentro non c'entra
il commento viene chiuso, quando trova un carattere di fine commento[ } o *)],
non deve rispettare nessun tipo di gerarchia di commenti, non e' che visto che ho
aperto
una parentesi graffa devo prima chiudere anche la graffa e poi il commento,
non e' mica HTML , ad esempio io utilizzo il borland tp7 che decolora
automaticamente il commento, quando apro un commento, tutto quello che scrivo
dentro rimane
decolorato, anche se cerco di aprire altri vari commenti, solo quando trova il
fine commento
il codice che scrivo torna ad essere colorato..
Ciaoo alla prossima
Fabio M. wrote:

--

...[cut]
I caratteri di inizio commento sono { e (  gli * e spazi possono
essere considerati come commento (un commento non inizia mai con *).
Come dici tu sembra che se un commento lo apro con { lo posso chiudere
con ) e viceversa. Non puo' essere cosi'. Commenti aperti con { vanno
chiusi con } ecc.
Ma tu come consideri il caso {{{{{{ parola }}}}}}}  . Lo avevi
considerato?
Potrei pensare che quando trovi una { leggi finche' c'e' una { e poi
leggi il commento fin a quando trovi una  } e poi continui a leggere
finche' c'e' una } .
Questo mi puo' andare anche bene, ma cosi' non cotrolli la sintassi
(il numero di parentesi aperte deve essere uguale al numero di
parentesi chiuse).
Il 'sistema del coteggio delle parentesi' permette oltre al controllo
della sintassi anche di considerare commenti del tipo
 {{{ parola }} { parola } }}}    forse inutile ma visto che ci siamo.
Bye
Fabio.
fabi...@rocketmail.com

Allora a casa mia conosco due tipi di commenti,
1)  { ciao ciao ciao }
2)  (* ciao ciao ciao ciao *)
"una graffa vuol chiusa con una graffa."
"una parentesi e asterisco vuol chiuso con un altro parentesi asterisco."
Sempre a casa mia il commento   {{{{{{ parola }}}}}}} genera un errore,
perche' le ultime 6 graffe chiuse, non rappresentano nessun tipo di istruzione,
ed il compilatore interpreta come inizio commento la prima graffa aperta,
e come fine commento la prima graffa chiusa, tutto questo vale
se Fabio Carosio, vuole un analizzatore di sorgenti Pascal, e se è cosi
credo che il ? nella sua mail stia a significare il fatto che neanche lui è tanto
sicuro
di come devono essere interpretati commenti e di come sono definiti.....
Esiste anche un altro caso, potrebbe ora anche essere, che fabio voglia un
analizzatore
di commenti per pseudocodice generalizzato, quindi in questo caso puo darsi che i
commenti
possano essere definiti nel suo pseudocodice con quel tipo di chiusura gerarchizzato.
Perciò credo che ora solo fabio possa far chiarezza, su cosa vuol veramente,
comunque il pascal con questo commento {{{{{{ parola }}}}}}} se tenti di compilare il
programma
da errore...
Ciao a tutti
Fabio M. wrote:

--
--------------------------------
 Alex Home:
     "
http://www.geocities.com/SiliconValley/Campus/7397/index.html
"
--------------------------------
Chi aumenta la Tariffa Urbana a Tempo diminuisce la liberta' di tutti
gli utenti  Internet. Anche la tua. Ricordalo, prima di acquistare
prodotti o servizi dalla Telecom Italia S.p.A.
"
http://notut.ml.org/
"
--------------------------------

Ciao a tutti
Io non avevo dato per scontato che si trattasse di un analizzatore di
linguaggio Pascal. Per esempio come tu sapevi che i commenti NON
potevano essere messi nella forma {{{{{{ parola }}}}}}} io NON sapevo
che nel TP si potevano mettere i commenti nella forma (* parola *).
Io avevo pensato il problema in forma generale secondo i dati forniti
da Fabio Carosio.
Se si suppone che il sorgente sia in linguaggio TP allora il tuo
metodo va benissimo.
Ciao,  Fabio.
fabi...@rocketmail.com

Infatti credo che il metodo che hai suggerito sia perfetto, come giustamente dici con
un codice non sorgente pascal : )
Adesso la parola spetta a Fabio Carosio....
Ciao a tutti... ( pochi ma buoni) :)


da errore...
Effettivamente ho verificato e hai ragione (non so come mi é venuto in mente
{{{{ - - }}}}.....).
Allora i casi possibili si riducono a:
{        }
(*        *)
(****...        ...****)
Beh.. io avrei pensato ad un sistema, peraltro avente alcune cose in comune
con la soluzione propostami da Fabio M.
Trattasi di un sistema a stati: semplificando, uso un intero per definire lo
stato in cui mi trovo.
0    -    é lo stato "fuori da commenti".
1    -    é lo stato "ho letto una '(' e aspetto un '*' ".
2    -    é lo stato "dentro il commento".
se  leggo (dal file) un carattere tra quelli qui sotto avrò le relative
transizioni tra stati (per ogni stato in cui portei trovarmi é esplicitata
la relativa transizione associata):
'('    :    0 -> 1
            1 -> 0
            2 -> 2
'*'    :    0 -> 0
            1 -> 2
            2 -> 2
')'    :    0 -> 0
            1 -> 0
            2 -> 2
'{'    :    * -> 2        L'asterisco sta per ogni stato
'}'    :    * -> 0
Che ne dici?
Perdona la rudezza dello schema ma mi risultava troppo laborioso disegnare
un grafo.

Ciao Fabio C. , credo che di prima come metodo possa andar benone,  dopo
logicamente dipende anche da come leggi il file in input, cioe' se lo leggi
carattere per carattere oppure parola per parola, a seconda di quello che usi si
possono attuari vari metodi, se ti serve una mano scrivimi ciaooo
Ciao a tutti
