From 0efdf8c11e50d6aed89ed72760a72e68b701bf9d Mon Sep 17 00:00:00 2001 From: bustico Date: Wed, 20 Sep 2006 09:28:59 +0000 Subject: Ajout de la fonctionnalité pour capter des intervalles numériques de la forme A=((?I10#20)) l'api ne change pas. --- src/intervalRegexp.c | 423 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 423 insertions(+) create mode 100644 src/intervalRegexp.c (limited to 'src/intervalRegexp.c') diff --git a/src/intervalRegexp.c b/src/intervalRegexp.c new file mode 100644 index 0000000..6658194 --- /dev/null +++ b/src/intervalRegexp.c @@ -0,0 +1,423 @@ +#include +#include +#include +#include +#include + +#include "intervalRegexp.h" + + +#define Perr(...) (perr ( __PRETTY_FUNCTION__, __VA_ARGS__)) +#define CHECK_AND_RETURN(a) if (strlen (locBuf) <= buflen) { \ + strcpy (a, locBuf); \ + return success; \ + } else { \ + return Perr ("CHECK_AND_RETURN"); } + +#define EndLocBuf (&(locBuf[strlen(locBuf)])) +#define AddLocBuf(...) snprintf (EndLocBuf, sizeof (locBuf)-strlen(locBuf), __VA_ARGS__) + +typedef struct { + int max; + int rank; +} NextMax ; + + +typedef char bool; + +const bool success = 1; +const bool fail = 0; + + +static bool strictPosRegexpGen (char *regexp, unsigned int buflen, long min, long max, const char* decimalPart, + const char* boundDecimalPart); +static bool genAtRank (char *regexp, unsigned int buflen, const char *min, const char *max, int rank); +static bool genPreRank (char *preRank, unsigned int buflen, const char *min, const char *max, int rank); +static bool genRank (char *outRank, unsigned int buflen, const char *min, const char *max, int rank); +static bool genPostRank (char *postRank, unsigned int buflen, int rank); +static bool substr (char *substring, unsigned int buflen, const char* expr, int pos, int len); +static char* reverse (char *string); +static char* ltoa (char *string, unsigned int buflen, long n); +static NextMax nextMax (const char *min, const char *max); +static bool perr (const char* func, const char *fmt, ...); + +static inline int maxint (int a, int b) {return ((a) > (b) ? (a) : (b));} +static inline int minint (int a, int b) {return ((a) < (b) ? (a) : (b));} + + + + + +/* +# __ _ _ __ _____ +# / _` | | '_ \ / ____| +# _ __ ___ | (_| | ___ __ __ | |_) | | | __ ___ _ __ +# | '__| / _ \ \__, | / _ \ \ \/ / | .__/ | | |_ | / _ \ | '_ \ +# | | | __/ __/ | | __/ > < | | | |__| | | __/ | | | | +# |_| \___| |___/ \___| /_/\_\ |_| \_____| \___| |_| |_| +*/ +int regexpGen (char *regexp, unsigned int buflen, long min, long max, int flottant) +{ + char *decimalPart = ""; + char *boundDecimalPart = ""; + char locBuf [8192] = "(?:"; + + + if (flottant) { + decimalPart = "(?:\\.\\d+)?"; + boundDecimalPart = "(?:\\.0+)?"; + } + + if (min > max) { + int nmin = max; + max = min; + min = nmin; + } + + if (min == max) { + AddLocBuf ("%ld%s", min, decimalPart); + } else if (min < 0) { + if (max < 0) { + // reg = '\-(?:' . strictPosRegexpGen (-max, -min, decimalPart, boundDecimalPart). ')'; + AddLocBuf ("\\-(?:"); + if (strictPosRegexpGen (EndLocBuf, sizeof (locBuf)-strlen(locBuf), -min, -max, decimalPart, + boundDecimalPart) == fail) return fail; + AddLocBuf (")"); + } else if (max == 0) { + AddLocBuf ("(?:0%s)|(?:-0%s)|-(?:", boundDecimalPart, decimalPart); + if (strictPosRegexpGen (EndLocBuf, sizeof (locBuf)-strlen(locBuf), 1, -min, decimalPart, + boundDecimalPart)== fail) return fail; + AddLocBuf (")"); + } else { + //reg ='(?:' . regexpGen (min, 0,withDecimal) . '|' . regexpGen (0, max, withDecimal). ')' ; + AddLocBuf ("(?:"); + if (regexpGen (EndLocBuf, sizeof (locBuf)-strlen(locBuf), min, 0, flottant)== fail) return fail; + AddLocBuf ("|"); + if (regexpGen (EndLocBuf, sizeof (locBuf)-strlen(locBuf), 0, max, flottant)== fail) return fail; + AddLocBuf (")"); + } + } else if (min == 0) { + // reg = "(?:0{decimalPart})|" . strictPosRegexpGen (1, max, decimalPart,boundDecimalPart) ; + AddLocBuf ("(?:0%s)|",decimalPart); + if (strictPosRegexpGen (EndLocBuf, sizeof (locBuf)-strlen(locBuf), 1, max, decimalPart, + boundDecimalPart)== fail) return fail; + } else { + if (strictPosRegexpGen (EndLocBuf, sizeof (locBuf)-strlen(locBuf), min, max, decimalPart, + boundDecimalPart)== fail) return fail; + } + + AddLocBuf (")(?![\\d.])"); + CHECK_AND_RETURN (regexp); +} + +/* +# _ _ _ _____ +# | | (_) | | | __ \ +# ___ | |_ _ __ _ ___ | |_ | |__) | ___ ___ +# / __| | __| | '__| | | / __| | __| | ___/ / _ \ / __| +# \__ \ \ |_ | | | | | (__ \ |_ | | | (_) | \__ \ +# |___/ \__| |_| |_| \___| \__| |_| \___/ |___/ +# _____ __ _ _ __ _____ +# | __ \ / _` | | '_ \ / ____| +# | |__) | ___ | (_| | ___ __ __ | |_) | | | __ ___ _ __ +# | _ / / _ \ \__, | / _ \ \ \/ / | .__/ | | |_ | / _ \ | '_ \ +# | | \ \ | __/ __/ | | __/ > < | | | |__| | | __/ | | | | +# |_| \_\ \___| |___/ \___| /_/\_\ |_| \_____| \___| |_| |_| +*/ +static bool strictPosRegexpGen (char *regexp, unsigned int buflen, long min, long max, const char* decimalPart, + const char* boundDecimalPart) +{ + const int maxSubReg=64; + const int digitRegSize=128; + char regList[maxSubReg][digitRegSize]; + char locBuf[maxSubReg*digitRegSize] ; + int regIndex=0,i; + int nbRank; + char maxAsString[32], minAsString[32]; + NextMax nMax; + + + if ((min <= 0) || (max <= 0)) return Perr ("min or max <= 0"); + if (min == max) { + sprintf (EndLocBuf, "%ld", max); + } else { + + max--; + + nbRank = strlen (ltoa (maxAsString, sizeof (maxAsString), max)); + do { + nMax = nextMax (ltoa (minAsString, sizeof (minAsString), min), + ltoa (maxAsString, sizeof (maxAsString), max)); + if (genAtRank (regList[regIndex++], digitRegSize, minAsString, + ltoa (maxAsString, sizeof (maxAsString), + nMax.max), nMax.rank) == fail) return fail; + if (regIndex == maxSubReg) return Perr ("regIndex == maxSubReg"); + min = nMax.max +1; + } while (nMax.max != max); + + locBuf[0] = 0; + for (i=0; i < \ |_ | | | | | (_| | > < +# |_| |_| \___| /_/\_\ \__| |_| |_| \__,_| /_/\_\ +*/ +static NextMax nextMax (const char *min, const char *max) +{ + NextMax nextMax ={0,0}; + char revMin[32], revMax[32]; + int nbDigitsMin, nbDigitsMax; + int rankRev=0, rankForw, rank=0, i; + int currMax; + + nbDigitsMin = strlen (min); + nbDigitsMax = strlen (max); + + for (i=nbDigitsMin-1; i >= 0; i--) { + revMin[nbDigitsMin-i-1]= min[i]; + // printf ("DBG> nextMax revMin[%d]= %c\n", nbDigitsMin-i-1, min[i]); + } + for (i=nbDigitsMax-nbDigitsMin; i >= 0; i--) { + revMin[nbDigitsMax-i]= '0'; + // printf ("DBG> nextMax revMin[%d]= %c\n", nbDigitsMax-i, '0'); + } + + for (i=nbDigitsMax-1; i >= 0; i--) { + revMax[nbDigitsMax-i-1]= max[i]; + } + revMin[nbDigitsMax] = revMax[nbDigitsMax] = 0; + rankForw = nbDigitsMax -1; + + // printf ("DBG> nextMax rev(%s)=%s rev(%s)=%s rankForw=%d\n", min, revMin, max, revMax, rankForw); + + // en partant des unitées (digit de poids faible), premier digit de min != 0 + while ((revMin[rankRev] == '0') && (rankRev < nbDigitsMax)) rankRev++; + // en partant du digit de poids fort, premier digit de max != du même digit de revMin + while ((revMin[rankForw] == revMax[rankForw]) && rankForw > 0) rankForw--; + + if (rankForw <= rankRev) { + rank = rankForw; + revMin[rankForw]= revMax[rankForw] - (rankForw ? 1 : 0); + for (i=0; i currMax) nextMax.max = currMax; + + // printf ("DBG> nextMax ('%s', '%s') = %d@%d\n", min, max, nextMax.max, nextMax.rank); + return (nextMax); +} + + +/* +# __ _ ____ _ +# / _` | / __ \ | | +# | (_| | ___ _ __ / / _` | _ __ __ _ _ __ | | _ +# \__, | / _ \ | '_ \ | | (_| | | '__| / _` | | '_ \ | |/ / +# __/ | | __/ | | | | \ \__,_| | | | (_| | | | | | | < +# |___/ \___| |_| |_| \____/ |_| \__,_| |_| |_| |_|\_\ +*/ +static bool genAtRank (char *regexp, unsigned int buflen, const char *min, const char *max, int rank) +{ + char locBuf [512]; + + if (genPreRank (locBuf, sizeof (locBuf), min, max, rank) == fail) return (fail); + if (genRank (EndLocBuf, sizeof (locBuf)-strlen(locBuf), min, max, rank) == fail) return (fail); + if (genPostRank (EndLocBuf, sizeof (locBuf)-strlen(locBuf), rank) == fail) return (fail); + + + CHECK_AND_RETURN (regexp); +} + +/* +# __ _ _____ _____ _ +# / _` | | __ \ | __ \ | | +# | (_| | ___ _ __ | |__) | _ __ ___ | |__) | __ _ _ __ | | _ +# \__, | / _ \ | '_ \ | ___/ | '__| / _ \ | _ / / _` | | '_ \ | |/ / +# __/ | | __/ | | | | | | | | | __/ | | \ \ | (_| | | | | | | < +# |___/ \___| |_| |_| |_| |_| \___| |_| \_\ \__,_| |_| |_| |_|\_\ +*/ +static bool genPreRank (char *preRank, unsigned int buflen, const char *min, const char *max, int rank) +{ + char locBuf [512], locBufMax[512]; + const char *lmin, *lmax; + int i=0, j=0; + + while (min[i] == '0') i++; + while (max[j] == '0') j++; + + lmin = &(min[i]); + lmax = &(max[j]); + + // printf ("DBG> genPreRank (lmin='%s'[%d], lmax='%s'[%d], rank=%d\n", lmin, (int) strlen (lmin), lmax, + // (int) strlen (lmax), rank); + + if (substr (locBuf, sizeof (locBuf), lmin, 0, strlen (lmin) - rank) == fail) return fail; + if (substr (locBufMax, sizeof (locBufMax), lmax, 0, strlen (lmax) - rank) == fail) return fail; + + if (strncmp (locBuf, locBufMax, minint (sizeof (locBuf), sizeof (locBufMax))) != 0) + return Perr ("min=%s[%s] and max=%s[%s] should be invariants at rank %d", locBuf, min, locBufMax, max, rank); + + // printf ("DBG> genPreRank ('%s', '%s', %d) = '%s'\n", min, max, rank, locBuf); + + CHECK_AND_RETURN (preRank); +} + + +/* +# __ _ _____ _ +# / _` | | __ \ | | +# | (_| | ___ _ __ | |__) | __ _ _ __ | | _ +# \__, | / _ \ | '_ \ | _ / / _` | | '_ \ | |/ / +# __/ | | __/ | | | | | | \ \ | (_| | | | | | | < +# |___/ \___| |_| |_| |_| \_\ \__,_| |_| |_| |_|\_\ +*/ +static bool genRank (char *outRank, unsigned int buflen, const char *min, const char *max, int rank) +{ + char locBuf [512]; + + char a,b,lmin,lmax; + a = min[strlen(min)-rank]; + b = max[strlen(max)-rank]; + + lmin = (char) minint (a,b); + lmax = (char) maxint (a,b); + + if ((lmin == '0') && (lmax == '9')) { + strcpy (locBuf, "\\d"); + } else if (lmin == lmax) { + locBuf[0] = lmin; + locBuf[1] = 0; + } else if (lmax == (lmin+1)) { + sprintf (locBuf, "[%c%c]", lmin, lmax); + } else { + sprintf (locBuf, "[%c-%c]", lmin, lmax); + } + + CHECK_AND_RETURN (outRank); +} + +/* +# __ _ _____ _ _____ +# / _` | | __ \ | | | __ \ +# | (_| | ___ _ __ | |__) | ___ ___ | |_ | |__) | __ _ _ __ +# \__, | / _ \ | '_ \ | ___/ / _ \ / __| | __| | _ / / _` | | '_ \ +# __/ | | __/ | | | | | | | (_) | \__ \ \ |_ | | \ \ | (_| | | | | | +# |___/ \___| |_| |_| |_| \___/ |___/ \__| |_| \_\ \__,_| |_| |_| +*/ +static bool genPostRank (char *postRank, unsigned int buflen, int rank) +{ + char locBuf [512]; + + if (rank <= 1) { + strcpy (locBuf, ""); + } else if (rank == 2) { + sprintf (locBuf, "\\d"); + } else { + sprintf (locBuf, "\\d{%d}", rank -1); + } + + CHECK_AND_RETURN (postRank); +} + +/* +# _ _ +# | | | | +# ___ _ _ | |__ ___ | |_ _ __ +# / __| | | | | | '_ \ / __| | __| | '__| +# \__ \ | |_| | | |_) | \__ \ \ |_ | | +# |___/ \__,_| |_.__/ |___/ \__| |_| +*/ +static bool substr (char *substring, unsigned int buflen, const char* expr, int pos, int len) +{ + char locBuf [512]; + int i, j=0; + + len = maxint (0, minint (len, strlen (expr) - pos)); + for (i=pos; i<(pos+len); i++) { + locBuf[j++]= expr[i]; + } + locBuf[j] = 0; + + // printf ("DBG> substr ('%s', %d, %d) = '%s'\n", expr, pos, len, locBuf); + CHECK_AND_RETURN (substring); +} + +/* +# +# +# _ __ ___ __ __ ___ _ __ ___ ___ +# | '__| / _ \ \ \ / / / _ \ | '__| / __| / _ \ +# | | | __/ \ V / | __/ | | \__ \ | __/ +# |_| \___| \_/ \___| |_| |___/ \___| +*/ +static char* reverse (char *string) +{ + char *locBuf ; + int i; + int len = strlen (string); + + locBuf = malloc (len+1); + for (i=len-1; i >= 0; i--) { + locBuf[len-i-1]= string[i]; + //printf ("DBG> reverse locBuf[%d]= %c\n",len- i-1, string[i]); + } + locBuf [len] = 0; + + // printf ("DBG> reverse '%s' = '%s'\n", string, locBuf); + strcpy (string, locBuf); + free (locBuf); + return (string); +} + +static char* ltoa (char *string, unsigned int buflen, long n) +{ + snprintf (string, buflen, "%ld", n); + return (string); +} + + +/* +# _ __ +# | '_ \ +# | |_) | ___ _ __ _ __ +# | .__/ / _ \ | '__| | '__| +# | | | __/ | | | | +# |_| \___| |_| |_| +*/ +static bool perr (const char* func, const char *fmt, ...) +{ + char err[4096], buffer[2048]; + va_list args; + va_start( args, fmt ); + vsprintf( buffer, fmt, args ); + va_end( args ); + + + sprintf (err, "Erreur %s @ %s\n", buffer, func); + fprintf (stderr, err); + return (fail); +} -- cgit v1.1 From 0e1ee0d3f027489c978e27ed5ed3572067234a61 Mon Sep 17 00:00:00 2001 From: fcolin Date: Fri, 22 Sep 2006 08:55:57 +0000 Subject: portage WIN32 --- src/intervalRegexp.c | 50 +++++++++++++++++++++++++++++--------------------- 1 file changed, 29 insertions(+), 21 deletions(-) (limited to 'src/intervalRegexp.c') diff --git a/src/intervalRegexp.c b/src/intervalRegexp.c index 6658194..77fb99a 100644 --- a/src/intervalRegexp.c +++ b/src/intervalRegexp.c @@ -6,6 +6,14 @@ #include "intervalRegexp.h" +#ifdef __PRETTY_FUNCTION__ +#else +#define __PRETTY_FUNCTION__ __FUNCTION__ +#endif + + +#define MAXINT( a , b ) ((a) > (b) ? (a) : (b)) +#define MININT( a , b ) ((a) < (b) ? (a) : (b)) #define Perr(...) (perr ( __PRETTY_FUNCTION__, __VA_ARGS__)) #define CHECK_AND_RETURN(a) if (strlen (locBuf) <= buflen) { \ @@ -15,6 +23,9 @@ return Perr ("CHECK_AND_RETURN"); } #define EndLocBuf (&(locBuf[strlen(locBuf)])) +#ifdef WIN32 +#define snprintf _snprintf +#endif #define AddLocBuf(...) snprintf (EndLocBuf, sizeof (locBuf)-strlen(locBuf), __VA_ARGS__) typedef struct { @@ -35,17 +46,12 @@ static bool genAtRank (char *regexp, unsigned int buflen, const char *min, const static bool genPreRank (char *preRank, unsigned int buflen, const char *min, const char *max, int rank); static bool genRank (char *outRank, unsigned int buflen, const char *min, const char *max, int rank); static bool genPostRank (char *postRank, unsigned int buflen, int rank); -static bool substr (char *substring, unsigned int buflen, const char* expr, int pos, int len); +static bool substr (char *substring, unsigned int buflen, const char* expr, size_t pos, size_t len); static char* reverse (char *string); -static char* ltoa (char *string, unsigned int buflen, long n); +static char* longtoa (char *string, unsigned int buflen, long n); static NextMax nextMax (const char *min, const char *max); static bool perr (const char* func, const char *fmt, ...); -static inline int maxint (int a, int b) {return ((a) > (b) ? (a) : (b));} -static inline int minint (int a, int b) {return ((a) < (b) ? (a) : (b));} - - - /* @@ -127,8 +133,10 @@ int regexpGen (char *regexp, unsigned int buflen, long min, long max, int flotta static bool strictPosRegexpGen (char *regexp, unsigned int buflen, long min, long max, const char* decimalPart, const char* boundDecimalPart) { - const int maxSubReg=64; - const int digitRegSize=128; + +#define maxSubReg 64 +#define digitRegSize 128 + char regList[maxSubReg][digitRegSize]; char locBuf[maxSubReg*digitRegSize] ; int regIndex=0,i; @@ -144,12 +152,12 @@ static bool strictPosRegexpGen (char *regexp, unsigned int buflen, long min, lon max--; - nbRank = strlen (ltoa (maxAsString, sizeof (maxAsString), max)); + nbRank = strlen (longtoa (maxAsString, sizeof (maxAsString), max)); do { - nMax = nextMax (ltoa (minAsString, sizeof (minAsString), min), - ltoa (maxAsString, sizeof (maxAsString), max)); + nMax = nextMax (longtoa (minAsString, sizeof (minAsString), min), + longtoa (maxAsString, sizeof (maxAsString), max)); if (genAtRank (regList[regIndex++], digitRegSize, minAsString, - ltoa (maxAsString, sizeof (maxAsString), + longtoa (maxAsString, sizeof (maxAsString), nMax.max), nMax.rank) == fail) return fail; if (regIndex == maxSubReg) return Perr ("regIndex == maxSubReg"); min = nMax.max +1; @@ -165,7 +173,7 @@ static bool strictPosRegexpGen (char *regexp, unsigned int buflen, long min, lon } max++; sprintf (EndLocBuf, "|(?:%s%s)", - ltoa (maxAsString, sizeof (maxAsString), max), boundDecimalPart); + longtoa (maxAsString, sizeof (maxAsString), max), boundDecimalPart); } CHECK_AND_RETURN (regexp); @@ -278,7 +286,7 @@ static bool genPreRank (char *preRank, unsigned int buflen, const char *min, con if (substr (locBuf, sizeof (locBuf), lmin, 0, strlen (lmin) - rank) == fail) return fail; if (substr (locBufMax, sizeof (locBufMax), lmax, 0, strlen (lmax) - rank) == fail) return fail; - if (strncmp (locBuf, locBufMax, minint (sizeof (locBuf), sizeof (locBufMax))) != 0) + if (strncmp (locBuf, locBufMax, MININT (sizeof (locBuf), sizeof (locBufMax))) != 0) return Perr ("min=%s[%s] and max=%s[%s] should be invariants at rank %d", locBuf, min, locBufMax, max, rank); // printf ("DBG> genPreRank ('%s', '%s', %d) = '%s'\n", min, max, rank, locBuf); @@ -303,8 +311,8 @@ static bool genRank (char *outRank, unsigned int buflen, const char *min, const a = min[strlen(min)-rank]; b = max[strlen(max)-rank]; - lmin = (char) minint (a,b); - lmax = (char) maxint (a,b); + lmin = MININT (a,b); + lmax = MAXINT (a,b); if ((lmin == '0') && (lmax == '9')) { strcpy (locBuf, "\\d"); @@ -351,12 +359,12 @@ static bool genPostRank (char *postRank, unsigned int buflen, int rank) # \__ \ | |_| | | |_) | \__ \ \ |_ | | # |___/ \__,_| |_.__/ |___/ \__| |_| */ -static bool substr (char *substring, unsigned int buflen, const char* expr, int pos, int len) +static bool substr (char *substring, unsigned int buflen, const char* expr, size_t pos, size_t len) { char locBuf [512]; - int i, j=0; + size_t i, j=0; - len = maxint (0, minint (len, strlen (expr) - pos)); + len = MAXINT (0, MININT (len, strlen (expr) - pos)); for (i=pos; i<(pos+len); i++) { locBuf[j++]= expr[i]; } @@ -393,7 +401,7 @@ static char* reverse (char *string) return (string); } -static char* ltoa (char *string, unsigned int buflen, long n) +static char* longtoa (char *string, unsigned int buflen, long n) { snprintf (string, buflen, "%ld", n); return (string); -- cgit v1.1 From 0a280c3a27b03a1267d1057604df000218e26416 Mon Sep 17 00:00:00 2001 From: fcolin Date: Fri, 22 Sep 2006 09:24:02 +0000 Subject: remove some WIN32 warning add module intervalRegexp in Makefile.win32 --- src/intervalRegexp.c | 42 +++++++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 21 deletions(-) (limited to 'src/intervalRegexp.c') diff --git a/src/intervalRegexp.c b/src/intervalRegexp.c index 77fb99a..fb5f3bc 100644 --- a/src/intervalRegexp.c +++ b/src/intervalRegexp.c @@ -40,15 +40,15 @@ const bool success = 1; const bool fail = 0; -static bool strictPosRegexpGen (char *regexp, unsigned int buflen, long min, long max, const char* decimalPart, +static bool strictPosRegexpGen (char *regexp, size_t buflen, long min, long max, const char* decimalPart, const char* boundDecimalPart); -static bool genAtRank (char *regexp, unsigned int buflen, const char *min, const char *max, int rank); -static bool genPreRank (char *preRank, unsigned int buflen, const char *min, const char *max, int rank); -static bool genRank (char *outRank, unsigned int buflen, const char *min, const char *max, int rank); -static bool genPostRank (char *postRank, unsigned int buflen, int rank); -static bool substr (char *substring, unsigned int buflen, const char* expr, size_t pos, size_t len); +static bool genAtRank (char *regexp, size_t buflen, const char *min, const char *max, int rank); +static bool genPreRank (char *preRank, size_t buflen, const char *min, const char *max, int rank); +static bool genRank (char *outRank, size_t buflen, const char *min, const char *max, int rank); +static bool genPostRank (char *postRank, size_t buflen, int rank); +static bool substr (char *substring, size_t buflen, const char* expr, size_t pos, size_t len); static char* reverse (char *string); -static char* longtoa (char *string, unsigned int buflen, long n); +static char* longtoa (char *string, size_t buflen, long n); static NextMax nextMax (const char *min, const char *max); static bool perr (const char* func, const char *fmt, ...); @@ -62,7 +62,7 @@ static bool perr (const char* func, const char *fmt, ...); # | | | __/ __/ | | __/ > < | | | |__| | | __/ | | | | # |_| \___| |___/ \___| /_/\_\ |_| \_____| \___| |_| |_| */ -int regexpGen (char *regexp, unsigned int buflen, long min, long max, int flottant) +int regexpGen (char *regexp, size_t buflen, long min, long max, int flottant) { char *decimalPart = ""; char *boundDecimalPart = ""; @@ -130,7 +130,7 @@ int regexpGen (char *regexp, unsigned int buflen, long min, long max, int flotta # | | \ \ | __/ __/ | | __/ > < | | | |__| | | __/ | | | | # |_| \_\ \___| |___/ \___| /_/\_\ |_| \_____| \___| |_| |_| */ -static bool strictPosRegexpGen (char *regexp, unsigned int buflen, long min, long max, const char* decimalPart, +static bool strictPosRegexpGen (char *regexp, size_t buflen, long min, long max, const char* decimalPart, const char* boundDecimalPart) { @@ -139,8 +139,8 @@ static bool strictPosRegexpGen (char *regexp, unsigned int buflen, long min, lon char regList[maxSubReg][digitRegSize]; char locBuf[maxSubReg*digitRegSize] ; - int regIndex=0,i; - int nbRank; + size_t regIndex=0,i; + size_t nbRank; char maxAsString[32], minAsString[32]; NextMax nMax; @@ -191,8 +191,8 @@ static NextMax nextMax (const char *min, const char *max) { NextMax nextMax ={0,0}; char revMin[32], revMax[32]; - int nbDigitsMin, nbDigitsMax; - int rankRev=0, rankForw, rank=0, i; + size_t nbDigitsMin, nbDigitsMax; + size_t rankRev=0, rankForw, rank=0, i; int currMax; nbDigitsMin = strlen (min); @@ -248,7 +248,7 @@ static NextMax nextMax (const char *min, const char *max) # __/ | | __/ | | | | \ \__,_| | | | (_| | | | | | | < # |___/ \___| |_| |_| \____/ |_| \__,_| |_| |_| |_|\_\ */ -static bool genAtRank (char *regexp, unsigned int buflen, const char *min, const char *max, int rank) +static bool genAtRank (char *regexp, size_t buflen, const char *min, const char *max, int rank) { char locBuf [512]; @@ -268,7 +268,7 @@ static bool genAtRank (char *regexp, unsigned int buflen, const char *min, const # __/ | | __/ | | | | | | | | | __/ | | \ \ | (_| | | | | | | < # |___/ \___| |_| |_| |_| |_| \___| |_| \_\ \__,_| |_| |_| |_|\_\ */ -static bool genPreRank (char *preRank, unsigned int buflen, const char *min, const char *max, int rank) +static bool genPreRank (char *preRank, size_t buflen, const char *min, const char *max, int rank) { char locBuf [512], locBufMax[512]; const char *lmin, *lmax; @@ -303,7 +303,7 @@ static bool genPreRank (char *preRank, unsigned int buflen, const char *min, con # __/ | | __/ | | | | | | \ \ | (_| | | | | | | < # |___/ \___| |_| |_| |_| \_\ \__,_| |_| |_| |_|\_\ */ -static bool genRank (char *outRank, unsigned int buflen, const char *min, const char *max, int rank) +static bool genRank (char *outRank, size_t buflen, const char *min, const char *max, int rank) { char locBuf [512]; @@ -336,7 +336,7 @@ static bool genRank (char *outRank, unsigned int buflen, const char *min, const # __/ | | __/ | | | | | | | (_) | \__ \ \ |_ | | \ \ | (_| | | | | | # |___/ \___| |_| |_| |_| \___/ |___/ \__| |_| \_\ \__,_| |_| |_| */ -static bool genPostRank (char *postRank, unsigned int buflen, int rank) +static bool genPostRank (char *postRank, size_t buflen, int rank) { char locBuf [512]; @@ -359,7 +359,7 @@ static bool genPostRank (char *postRank, unsigned int buflen, int rank) # \__ \ | |_| | | |_) | \__ \ \ |_ | | # |___/ \__,_| |_.__/ |___/ \__| |_| */ -static bool substr (char *substring, unsigned int buflen, const char* expr, size_t pos, size_t len) +static bool substr (char *substring, size_t buflen, const char* expr, size_t pos, size_t len) { char locBuf [512]; size_t i, j=0; @@ -385,8 +385,8 @@ static bool substr (char *substring, unsigned int buflen, const char* expr, size static char* reverse (char *string) { char *locBuf ; - int i; - int len = strlen (string); + size_t i; + size_t len = strlen (string); locBuf = malloc (len+1); for (i=len-1; i >= 0; i--) { @@ -401,7 +401,7 @@ static char* reverse (char *string) return (string); } -static char* longtoa (char *string, unsigned int buflen, long n) +static char* longtoa (char *string, size_t buflen, long n) { snprintf (string, buflen, "%ld", n); return (string); -- cgit v1.1 From 55a2769f5c6ef98adc63d06b637a2b37733cb35b Mon Sep 17 00:00:00 2001 From: fcolin Date: Fri, 22 Sep 2006 12:35:46 +0000 Subject: correction bug introduit avec size_t --- src/intervalRegexp.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'src/intervalRegexp.c') diff --git a/src/intervalRegexp.c b/src/intervalRegexp.c index fb5f3bc..0132fce 100644 --- a/src/intervalRegexp.c +++ b/src/intervalRegexp.c @@ -192,7 +192,8 @@ static NextMax nextMax (const char *min, const char *max) NextMax nextMax ={0,0}; char revMin[32], revMax[32]; size_t nbDigitsMin, nbDigitsMax; - size_t rankRev=0, rankForw, rank=0, i; + size_t rankRev=0, rankForw, rank=0; + int i; int currMax; nbDigitsMin = strlen (min); @@ -385,7 +386,7 @@ static bool substr (char *substring, size_t buflen, const char* expr, size_t pos static char* reverse (char *string) { char *locBuf ; - size_t i; + int i; size_t len = strlen (string); locBuf = malloc (len+1); -- cgit v1.1