campo-sirio/xvaga/matche.cpp

198 lines
8.8 KiB
C++
Raw Normal View History

#include <stdlib.h>
#include "matche.h"
// codici di ritorno della matche()
#define regexp_MATCH_PATTERN (6) // pattern non valido
#define regexp_MATCH_LITERAL (5) // il pattern non coincide su un carattere comune
#define regexp_MATCH_RANGE (4) // il pattern non coincide in un costrutto [..]
#define regexp_MATCH_ABORT (3) // il stringa da confrontare <20> terminata anticipatamente
#define regexp_MATCH_END (2) // il pattern <20> terminato anticipatamente
#define regexp_MATCH_VALID (1) // pattern e stringa coincidono
// codici di ritorno della is_valid_pattern()
#define regexp_PATTERN_VALID (0) // il pattern <20> valido
#define regexp_PATTERN_ESC (-1) // <20> presente un escape aperto a fine pattern
#define regexp_PATTERN_RANGE (-2) // c'<27> un range non chiuso all'interno di un costrutto [..]
#define regexp_PATTERN_CLOSE (-3) // manca la parentesi di chiusura in un costrutto [..]
#define regexp_PATTERN_EMPTY (-4) // c'<27> un costrutto vuoto
// prototipi delle funzioni interne
static int matche(const char *pat, const char *str); // ritorna un codice della classe regexp_MATCH che indica se e in che modo pattern e stringa coincidono
static int matche_after_star(const char *pat, const char *str); // chiama ricorsivamente la matche() con i segmenti puri del pattern e della stringa
static bool is_pattern(const char *pat); // ritorna true se la stringa <20> un pattern
static bool is_valid_pattern(const char *pat, int *err= NULL); // ritorna true se la stringa <20> un pattern valido, indica un codice di ritorno della classe regexp_PATTERN nel secondo parametro
static bool is_pattern(const char *p) {
while (*p) {
switch (*p++) {
case '?':
case '*':
case '[':
case '\\':
return true;
}
}
return false;
}
static bool is_valid_pattern(const char *p, int *error_type) {
if (error_type != NULL) *error_type= regexp_PATTERN_VALID; // inizializzazione del tipo d'errore
while (*p) { // ciclo all'interno del pattern fino a fine stringa
switch(*p) { // determinazione del tipo di wild card nel pattern
case '\\': // controllo dell'escape, non pu<70> essere a fine pattern
if (!*++p) {
if (error_type != NULL) *error_type= regexp_PATTERN_ESC;
return false;
}
p++;
break;
case '[': // controllo della costruzione del costrutto [..]
p++;
if (*p == ']') { // se il prossimo carattere <20> ']' il costrutto <20> vuoto
if (error_type != NULL) *error_type= regexp_PATTERN_EMPTY;
return false;
}
if (!*p) { // se si <20> a fine stringa il costrutto non <20> chiuso
if (error_type != NULL) *error_type= regexp_PATTERN_CLOSE;
return false;
}
while (*p != ']') { // ciclo fino a fine costrutto [..]
if (*p == '\\') { // controllo per gli escape
p++;
if (!*p++) { // controllo che l'escape non sia a fine pattern
if (error_type != NULL) *error_type= regexp_PATTERN_ESC;
return false;
}
} else p++;
if (!*p) { // se si <20> a fine stringa il costrutto non <20> chiuso
if (error_type != NULL) *error_type= regexp_PATTERN_CLOSE;
return false;
}
if (*p == '-') { // controllo di un eventuale range
if (!*++p || *p == ']') { // deve esistere una fine del range
if (error_type != NULL) *error_type= regexp_PATTERN_RANGE;
return false;
} else {
if (*p == '\\') p++; // controllo degli escape
if (!*p++) { // controllo che l'escape non sia a fine pattern
if (error_type != NULL) *error_type= regexp_PATTERN_ESC;
return false;
}
}
}
}
break;
case '*': // tutti gli altri caratteri sono elementi validi del pattern
case '?':
default:
p++; // caratteri normali
break;
}
}
return true;
}
static int matche_after_star(const char *p, const char *t) {
int match= 0;
while (*p == '?' || *p == '*') { // salto degli eventuali '*' e '?'
if (*p == '?') // salto di un carattere per ciascun '?'
if (!*t++) return regexp_MATCH_ABORT; // se la stringa termina qui non c'<27> coincidenza
p++; // posizionamento sul prossimo carattere del pattern
}
if (!*p) return regexp_MATCH_VALID; //se il pattern <20> concluso c'<27> coincidenza
int nextp= *p; // prelevamento del prossimo carattere, normale o '['
if (nextp == '\\') {
nextp= p[1];
if (!nextp) return regexp_MATCH_PATTERN; // se il pattern termina qui non <20> valido
}
do { // ciclo fino a conclusione di stringa o pattern
if (nextp == *t || nextp == '[') match= matche(p, t); // <20> necessario che il carattere corrente del testo coincida con il carattere corrente del pattern, oppure che il pattern abbia un inizio di costrutto [..]
if (!*t++) match= regexp_MATCH_ABORT; // se la stringa termina qui non c'<27> coincidenza
} while (match != regexp_MATCH_VALID && match != regexp_MATCH_ABORT && match != regexp_MATCH_PATTERN);
return match; // ritorno del risultato
}
static int matche(const char *p, const char *t) {
for (; *p; p++, t++) {
if (!*t) // se si <20> alla fine della stringa, il confronto <20> concluso
return (*p == '*' && *++p == '\0') ? regexp_MATCH_VALID : regexp_MATCH_ABORT;
switch (*p) { // determina il tipo di wild card del pattern
case '?': // carattere singolo, qualunque carattere coincide
break;
case '*': // sottostringa, coincide qualunque sequenza di caratteri
return matche_after_star (p, t);
case '[': { // costrutto [..], controllo di coincidenza per inclusione o esclusione su un solo carattere
p++; // posizionamento all'inizio del range
bool invert= false; // controllo di inclusione o esclusione del costrutto
if (*p == '!' || *p == '^') {
invert= true;
p++;
}
if (*p == ']') // se si <20> su una chiusura di costrutto il pattern non <20> valido
return regexp_MATCH_PATTERN;
bool member_match= false;
bool loop= true;
while (loop) {
char range_start, range_end; // inizio e fine del range corrente
if (*p == ']') { // se si <20> alla fine del costrutto il ciclo si conclude
loop= false;
continue;
}
if (*p == '\\') // controllo di coincidenza su un metacarattere, dopo un escape
range_start= range_end= *++p;
else
range_start= range_end= *p;
if (!*p) return regexp_MATCH_PATTERN; // se il pattern termina non <20> valido
if (*++p == '-') { // controllo del segno di sottoinsieme
range_end= *++p; // impostazione della fine del range
if (range_end == '\0' || range_end == ']') return regexp_MATCH_PATTERN; // se il costrutto [..] o il pattern terminano qui allora il pattern non <20> valido
if (range_end == '\\') { // la fine del range <20> un metacarattere
range_end= *++p;
if (!range_end) return regexp_MATCH_PATTERN; // se il pattern termina non <20> valido
}
p++; // posizionamento oltre il range
}
if (range_start < range_end) { // confronto del carattere corrente con il costrutto, controllo della sequenzialit<69> degli estremi del range
if (*t >= range_start && *t <= range_end) {
member_match= true;
loop= false;
}
} else {
if (*t >= range_end && *t <= range_start) {
member_match= true;
loop= false;
}
}
}
if ((invert && member_match) || !(invert || member_match)) // controllo del risultato dell'ultimo confronto nel costrutto [..]
return regexp_MATCH_RANGE;
if (member_match) { // salto del resto del costrutto se non <20> esclusivo
while (*p != ']') {
if (!*p) return regexp_MATCH_PATTERN; // se si <20> a fine pattern il costrutto non <20> valido
if (*p == '\\') { // salto di un confronto con un metacarattere
p++;
if (!*p) return regexp_MATCH_PATTERN; // se il pattern termina qui non <20> valido
}
p++; // posizionamento sul prossimo carattere del pattern
}
}
break;
}
case '\\': // confronto con un metacarattere
p++; // posizionamento sul carattere da confrontare
if (!*p) return regexp_MATCH_PATTERN; // se il pattern termina qui non <20> valido
default: // confronto con un carattere normale
if (*p != *t) return regexp_MATCH_LITERAL;
}
}
if (*t) return regexp_MATCH_END; // se la stringa non <20> conclusa non c'<27> coincidenza
else return regexp_MATCH_VALID;
}
bool match(const char *pat, const char *str)
{
const int err = matche(pat, str);
return (err == regexp_MATCH_VALID); // ritorna true se il pattern e la stringa coincidono
}