[C/C++] Espressioni regolari

[misterx]

ciao,
sto sviluppando un progetto che tira in ballo l'acquisizione di alcuni dati da file; questi però devono essere formati in un certo modo come ad esempio potrebbe essero un indirizzo IP 192.168.1.100 oppure dati in ingresso del tipo A0.3, B10.5 e così via.

Come effettuo un controllo del genere?
Mi sonon venute in mente le espressioni regolari ma non so nulla a riguardo.

grazie

[WarDuck]

Originariamente inviato da misterx

ciao,
sto sviluppando un progetto che tira in ballo l'acquisizione di alcuni dati da file; questi però devono essere formati in un certo modo come ad esempio potrebbe essero un indirizzo IP 192.168.1.100 oppure dati in ingresso del tipo A0.3, B10.5 e così via.

Come effettuo un controllo del genere?
Mi sonon venute in mente le espressioni regolari ma non so nulla a riguardo.

grazie

Il formato del file è semplice testo?
I dati possono cambiare, ma il formato è comune?

Ad esempio, se usi un formato CSV:

file

1, nome, cognome, telefono
2, nome, cognome, telefono
..

A questo punto potresti usare un file per definire i vari campi (ad esempio uno su ogni linea):

integer
text(30)
text(30)
text(12)

All'avvio del tuo programma leggi il file di configurazione e configuri il programma opportunamente: così facendo conosci il numero di campi, quindi sai già cosa e quanto devi leggere.

Dunque se il formato è comune puoi creare una piccola applicazione in cui passi eventualmente dall'esterno cosa rappresentano quei dati.

[misterx]

ciao,
è un comune file ASCII ma ad esempio un utente potrebbe scrivere erroneamente un indirizzo IP errato

I92.168.1.298

Quindi, una I in luodo di 1 e un valore 298 che fuoriesce dal campo di indirizzamento degli indirizzi IP

Le espressioi regolari mi sembravano una valida soluzione in quanto stabilita una regola poi deve essere verificata.

Sto usando Borland C++ Builder e pensavo che fossero implementate.

[WarDuck]

Originariamente inviato da misterx

ciao,
è un comune file ASCII ma ad esempio un utente potrebbe scrivere erroneamente un indirizzo IP errato

I92.168.1.298

Quindi, una I in luodo di 1 e un valore 298 che fuoriesce dal campo di indirizzamento degli indirizzi IP

Le espressioi regolari mi sembravano una valida soluzione in quanto stabilita una regola poi deve essere verificata.

Sto usando Borland C++ Builder e pensavo che fossero implementate.

Credo che l'espressione regolare per fare questo controllo sia un po' lunga...

Secondo me se sai che sono indirizzi IP ti conviene dividere la stringa in tokens (separati da punto), convertire in numero e controllare che siano nel range corretto.

[misterx]

Originariamente inviato da WarDuck

Credo che l'espressione regolare per fare questo controllo sia un po' lunga...

Secondo me se sai che sono indirizzi IP ti conviene dividere la stringa in tokens (separati da punto), convertire in numero e controllare che siano nel range corretto.

sarebbe interessante vedere sviluppato in C un automa a stati finit per il riconoscimento di quella espressioe regolare.

Non ne ho la più pallida idea di come vengono sviluppati

[WarDuck]

Originariamente inviato da misterx

sarebbe interessante vedere sviluppato in C un automa a stati finit per il riconoscimento di quella espressioe regolare.

Non ne ho la più pallida idea di come vengono sviluppati

Prova a svilupparlo su carta l'automa, ti accorgerai presto che è un po' un casino perché devi tenere conto di molte cose (se vuoi fare una cosa fatta bene).

Ad esempio devi gestire cosa accade se leggi un 2 come prima cifra di un gruppo:

Inizio con 2 -> leggo un numero compreso tra 0..4 -> dopo posso leggere 0..9
Inizio con 2 -> leggo 5 -> dopo posso leggere 0..5
Inizio con 2 -> leggo un numero compreso tra 6..9 -> dopo devo per forza leggere un punto

Devi tenere conto che non puoi iniziare una sequenza con uno 0, ovvero, se leggi uno 0 all'inizio devi per forza di cose leggere un punto.

Se ho fatto bene i conti hai almeno 8 stati diversi.

[misterx]

Originariamente inviato da WarDuck

Prova a svilupparlo su carta l'automa, ti accorgerai presto che è un po' un casino perché devi tenere conto di molte cose (se vuoi fare una cosa fatta bene).

Ad esempio devi gestire cosa accade se leggi un 2 come prima cifra di un gruppo:

Inizio con 2 -> leggo un numero compreso tra 0..4 -> dopo posso leggere 0..9
Inizio con 2 -> leggo 5 -> dopo posso leggere 0..5
Inizio con 2 -> leggo un numero compreso tra 6..9 -> dopo devo per forza leggere un punto

Devi tenere conto che non puoi iniziare una sequenza con uno 0, ovvero, se leggi uno 0 all'inizio devi per forza di cose leggere un punto.

Se ho fatto bene i conti hai almeno 8 stati diversi.

però è molto interessante

Ma verrebbe una serie di:

if(carattere == numero) allora accetta e
cifre++; // incrementa il contatore delle cifre lette

if(carattere == '.' AND cifre == 0) allora NON accetta
if(carattere == '.' AND cifre >= 1) allora accetta

e così via

[VICIUS]

Se ti serve una regex per validare un indirizzo ip puoi usare questa:

\b([01]?\d\d?|2[0-4]\d|25[0-5])\.([01]?\d\d?|2[0-4]\d|25[0-5])\.([01]?\d\d?|2[0-4]\d|25[0-5])\.([01]?\d\d?|2[0-4]\d|25[0-5])\b

Per usarle in un programma c dovrebbe bastare usare pcre come libreria.

[WarDuck]

Originariamente inviato da misterx

però è molto interessante

Ma verrebbe una serie di:

if(carattere == numero) allora accetta e
cifre++; // incrementa il contatore delle cifre lette

if(carattere == '.' AND cifre == 0) allora NON accetta
if(carattere == '.' AND cifre >= 1) allora accetta

e così via

Si può fare in molti modi, ma io non lo farei con una catena di IF secca.

Preferisco una soluzione più elegante, ad esempio usando una struttura del tipo:

typedef struct _stato
{
    struct _stato* Next[255]; /* tabella di transizione: 255 caratteri possibili */
} stato;

stato Stato[10];

void InitStati( )
{
   /* inizializza tutti i Next[i] a NULL (si può anche inizializzare ad uno stato dummy) */

   /* inizializza stati */
   /* ESEMPIO */

   Stato[0].Next['c'] = &( Stato[1] );
}

bool Parse( string Input )
{
    stato* Current = &( Stato[0] ); /* Stato iniziale */

   for (char Ch in Input)
   {
       Current = Current->Next[Ch];
       if ( Current == NULL )
           return false; /* si può evitare questo if usando uno stato dummy */
   }

   return ( Current == &( Stato[1] ) ); /* se sono nello stato finale (1) ritorna true */
}

In pratica il principio è, leggo un carattere, in base allo stato corrente vado allo stato successivo, se lo stato successivo è nullo vuol dire che hai inserito un carattere non ammesso (o per cui non esiste una transizione).

Il tutto senza catene di IF orrende .

Certamente consumi più memoria, in quanto ogni stato ha un array di 255 puntatori (se vuoi contemplare tutti i possibili input ASCII).

Volendo essere più puristi puoi usare uno stato dummy (che ovviamente non può essere finale) che cicla su se stesso qualunque sia il carattere in input.

La differenza in questo caso è che la funzione Parse non termina subito se trova un carattere non valido, ma si legge tutta l'intera stringa.

Una soluzione analoga potrebbe essere quella di usare una matrice con gli indici degli stati.

Se all'interno dello stato devi fare molte cose, potrebbe essere conveniente fare diverse funzioni per ciascuno degli stati, e usare i puntatori a funzione per eseguire di volta in volta lo stato corrente (ergo la funzione specifica dello stato corrente).

Sicuramente quest'ultima soluzione rende di gran lunga più leggibile il codice, piuttosto che usare una lunga sfilza di if-else o di switch-case.

[misterx]

peccato aver visto solo a livello teorico gli automi. La tua tesi si basava sugli automi a stati ?

[misterx]

parlando in termini di open source non sarebbe male se gli utenti postassero codice perfettamente funzionante da mettere a disposizione per chi programma, una cosa del tipo:

verifica dell'indirizzo IP dato come input - ambiente Borland C++ Builder

void __fastcall TForm1::Button1Click(TObject *Sender)
{
        char *token;
        char *line = "192.168.0.32";
        char *search = ".";
        short nm=0;

        token = strtok(line, search);

        if(StrToInt(token) >= 0 && StrToInt(token) <= 255)
        {
                Memo1->Lines->Add(token);
                nm++;
        }
        else
        {
                Memo1->Lines->Add("ERRORE");
                Memo1->Lines->Add(token);
                nm++;
        }

        while( (token = strtok(NULL, search)) != NULL)
        {
                if(StrToInt(token) >= 0 && StrToInt(token) <= 255)
                {
                        Memo1->Lines->Add(token);
                        nm++;
                }
                else
                {
                        Memo1->Lines->Add("ERRORE");
                        Memo1->Lines->Add(token);
                        nm++;
                }
        }

        if(nm < 4 || nm > 4) Memo1->Lines->Add("Formato indirizzo IP errato!!!");

}

[banryu79]

Quella funzione però non fa i controlli che ha indicato WarDuck nel messaggio #6...

@EDIT:

prova ad inserire indirizzi IP a caso

aa.123455.78989.1
500.3.12.90
192.168.90,12

Mica c'ho un compilatore Pascal... come la provo? E comunque basta leggere il codice del corpo della funzione per capire che non fa quei controlli. Quella funzione controlla solo che l'IP sia formato esattamente da 4 campi separati da '.', ognuno formato da un numero intero compreso tra 0 e 255 inclusi.
Ripeto: non fa i controlli che ha indicato WarDuck nel messaggio #6...

[misterx]

Originariamente inviato da banryu79

Quella funzione però non fa i controlli che ha indicato WarDuck nel messaggio #6...

prova ad inserire indirizzi IP a caso

aa.123455.78989.1
500.3.12.90
192.168.90,12

[ESSE-EFFE]

Per validare l'indirizzo IP non serve scomodare le espressioni regolari, basta sfruttare qualche funzione Win32, per esempio:

    char *line = "192.168.0.32";

    if (inet_addr(line) == INADDR_NONE)
    {
        // IP errato
    }
    else
    {
        // IP OK
    }

Gli altri possibili input mi sembrano comunque semplici da parsare.

[misterx]

Originariamente inviato da ESSE-EFFE

Per validare l'indirizzo IP non serve scomodare le espressioni regolari, basta sfruttare qualche funzione Win32, per esempio:

    char *line = "192.168.0.32";

    if (inet_addr(line) == INADDR_NONE)
    {
        // IP errato
    }
    else
    {
        // IP OK
    }

Gli altri possibili input mi sembrano comunque semplici da parsare.

interessante.

Però quello dell'IP era solo la punta dell'icberg. Devo controllare anche dati del tipo
A10.7, SL170
P10.7, PB20 etc...

[ESSE-EFFE]

Originariamente inviato da misterx

Devo controllare anche dati del tipo
A10.7, SL170
P10.7, PB20 etc...

Sì, ho letto, ma come ho già scritto, questi sono formati piuttosto semplici da parsare. Se poi ce ne sono anche di più complicati per cui tanto vale usare le RegEx per tutto, io questo non lo so...

[misterx]

Originariamente inviato da ESSE-EFFE

Sì, ho letto, ma come ho già scritto, questi sono formati piuttosto semplici da parsare. Se poi ce ne sono anche di più complicati per cui tanto vale usare le RegEx per tutto, io questo non lo so...

si, in effetti ne ho molti di più e di diverso formato, per tale motivo ho pensato alle espressioni regolari

[misterx]

Originariamente inviato da VICIUS

Se ti serve una regex per validare un indirizzo ip puoi usare questa:

\b([01]?\d\d?|2[0-4]\d|25[0-5])\.([01]?\d\d?|2[0-4]\d|25[0-5])\.([01]?\d\d?|2[0-4]\d|25[0-5])\.([01]?\d\d?|2[0-4]\d|25[0-5])\b

Per usarle in un programma c dovrebbe bastare usare pcre come libreria.

di quella espressione regolare sarebbe interessante capire come viene caricata in memoria per poi venire usata

[VICIUS]

In genere l'alternanza è ordinata quindi esegue i test nell'ordine in cui sono scritti. Non fa alto che cercare questo (0-199|200-249|250-255) ripetuto 4 volte.

[misterx]

Originariamente inviato da VICIUS

In genere l'alternanza è ordinata quindi esegue i test nell'ordine in cui sono scritti. Non fa alto che cercare questo (0-199|200-249|250-255) ripetuto 4 volte.

la formattazione di espressioni regolari di quel tipo sono stabilite dallo standard POSIX o altro standard?
E' da un pò che cerco ma le informazioni sono abbastanza confuse, forse cerco nei posti sbagliati.

Poi stranamenete non trovo codice C già pronto da studiare che legga quelle espressioni.