#include "postgres.h"
#include "executor/spi.h"
#include "commands/trigger.h"
-#include <ctype.h> /* tolower */
+#include <ctype.h>
#include <stdio.h> /* debugging */
/*
char *string = column;
while (*string != '\0')
- { /* placed 'really' inline. */
- *string = tolower(*string); /* some compilers will
- * choke */
- string++; /* on 'inline' keyword */
+ {
+ *string = tolower((unsigned char) *string);
+ string++;
}
data = (struct varlena *) palloc(sizeof(int32) + strlen(column) +1);
* (ie. 'string$%^&', last_start first points to '&', and after
* this to 'g'
*/
- if (!isalnum((int) *last_start))
+ if (!isalnum((unsigned char) *last_start))
{
- while (!isalnum((int) *last_start) &&
+ while (!isalnum((unsigned char) *last_start) &&
last_start > string)
last_start--;
cur_pos = last_start;
cur_pos--; /* substrings are at minimum 2 characters
* long */
- if (isalnum((int) *cur_pos))
+ if (isalnum((unsigned char) *cur_pos))
{
/* Houston, we have a substring! :) */
memcpy(substring, cur_pos, last_start - cur_pos + 1);
-/* $Header: /cvsroot/pgsql/contrib/soundex/Attic/soundex.c,v 1.8 2000/11/20 20:36:57 tgl Exp $ */
+/* $Header: /cvsroot/pgsql/contrib/soundex/Attic/soundex.c,v 1.9 2000/12/03 20:45:31 tgl Exp $ */
#include "postgres.h"
#include "fmgr.h"
#include "utils/builtins.h"
/* ABCDEFGHIJKLMNOPQRSTUVWXYZ */
static const char *soundex_table = "01230120022455012623010202";
-#define soundex_code(letter) soundex_table[toupper(letter) - 'A']
+#define soundex_code(letter) soundex_table[toupper((unsigned char) (letter)) - 'A']
static void
outstr[SOUNDEX_LEN] = '\0';
/* Skip leading non-alphabetic characters */
- while (!isalpha(instr[0]) && instr[0])
+ while (!isalpha((unsigned char) instr[0]) && instr[0])
++instr;
/* No string left */
}
/* Take the first letter as is */
- *outstr++ = (char) toupper(*instr++);
+ *outstr++ = (char) toupper((unsigned char) *instr++);
count = 1;
while (*instr && count < SOUNDEX_LEN)
{
- if (isalpha(*instr) && soundex_code(*instr) != soundex_code(*(instr - 1)))
+ if (isalpha((unsigned char) *instr) &&
+ soundex_code(*instr) != soundex_code(*(instr - 1)))
{
*outstr = soundex_code(instr[0]);
if (*outstr != '0')
int i;
for (i = 0; i < strlen(string); i++)
- string[i] = toupper(string[i]);
+ string[i] = toupper((unsigned char) string[i]);
return string;
}
#include "executor/spi.h" /* this is what you need to work with SPI */
#include "commands/trigger.h" /* -"- and triggers */
-#include <ctype.h> /* tolower () */
+#include <ctype.h>
extern Datum check_primary_key(PG_FUNCTION_ARGS);
nrefs = pg_atoi(args[0], sizeof(int), 0);
if (nrefs < 1)
elog(ERROR, "check_foreign_key: %d (< 1) number of references specified", nrefs);
- action = tolower(*(args[1]));
+ action = tolower((unsigned char) *(args[1]));
if (action != 'r' && action != 'c' && action != 's')
elog(ERROR, "check_foreign_key: invalid action %s", args[1]);
nargs -= 2;
#include "executor/spi.h" /* this is what you need to work with SPI */
#include "commands/trigger.h" /* -"- and triggers */
-#include <ctype.h> /* tolower () */
+#include <ctype.h>
#define ABSTIMEOID 702 /* it should be in pg_type.h */
NameGetDatum(relname)));
d = TTOff[nTTOff] = malloc(strlen(rname) + 1);
while (*s)
- *d++ = tolower(*s++);
+ *d++ = tolower((unsigned char) *s++);
*d = 0;
pfree(rname);
nTTOff++;
#define DIGIT(val) ((val) + '0')
#define ISOCTAL(c) (((c) >= '0') && ((c) <= '7'))
#ifndef ISO8859
-#define NOTPRINTABLE(c) (!isprint(c))
+#define NOTPRINTABLE(c) (!isprint((unsigned char) (c)))
#else
-#define NOTPRINTABLE(c) (!isprint(c) && ((c) < 0xa0))
+#define NOTPRINTABLE(c) (!isprint((unsigned char) (c)) && \
+ ((unsigned char) (c) < (unsigned char) 0xa0))
#endif
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/define.c,v 1.49 2000/11/20 20:36:47 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/define.c,v 1.50 2000/12/03 20:45:33 tgl Exp $
*
* DESCRIPTION
* The "DefineFoo" routines take the parse tree and pick out the
int i;
for (i = 0; i < NAMEDATALEN-1 && input[i]; ++i)
- output[i] = tolower(input[i]);
+ output[i] = tolower((unsigned char) input[i]);
output[i] = '\0';
int i;
for (i = 0; i < NAMEDATALEN && input[i]; ++i)
- output[i] = tolower(input[i]);
+ output[i] = tolower((unsigned char) input[i]);
output[i] = '\0';
*/
for (; *rawname; rawname++)
{
- if (isascii((int) *rawname) &&
- isupper((int) *rawname))
- *rawname = tolower(*rawname);
+ if (isupper((unsigned char) *rawname))
+ *rawname = tolower((unsigned char) *rawname);
}
}
return seqname;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/variable.c,v 1.43 2000/10/26 17:31:34 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/variable.c,v 1.44 2000/12/03 20:45:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
return NULL;
/* skip leading white space */
- while (isspace((int) *str))
+ while (isspace((unsigned char) *str))
str++;
/* end of string? then return NULL */
*tok = str;
/* Advance to end of word */
- while (*str && !isspace((int) *str) && *str != ',' && *str != '=')
+ while (*str && !isspace((unsigned char) *str) &&
+ *str != ',' && *str != '=')
str++;
/* Terminate word string for caller */
*str = '\0';
/* Skip any whitespace */
- while (isspace((int) ch))
+ while (isspace((unsigned char) ch))
ch = *(++str);
/* end of string? */
str++;
/* skip whitespace after '=' */
- while (isspace((int) *str))
+ while (isspace((unsigned char) *str))
str++;
if (*str == ',' || *str == '\0')
*val = str;
/* Advance to end of word */
- while (*str && !isspace((int) *str) && *str != ',')
+ while (*str && !isspace((unsigned char) *str) && *str != ',')
str++;
/* Terminate word string for caller */
*str = '\0';
/* Skip any whitespace */
- while (isspace((int) ch))
+ while (isspace((unsigned char) ch))
ch = *(++str);
/* end of string? */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/libpq/auth.c,v 1.49 2000/08/25 10:00:30 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/libpq/auth.c,v 1.50 2000/12/03 20:45:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include <netdb.h> /* for MAXHOSTNAMELEN on some */
#endif
#include <pwd.h>
-#include <ctype.h> /* isspace() declaration */
+#include <ctype.h>
#include <sys/types.h> /* needed by in.h on Ultrix */
#include <netinet/in.h>
* Portions Copyright (c) 1996-2000, PostgreSQL, Inc
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.134 2000/11/16 22:30:23 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.135 2000/12/03 20:45:33 tgl Exp $
*
* NOTES
* Every (plan) node in POSTGRES has an associated "out" routine which
if (*s == '<' ||
*s == '\"' ||
*s == '@' ||
- isdigit((int) *s) ||
- (*s == '-' && isdigit((int) s[1])))
+ isdigit((unsigned char) *s) ||
+ (*s == '-' && isdigit((unsigned char) s[1])))
appendStringInfoChar(str, '\\');
while (*s)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/read.c,v 1.25 2000/10/31 13:59:52 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/read.c,v 1.26 2000/12/03 20:45:33 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
numlen = length;
if (*numptr == '+' || *numptr == '-')
numptr++, numlen--;
- if ((numlen > 0 && isdigit((int) *numptr)) ||
- (numlen > 1 && *numptr == '.' && isdigit((int) numptr[1])))
+ if ((numlen > 0 && isdigit((unsigned char) *numptr)) ||
+ (numlen > 1 && *numptr == '.' && isdigit((unsigned char) numptr[1])))
{
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.49 2000/11/16 22:30:28 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.50 2000/12/03 20:45:34 tgl Exp $
*
*-------------------------------------------------------------------------
*/
ndigits = 0;
for (; *ptr; ptr++)
{
- if (isdigit((int) *ptr))
+ if (isdigit((unsigned char) *ptr))
ndigits++;
else if (*ptr == 'e' || *ptr == 'E')
break; /* don't count digits in exponent */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/scan.l,v 1.83 2000/11/16 22:47:44 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/scan.l,v 1.84 2000/12/03 20:45:34 tgl Exp $
*
*-------------------------------------------------------------------------
*/
ScanKeyword *keyword;
for(i = 0; yytext[i]; i++)
- if (isascii((int) yytext[i]) &&
- isupper((int) yytext[i]))
- yytext[i] = tolower(yytext[i]);
+ if (isupper((unsigned char) yytext[i]))
+ yytext[i] = tolower((unsigned char) yytext[i]);
if (i >= NAMEDATALEN)
{
#ifdef MULTIBYTE
-/* $Id: inet_aton.c,v 1.17 1999/07/17 04:12:09 momjian Exp $
+/* $Id: inet_aton.c,v 1.18 2000/12/03 20:45:34 tgl Exp $
*
* This inet_aton() function was taken from the GNU C library and
* incorporated into Postgres for those systems which do not have this
}
while ((c = *cp) != '\0')
{
- if (isascii(c) && isdigit(c))
+ if (isdigit((unsigned char) c))
{
val = (val * base) + (c - '0');
cp++;
continue;
}
- if (base == 16 && isascii(c) && isxdigit(c))
+ if (base == 16 && isxdigit((unsigned char) c))
{
val = (val << 4) +
- (c + 10 - (islower(c) ? 'a' : 'A'));
+ (c + 10 - (islower((unsigned char) c) ? 'a' : 'A'));
cp++;
continue;
}
}
/*
- * Check for trailing characters.
+ * Check for trailing junk.
*/
- if (*cp && (!isascii(*cp) || !isspace(*cp)))
- return 0;
+ while (*cp)
+ if (!isspace((unsigned char) *cp++))
+ return 0;
/*
* Concoct the address according to the number of parts specified.
* causing nast effects.
**************************************************************/
-/*static char _id[] = "$Id: snprintf.c,v 1.27 1999/09/09 03:13:22 tgl Exp $";*/
+/*static char _id[] = "$Id: snprintf.c,v 1.28 2000/12/03 20:45:34 tgl Exp $";*/
static char *end;
static int SnprfOverflow;
dopr_outch(int c)
{
#ifdef NOT_USED
- if (iscntrl(c) && c != '\n' && c != '\t')
+ if (iscntrl((unsigned char) c) && c != '\n' && c != '\t')
{
c = '@' + (c & 0x1F);
if (end == 0 || output < end)
{
const char *s = nptr;
unsigned long acc;
- int c;
+ unsigned char c;
unsigned long cutoff;
int neg = 0,
any,
cutoff = neg ? -(unsigned long) LONG_MIN : LONG_MAX;
cutlim = cutoff % (unsigned long) base;
cutoff /= (unsigned long) base;
- for (acc = 0, any = 0;; c = *s++)
+ for (acc = 0, any = 0; ; c = *s++)
{
if (isdigit(c))
c -= '0';
c -= isupper(c) ? 'A' - 10 : 'a' - 10;
else
break;
- if (c >= base)
+ if ((int) c >= base)
break;
- if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
+ if (any < 0 || acc > cutoff || acc == cutoff && (int) c > cutlim)
any = -1;
else
{
c -= isupper(c) ? 'A' - 10 : 'a' - 10;
else
break;
- if (c >= base)
+ if ((int) c >= base)
break;
- if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
+ if (any < 0 || acc > cutoff || (acc == cutoff && (int) c > cutlim))
any = -1;
else
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.197 2000/11/30 23:20:51 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.198 2000/12/03 20:45:34 tgl Exp $
*
* NOTES
*
{
while (s && *s)
{
- while (isspace((int) *s))
+ while (isspace((unsigned char) *s))
++s;
if (*s == '\0')
break;
argv[(*argcp)++] = s;
- while (*s && !isspace((int) *s))
+ while (*s && !isspace((unsigned char) *s))
++s;
if (*s)
*s++ = '\0';
pg_isprint(int c)
{
#ifdef MULTIBYTE
- return (c >= 0 && c <= UCHAR_MAX && isprint(c));
+ return (c >= 0 && c <= UCHAR_MAX && isprint((unsigned char) c));
#else
- return (isprint(c));
+ return (isprint((unsigned char) c));
#endif
}
assert(pg_isalpha(ch));
if (pg_isupper(ch))
#ifdef MULTIBYTE
- return (unsigned char) tolower(ch);
+ return (unsigned char) tolower((unsigned char) ch);
#else
- return tolower(ch);
+ return tolower((unsigned char) ch);
#endif
else if (pg_islower(ch))
#ifdef MULTIBYTE
- return (unsigned char) toupper(ch);
+ return (unsigned char) toupper((unsigned char) ch);
#else
- return toupper(ch);
+ return toupper((unsigned char) ch);
#endif
else
/* peculiar, but could happen */
pg_isdigit(int c)
{
#ifdef MULTIBYTE
- return (c >= 0 && c <= UCHAR_MAX && isdigit(c));
+ return (c >= 0 && c <= UCHAR_MAX && isdigit((unsigned char) c));
#else
- return (isdigit(c));
+ return (isdigit((unsigned char) c));
#endif
}
pg_isalpha(int c)
{
#ifdef MULTIBYTE
- return (c >= 0 && c <= UCHAR_MAX && isalpha(c));
+ return (c >= 0 && c <= UCHAR_MAX && isalpha((unsigned char) c));
#else
- return (isalpha(c));
+ return (isalpha((unsigned char) c));
#endif
}
pg_isupper(int c)
{
#ifdef MULTIBYTE
- return (c >= 0 && c <= UCHAR_MAX && isupper(c));
+ return (c >= 0 && c <= UCHAR_MAX && isupper((unsigned char) c));
#else
- return (isupper(c));
+ return (isupper((unsigned char) c));
#endif
}
pg_islower(int c)
{
#ifdef MULTIBYTE
- return (c >= 0 && c <= UCHAR_MAX && islower(c));
+ return (c >= 0 && c <= UCHAR_MAX && islower((unsigned char) c));
#else
- return (islower(c));
+ return (islower((unsigned char) c));
#endif
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.54 2000/11/28 23:42:31 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.55 2000/12/03 20:45:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
Assert(s && n);
- while (isspace((int) *s))
+ while (isspace((unsigned char) *s))
++s;
if (*s == '"')
s++;
}
- for (id = s, len = 0; isalnum((int) *s) || *s == '_' || in_quotes; ++len, ++s)
+ for (id = s, len = 0;
+ isalnum((unsigned char) *s) || *s == '_' || in_quotes;
+ ++len, ++s)
{
if (in_quotes && *s == '"')
{
if (len > 0)
memmove(n, id, len);
n[len] = '\0';
- while (isspace((int) *s))
+ while (isspace((unsigned char) *s))
++s;
return s;
}
}
aip->ai_mode = ACL_NO;
- while (isalpha((int) *++s))
+ while (isalpha((unsigned char) *++s))
{
switch (*s)
{
s = aclparse(s, aip, &modechg);
if (modechg != ACL_MODECHG_EQL)
elog(ERROR, "aclitemin: cannot accept anything but = ACLs");
- while (isspace((int) *s))
+ while (isspace((unsigned char) *s))
++s;
if (*s)
elog(ERROR, "aclitemin: extra garbage at end of specification");
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.66 2000/11/16 22:30:31 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.67 2000/12/03 20:45:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* Note: we currently allow whitespace between, but not within,
* dimension items.
*/
- while (isspace((int) *p))
+ while (isspace((unsigned char) *p))
p++;
if (*p != '[')
break; /* no more dimension items */
p++;
if (ndim >= MAXDIM)
elog(ERROR, "array_in: more than %d dimensions", MAXDIM);
- for (q = p; isdigit((int) *q); q++);
+ for (q = p; isdigit((unsigned char) *q); q++);
if (q == p) /* no digits? */
elog(ERROR, "array_in: missing dimension value");
if (*q == ':')
*q = '\0';
lBound[ndim] = atoi(p);
p = q + 1;
- for (q = p; isdigit((int) *q); q++);
+ for (q = p; isdigit((unsigned char) *q); q++);
if (q == p) /* no digits? */
elog(ERROR, "array_in: missing dimension value");
}
if (strncmp(p, ASSGN, strlen(ASSGN)) != 0)
elog(ERROR, "array_in: missing assignment operator");
p += strlen(ASSGN);
- while (isspace((int) *p))
+ while (isspace((unsigned char) *p))
p++;
}
temp[ndim - 1]++;
q++;
if (!eoArray)
- while (isspace((int) *q))
+ while (isspace((unsigned char) *q))
q++;
}
for (i = 0; i < ndim; ++i)
* if not at the end of the array skip white space
*/
if (!eoArray)
- while (isspace((int) *q))
+ while (isspace((unsigned char) *q))
{
p++;
q++;
* workings can be found in the book "Software Solutions in C" by
* Dale Schumacher, Academic Press, ISBN: 0-12-632360-7.
*
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/cash.c,v 1.48 2000/11/25 22:43:08 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/cash.c,v 1.49 2000/12/03 20:45:35 tgl Exp $
*/
#include "postgres.h"
/* we need to add all sorts of checking here. For now just */
/* strip all leading whitespace and any leading currency symbol */
- while (isspace((int) *s))
+ while (isspace((unsigned char) *s))
s++;
if (strncmp(s, csymbol, strlen(csymbol)) == 0)
s += strlen(csymbol);
printf("cashin- string is '%s'\n", s);
#endif
- while (isspace((int) *s))
+ while (isspace((unsigned char) *s))
s++;
if (strncmp(s, csymbol, strlen(csymbol)) == 0)
s += strlen(csymbol);
{
/* we look for digits as int4 as we have less */
/* than the required number of decimal places */
- if (isdigit((int) *s) && dec < fpoint)
+ if (isdigit((unsigned char) *s) && dec < fpoint)
{
value = (value * 10) + *s - '0';
else
{
/* round off */
- if (isdigit((int) *s) && *s >= '5')
+ if (isdigit((unsigned char) *s) && *s >= '5')
value++;
/* adjust for less than required decimal places */
}
}
- while (isspace((int) *s) || *s == '0' || *s == ')')
+ while (isspace((unsigned char) *s) || *s == '0' || *s == ')')
s++;
if (*s != '\0')
strcat(buf, m0 == 1 ? " cent" : " cents");
/* capitalize output */
- buf[0] = toupper(buf[0]);
+ buf[0] = toupper((unsigned char) buf[0]);
/* make a text type for output */
result = (text *) palloc(strlen(buf) + VARHDRSZ);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.56 2000/11/11 19:55:19 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.57 2000/12/03 20:45:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
field[nf] = lp;
/* leading digit? then date or time */
- if (isdigit((int) *cp) || (*cp == '.'))
+ if (isdigit((unsigned char) *cp) || (*cp == '.'))
{
*lp++ = *cp++;
- while (isdigit((int) *cp))
+ while (isdigit((unsigned char) *cp))
*lp++ = *cp++;
/* time field? */
if (*cp == ':')
{
ftype[nf] = DTK_TIME;
- while (isdigit((int) *cp) || (*cp == ':') || (*cp == '.'))
+ while (isdigit((unsigned char) *cp) ||
+ (*cp == ':') || (*cp == '.'))
*lp++ = *cp++;
}
else if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
{
ftype[nf] = DTK_DATE;
- while (isalnum((int) *cp) || (*cp == '-') || (*cp == '/') || (*cp == '.'))
- *lp++ = tolower(*cp++);
+ while (isalnum((unsigned char) *cp) || (*cp == '-') ||
+ (*cp == '/') || (*cp == '.'))
+ *lp++ = tolower((unsigned char) *cp++);
}
* text? then date string, month, day of week, special, or
* timezone
*/
- else if (isalpha((int) *cp))
+ else if (isalpha((unsigned char) *cp))
{
ftype[nf] = DTK_STRING;
- *lp++ = tolower(*cp++);
- while (isalpha((int) *cp))
- *lp++ = tolower(*cp++);
+ *lp++ = tolower((unsigned char) *cp++);
+ while (isalpha((unsigned char) *cp))
+ *lp++ = tolower((unsigned char) *cp++);
/*
* Full date string with leading text month? Could also be a
if ((*cp == '-') || (*cp == '/') || (*cp == '.'))
{
ftype[nf] = DTK_DATE;
- while (isdigit((int) *cp) || (*cp == '-') || (*cp == '/') || (*cp == '.'))
- *lp++ = tolower(*cp++);
+ while (isdigit((unsigned char) *cp) ||
+ (*cp == '-') || (*cp == '/') || (*cp == '.'))
+ *lp++ = tolower((unsigned char) *cp++);
}
/* skip leading spaces */
}
- else if (isspace((int) *cp))
+ else if (isspace((unsigned char) *cp))
{
cp++;
continue;
{
*lp++ = *cp++;
/* soak up leading whitespace */
- while (isspace((int) *cp))
+ while (isspace((unsigned char) *cp))
cp++;
/* numeric timezone? */
- if (isdigit((int) *cp))
+ if (isdigit((unsigned char) *cp))
{
ftype[nf] = DTK_TZ;
*lp++ = *cp++;
- while (isdigit((int) *cp) || (*cp == ':') || (*cp == '.'))
+ while (isdigit((unsigned char) *cp) ||
+ (*cp == ':') || (*cp == '.'))
*lp++ = *cp++;
/* special? */
}
- else if (isalpha((int) *cp))
+ else if (isalpha((unsigned char) *cp))
{
ftype[nf] = DTK_SPECIAL;
- *lp++ = tolower(*cp++);
- while (isalpha((int) *cp))
- *lp++ = tolower(*cp++);
+ *lp++ = tolower((unsigned char) *cp++);
+ while (isalpha((unsigned char) *cp))
+ *lp++ = tolower((unsigned char) *cp++);
/* otherwise something wrong... */
}
/* ignore punctuation but use as delimiter */
}
- else if (ispunct((int) *cp))
+ else if (ispunct((unsigned char) *cp))
{
cp++;
continue;
* PST)
*/
if ((i > 0) && ((fmask & DTK_M(TZ)) != 0)
- && (ftype[i - 1] == DTK_TZ) && (isalpha((int) *field[i - 1])))
+ && (ftype[i - 1] == DTK_TZ) && (isalpha((unsigned char) *field[i - 1])))
{
*tzp -= tz;
tmask = 0;
* PST)
*/
if ((i > 0) && ((fmask & DTK_M(TZ)) != 0)
- && (ftype[i - 1] == DTK_TZ) && (isalpha((int) *field[i - 1])))
+ && (ftype[i - 1] == DTK_TZ) && (isalpha((unsigned char) *field[i - 1])))
{
*tzp -= tz;
tmask = 0;
while ((*str != '\0') && (nf < MAXDATEFIELDS))
{
/* skip field separators */
- while (!isalnum((int) *str))
+ while (!isalnum((unsigned char) *str))
str++;
field[nf] = str;
- if (isdigit((int) *str))
+ if (isdigit((unsigned char) *str))
{
- while (isdigit((int) *str))
+ while (isdigit((unsigned char) *str))
str++;
}
- else if (isalpha((int) *str))
+ else if (isalpha((unsigned char) *str))
{
- while (isalpha((int) *str))
+ while (isalpha((unsigned char) *str))
str++;
}
/* look first for text fields, since that will be unambiguous month */
for (i = 0; i < nf; i++)
{
- if (isalpha((int) *field[i]))
+ if (isalpha((unsigned char) *field[i]))
{
type = DecodeSpecial(i, field[i], &val);
if (type == IGNORE)
char delim;
cp = str;
- while ((*cp != '\0') && isalpha((int) *cp))
+ while ((*cp != '\0') && isalpha((unsigned char) *cp))
cp++;
if (DecodeTimezone(cp, &tz) != 0)
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/format_type.c,v 1.6 2000/11/16 22:30:31 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/format_type.c,v 1.7 2000/12/03 20:45:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
default:
name = NameStr(((Form_pg_type) GETSTRUCT(tuple))->typname);
if (strspn(name, "abcdefghijklmnopqrstuvwxyz0123456789_") != strlen(name)
- || isdigit((int) name[0]))
+ || isdigit((unsigned char) name[0]))
buf = psnprintf(strlen(name) + 3, "\"%s\"", name);
else
buf = pstrdup(name);
/* -----------------------------------------------------------------------
* formatting.c
*
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/formatting.c,v 1.25 2000/12/01 05:17:19 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/formatting.c,v 1.26 2000/12/03 20:45:35 tgl Exp $
*
*
* Portions Copyright (c) 1999-2000, PostgreSQL, Inc
int len, /* keyword length */
(*action) (),
id; /* keyword id */
- bool isdigit; /* is expected output/input digit */
+ bool isitdigit; /* is expected output/input digit */
} KeyWord;
typedef struct
* ----------
*/
static KeyWord DCH_keywords[] = {
-/* keyword, len, func, type, isdigit is in Index */
+/* keyword, len, func, type, isitdigit is in Index */
{"A.D.", 4, dch_date, DCH_A_D, FALSE}, /* A */
{"A.M.", 4, dch_time, DCH_A_M, FALSE},
{"AD", 2, dch_date, DCH_AD, FALSE},
{NULL, 0, NULL, 0}};
/* ----------
- * KeyWords for NUMBER version (now, isdigit info is not needful here..)
+ * KeyWords for NUMBER version (now, isitdigit info is not needful here..)
* ----------
*/
static KeyWord NUM_keywords[] = {
* Skip blank space in FROM_CHAR's input
* ----------
*/
- if (isspace(n->character) && IS_FX == 0)
+ if (isspace((unsigned char) n->character) && IS_FX == 0)
{
- while (*s != '\0' && isspace((int) *(s + 1)))
+ while (*s != '\0' && isspace((unsigned char) *(s + 1)))
++s;
}
}
if (n->type == NODE_TYPE_ACTION)
{
- if (n->key->isdigit)
+ if (n->key->isitdigit)
return FALSE;
return TRUE;
}
- else if (isdigit(n->character))
+ else if (isdigit((unsigned char) n->character))
return FALSE;
return TRUE; /* some non-digit input (separator) */
case DCH_month:
sprintf(inout, "%*s", S_FM(suf) ? 0 : -9, months_full[tm->tm_mon - 1]);
- *inout = tolower(*inout);
+ *inout = tolower((unsigned char) *inout);
if (S_FM(suf))
return strlen(p_inout) - 1;
else
case DCH_mon:
strcpy(inout, months[tm->tm_mon - 1]);
- *inout = tolower(*inout);
+ *inout = tolower((unsigned char) *inout);
return 2;
case DCH_MM:
case DCH_day:
sprintf(inout, "%*s", S_FM(suf) ? 0 : -9, days[tm->tm_wday]);
- *inout = tolower(*inout);
+ *inout = tolower((unsigned char) *inout);
if (S_FM(suf))
return strlen(p_inout) - 1;
else
case DCH_dy:
strcpy(inout, days[tm->tm_wday]);
- *inout = tolower(*inout);
+ *inout = tolower((unsigned char) *inout);
return 2;
case DCH_DDD:
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.54 2000/07/30 20:43:41 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.55 2000/12/03 20:45:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
if (!PointerIsValid(str))
return FALSE;
- while (isspace((int) *str))
+ while (isspace((unsigned char) *str))
str++;
*x = strtod(str, &cp);
#ifdef GEODEBUG
#endif
if (cp <= str)
return FALSE;
- while (isspace((int) *cp))
+ while (isspace((unsigned char) *cp))
cp++;
if (s != NULL)
if (!PointerIsValid(str))
return FALSE;
- while (isspace((int) *str))
+ while (isspace((unsigned char) *str))
str++;
if ((has_delim = (*str == LDELIM)))
str++;
- while (isspace((int) *str))
+ while (isspace((unsigned char) *str))
str++;
*x = strtod(str, &cp);
if (cp <= str)
return FALSE;
- while (isspace((int) *cp))
+ while (isspace((unsigned char) *cp))
cp++;
if (*cp++ != DELIM)
return FALSE;
- while (isspace((int) *cp))
+ while (isspace((unsigned char) *cp))
cp++;
*y = strtod(cp, &str);
if (str <= cp)
return FALSE;
- while (isspace((int) *str))
+ while (isspace((unsigned char) *str))
str++;
if (has_delim)
{
if (*str != RDELIM)
return FALSE;
str++;
- while (isspace((int) *str))
+ while (isspace((unsigned char) *str))
str++;
}
if (s != NULL)
int i;
s = str;
- while (isspace((int) *s))
+ while (isspace((unsigned char) *s))
s++;
if ((*isopen = (*s == LDELIM_EP)))
{
return FALSE;
depth++;
s++;
- while (isspace((int) *s))
+ while (isspace((unsigned char) *s))
s++;
}
else if (*s == LDELIM)
{
cp = (s + 1);
- while (isspace((int) *cp))
+ while (isspace((unsigned char) *cp))
cp++;
if (*cp == LDELIM)
{
{
depth--;
s++;
- while (isspace((int) *s))
+ while (isspace((unsigned char) *s))
s++;
}
else
elog(ERROR, "Bad path external representation '%s'", str);
s = str;
- while (isspace((int) *s))
+ while (isspace((unsigned char) *s))
s++;
/* skip single leading paren */
circle = (CIRCLE *) palloc(sizeof(CIRCLE));
s = str;
- while (isspace((int) *s))
+ while (isspace((unsigned char) *s))
s++;
if ((*s == LDELIM_C) || (*s == LDELIM))
{
depth++;
cp = (s + 1);
- while (isspace((int) *cp))
+ while (isspace((unsigned char) *cp))
cp++;
if (*cp == LDELIM)
s = cp;
if (*s == DELIM)
s++;
- while (isspace((int) *s))
+ while (isspace((unsigned char) *s))
s++;
if ((!single_decode(s, &circle->radius, &s)) || (circle->radius < 0))
{
depth--;
s++;
- while (isspace((int) *s))
+ while (isspace((unsigned char) *s))
s++;
}
else
*/
#if defined(LIBC_SCCS) && !defined(lint)
-static const char rcsid[] = "$Id: inet_net_pton.c,v 1.11 2000/06/14 18:17:44 petere Exp $";
+static const char rcsid[] = "$Id: inet_net_pton.c,v 1.12 2000/12/03 20:45:36 tgl Exp $";
#endif
ch = *src++;
if (ch == '0' && (src[0] == 'x' || src[0] == 'X')
- && isascii((int) src[1]) && isxdigit((int) src[1]))
+ && isxdigit((unsigned char) src[1]))
{
/* Hexadecimal: Eat nybble string. */
if (size <= 0)
dirty = 0;
tmp = 0;
src++; /* skip x or X. */
- while ((ch = *src++) != '\0' && isascii(ch) && isxdigit(ch))
+ while ((ch = *src++) != '\0' && isxdigit((unsigned char) ch))
{
- if (isupper(ch))
- ch = tolower(ch);
+ if (isupper((unsigned char) ch))
+ ch = tolower((unsigned char) ch);
n = strchr(xdigits, ch) - xdigits;
assert(n >= 0 && n <= 15);
if (dirty == 0)
*dst++ = (u_char) (tmp << 4);
}
}
- else if (isascii(ch) && isdigit(ch))
+ else if (isdigit((unsigned char) ch))
{
/* Decimal: eat dotted digit string. */
for (;;)
if (tmp > 255)
goto enoent;
} while ((ch = *src++) != '\0' &&
- isascii(ch) && isdigit(ch));
+ isdigit((unsigned char) ch));
if (size-- <= 0)
goto emsgsize;
*dst++ = (u_char) tmp;
if (ch != '.')
goto enoent;
ch = *src++;
- if (!isascii(ch) || !isdigit(ch))
+ if (!isdigit((unsigned char) ch))
goto enoent;
}
}
goto enoent;
bits = -1;
- if (ch == '/' && isascii((int) src[0]) && isdigit((int) src[0]) && dst > odst)
+ if (ch == '/' && isdigit((unsigned char) src[0]) && dst > odst)
{
/* CIDR width specifier. Nothing can follow it. */
ch = *src++; /* Skip over the /. */
assert(n >= 0 && n <= 9);
bits *= 10;
bits += n;
- } while ((ch = *src++) != '\0' &&
- isascii(ch) && isdigit(ch));
+ } while ((ch = *src++) != '\0' && isdigit((unsigned char) ch));
if (ch != '\0')
goto enoent;
if (bits > 32)
size_t size = 4;
/* Get the mantissa. */
- while (ch = *src++, (isascii(ch) && isdigit(ch)))
+ while (ch = *src++, isdigit((unsigned char) ch))
{
tmp = 0;
do
tmp += n;
if (tmp > 255)
goto enoent;
- } while ((ch = *src++) != '\0' && isascii(ch) && isdigit(ch));
+ } while ((ch = *src++) != '\0' && isdigit((unsigned char) ch));
if (size-- == 0)
goto emsgsize;
*dst++ = (u_char) tmp;
/* Get the prefix length if any. */
bits = -1;
- if (ch == '/' && isascii((int) src[0]) && isdigit((int) src[0]) && dst > odst)
+ if (ch == '/' && isdigit((unsigned char) src[0]) && dst > odst)
{
/* CIDR width specifier. Nothing can follow it. */
ch = *src++; /* Skip over the /. */
assert(n >= 0 && n <= 9);
bits *= 10;
bits += n;
- } while ((ch = *src++) != '\0' && isascii(ch) && isdigit(ch));
+ } while ((ch = *src++) != '\0' && isdigit((unsigned char) ch));
if (ch != '\0')
goto enoent;
if (bits > 32)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.43 2000/10/24 20:14:35 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.44 2000/12/03 20:45:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
if (sscanf(intString, "%hd", &result[slot]) != 1)
break;
- while (*intString && isspace((int) *intString))
+ while (*intString && isspace((unsigned char) *intString))
intString++;
- while (*intString && !isspace((int) *intString))
+ while (*intString && !isspace((unsigned char) *intString))
intString++;
}
- while (*intString && isspace((int) *intString))
+ while (*intString && isspace((unsigned char) *intString))
intString++;
if (*intString)
elog(ERROR, "int2vector value has too many values");
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/int8.c,v 1.25 2000/10/24 20:14:35 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/int8.c,v 1.26 2000/12/03 20:45:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* Do our own scan, rather than relying on sscanf which might be
* broken for long long.
*/
- while (*ptr && isspace((int) *ptr)) /* skip leading spaces */
+ while (*ptr && isspace((unsigned char) *ptr)) /* skip leading spaces */
ptr++;
if (*ptr == '-') /* handle sign */
sign = -1, ptr++;
else if (*ptr == '+')
ptr++;
- if (!isdigit((int) *ptr)) /* require at least one digit */
+ if (!isdigit((unsigned char) *ptr)) /* require at least one digit */
elog(ERROR, "Bad int8 external representation \"%s\"", str);
- while (*ptr && isdigit((int) *ptr)) /* process digits */
+ while (*ptr && isdigit((unsigned char) *ptr)) /* process digits */
{
int64 newtmp = tmp * 10 + (*ptr++ - '0');
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/nabstime.c,v 1.75 2000/10/29 13:17:34 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/nabstime.c,v 1.76 2000/12/03 20:45:36 tgl Exp $
*
* NOTES
*
for (;;)
{
c = *p;
- if (isdigit(c))
+ if (isdigit((unsigned char) c))
{
*quantity = *quantity * 10 + (c - '0');
p++;
*
* 1998 Jan Wieck
*
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/numeric.c,v 1.34 2000/08/01 18:29:35 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/numeric.c,v 1.35 2000/12/03 20:45:36 tgl Exp $
*
* ----------
*/
while (*cp)
{
- if (!isspace((int) *cp))
+ if (!isspace((unsigned char) *cp))
break;
cp++;
}
cp++;
}
- if (!isdigit((int) *cp))
+ if (!isdigit((unsigned char) *cp))
elog(ERROR, "Bad numeric input format '%s'", str);
while (*cp)
{
- if (isdigit((int) *cp))
+ if (isdigit((unsigned char) *cp))
{
dest->digits[i++] = *cp++ - '0';
if (!have_dp)
/* Should be nothing left but spaces */
while (*cp)
{
- if (!isspace((int) *cp))
+ if (!isspace((unsigned char) *cp))
elog(ERROR, "Bad numeric input format '%s'", str);
cp++;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/oid.c,v 1.40 2000/11/21 04:27:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/oid.c,v 1.41 2000/12/03 20:45:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
if (sscanf(oidString, "%u", &result[slot]) != 1)
break;
- while (*oidString && isspace((int) *oidString))
+ while (*oidString && isspace((unsigned char) *oidString))
oidString++;
- while (*oidString && isdigit((int) *oidString))
+ while (*oidString && isdigit((unsigned char) *oidString))
oidString++;
}
- while (*oidString && isspace((int) *oidString))
+ while (*oidString && isspace((unsigned char) *oidString))
oidString++;
if (*oidString)
elog(ERROR, "oidvector value has too many values");
/*
* Edmund Mergl <E.Mergl@bawue.de>
*
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/oracle_compat.c,v 1.28 2000/09/25 12:58:47 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/oracle_compat.c,v 1.29 2000/12/03 20:45:36 tgl Exp $
*
*/
while (m-- > 0)
{
- if (isspace(ptr[-1]))
+ if (isspace((unsigned char) ptr[-1]))
*ptr = toupper((unsigned char) *ptr);
else
*ptr = tolower((unsigned char) *ptr);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.83 2000/11/25 20:33:53 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.84 2000/12/03 20:45:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* XXX I suspect isalpha() is not an adequately locale-sensitive
* test for characters that can vary under case folding?
*/
- if (case_insensitive && isalpha((int) patt[pos]))
+ if (case_insensitive && isalpha((unsigned char) patt[pos]))
break;
/*
* NOTE: this code used to think that %% meant a literal %, but
patt[pos] == '(' ||
patt[pos] == '[' ||
patt[pos] == '$' ||
- (case_insensitive && isalpha((int) patt[pos])))
+ (case_insensitive && isalpha((unsigned char) patt[pos])))
break;
/*
* Check for quantifiers. Except for +, this means the preceding
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/timestamp.c,v 1.38 2000/11/11 19:55:19 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/timestamp.c,v 1.39 2000/12/03 20:45:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
up = VARDATA(units);
lp = lowunits;
for (i = 0; i < (VARSIZE(units) - VARHDRSZ); i++)
- *lp++ = tolower(*up++);
+ *lp++ = tolower((unsigned char) *up++);
*lp = '\0';
type = DecodeUnits(0, lowunits, &val);
up = VARDATA(units);
lp = lowunits;
for (i = 0; i < (VARSIZE(units) - VARHDRSZ); i++)
- *lp++ = tolower(*up++);
+ *lp++ = tolower((unsigned char) *up++);
*lp = '\0';
type = DecodeUnits(0, lowunits, &val);
up = VARDATA(units);
lp = lowunits;
for (i = 0; i < (VARSIZE(units) - VARHDRSZ); i++)
- *lp++ = tolower(*up++);
+ *lp++ = tolower((unsigned char) *up++);
*lp = '\0';
type = DecodeUnits(0, lowunits, &val);
up = VARDATA(units);
lp = lowunits;
for (i = 0; i < (VARSIZE(units) - VARHDRSZ); i++)
- *lp++ = tolower(*up++);
+ *lp++ = tolower((unsigned char) *up++);
*lp = '\0';
type = DecodeUnits(0, lowunits, &val);
up = VARDATA(zone);
lp = lowzone;
for (i = 0; i < (VARSIZE(zone) - VARHDRSZ); i++)
- *lp++ = tolower(*up++);
+ *lp++ = tolower((unsigned char) *up++);
*lp = '\0';
type = DecodeSpecial(0, lowzone, &val);
up = upzone;
lp = lowzone;
for (i = 0; *lp != '\0'; i++)
- *up++ = toupper(*lp++);
+ *up++ = toupper((unsigned char) *lp++);
*up = '\0';
tzn = upzone;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.65 2000/07/29 03:26:42 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.66 2000/12/03 20:45:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
if (*tp == '\\')
tp++;
- else if (!isdigit((int) *tp++) ||
- !isdigit((int) *tp++) ||
- !isdigit((int) *tp++))
+ else if (!isdigit((unsigned char) *tp++) ||
+ !isdigit((unsigned char) *tp++) ||
+ !isdigit((unsigned char) *tp++))
elog(ERROR, "Bad input string for type bytea");
}
}
{
if (*vp == '\\')
len += 2;
- else if (isascii((int) *vp) && isprint((int) *vp))
+ else if (isprint((unsigned char) *vp))
len++;
else
len += 4;
*rp++ = '\\';
*rp++ = '\\';
}
- else if (isascii((int) *vp) && isprint((int) *vp))
+ else if (isprint((unsigned char) *vp))
*rp++ = *vp;
else
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.71 2000/12/03 10:27:28 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.72 2000/12/03 20:45:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
l = strlen(buf);
#endif
/* already word boundary? */
- if (isspace(line[l]) || line[l] == '\0')
+ if (isspace((unsigned char) line[l]) || line[l] == '\0')
buflen = l;
else
{
/* try to divide at word boundary */
i = l - 1;
- while (i > 0 && !isspace(buf[i]))
+ while (i > 0 && !isspace((unsigned char) buf[i]))
i--;
if (i <= 0) /* couldn't divide word boundary */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/pg_dump/common.c,v 1.47 2000/09/15 04:57:09 pjw Exp $
+ * $Header: /cvsroot/pgsql/src/bin/pg_dump/common.c,v 1.48 2000/12/03 20:45:37 tgl Exp $
*
* Modifications - 6/12/96 - dave@bensoft.com - version 1.13.dhb.2
*
}
else
{
- if (!(isdigit((int) s) || s == '-') || j >= sizeof(temp) - 1)
+ if (!(isdigit((unsigned char) s) || s == '-') ||
+ j >= sizeof(temp) - 1)
{
fprintf(stderr, "parseNumericArray: bogus number\n");
exit(2);
if (!force_quotes)
{
/* do a quick check on the first character... */
- if (!islower((int) *rawid))
+ if (!islower((unsigned char) *rawid))
force_quotes = true;
/* otherwise check the entire string */
else
for (cp = rawid; *cp; cp++)
{
- if (!(islower((int) *cp) || isdigit((int) *cp) || (*cp == '_')))
+ if (!(islower((unsigned char) *cp) ||
+ isdigit((unsigned char) *cp) ||
+ (*cp == '_')))
{
force_quotes = true;
break;
char *attr;
for(i=0 ; i < strlen(tablename) ; i++)
- tablename[i] = tolower(tablename[i]);
+ tablename[i] = tolower((unsigned char) tablename[i]);
if (strcmp(tablename, BLOB_XREF_TABLE) == 0)
return;
/* Get a copy of the COPY statement and clean it up */
tmpCopy = strdup(te->copyStmt);
for (i=0 ; i < strlen(tmpCopy) ; i++)
- tmpCopy[i] = tolower(tmpCopy[i]);
+ tmpCopy[i] = tolower((unsigned char) tmpCopy[i]);
/*
* This is very nasty; we don't know if the archive used WITH OIDS, so
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_dump.c,v 1.182 2000/11/27 20:51:40 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_dump.c,v 1.183 2000/12/03 20:45:37 tgl Exp $
*
* Modifications - 6/10/96 - dave@bensoft.com - version 1.13.dhb
*
else
{
for (i = 0; tablename[i]; i++)
- if (isascii((int) tablename[i]) &&
- isupper((int) tablename[i]))
- tablename[i] = tolower(tablename[i]);
+ if (isupper((unsigned char) tablename[i]))
+ tablename[i] = tolower((unsigned char) tablename[i]);
}
}
break;
{
int i;
- if (!name)
- return NULL;
-
- if (strlen(name) == 0)
- return NULL;
+ if (!name || ! name[0])
+ return NULL;
name = strdup(name);
if (name[0] == '"')
{
- strcpy(name, &name[1]);
- if (*(name + strlen(name) - 1) == '"')
- *(name + strlen(name) - 1) = '\0';
+ strcpy(name, &name[1]);
+ if (name[0] && *(name + strlen(name) - 1) == '"')
+ *(name + strlen(name) - 1) = '\0';
}
/* otherwise, convert table name to lowercase... */
else
{
- for (i = 0; name[i]; i++)
- if (isascii((unsigned char) name[i]) && isupper(name[i]))
- name[i] = tolower(name[i]);
+ for (i = 0; name[i]; i++)
+ if (isupper((unsigned char) name[i]))
+ name[i] = tolower((unsigned char) name[i]);
}
return name;
}
#include <errno.h>
#include <time.h>
#include <ctype.h>
-#define issaltchar(c) (isalnum(c) || (c) == '.' || (c) == '/')
+#define issaltchar(c) (isalnum((unsigned char) (c)) || (c) == '.' || (c) == '/')
#ifdef HAVE_TERMIOS_H
#include <termios.h>
*
* Copyright 2000 by PostgreSQL Global Development Group
*
- * $Header: /cvsroot/pgsql/src/bin/psql/command.c,v 1.41 2000/11/27 02:20:36 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/bin/psql/command.c,v 1.42 2000/12/03 20:45:38 tgl Exp $
*/
#include "postgres.h"
#include "command.h"
status = exec_command(new_cmd, my_line + 1, &continue_parse, query_buf);
#if 0 /* turned out to be too annoying */
- if (status != CMD_UNKNOWN && isalpha(new_cmd[0]))
+ if (status != CMD_UNKNOWN && isalpha((unsigned char) new_cmd[0]))
psql_error("Warning: this syntax is deprecated\n");
#endif
}
if (type == OT_SQLID)
for (cp = return_val; *cp; cp += PQmblen(cp, pset.encoding))
- if (isascii(*cp))
- *cp = tolower(*cp);
+ if (isupper((unsigned char) *cp))
+ *cp = tolower((unsigned char) *cp);
*string = &options_string[pos + token_end];
return return_val;
*
* Copyright 2000 by PostgreSQL Global Development Group
*
- * $Header: /cvsroot/pgsql/src/bin/psql/tab-complete.c,v 1.23 2000/12/03 14:36:47 petere Exp $
+ * $Header: /cvsroot/pgsql/src/bin/psql/tab-complete.c,v 1.24 2000/12/03 20:45:38 tgl Exp $
*/
/*----------------------------------------------------------------------
/* If we don't have this, we might as well forget about the whole thing: */
#ifdef USE_READLINE
-#include <ctype.h> /* toupper */
+#include <ctype.h>
#ifdef USE_ASSERT_CHECKING
#include <assert.h>
#endif
/* Complete "AS ON <sth with a 'T' :)>" with a "TO" */
else if (strcasecmp(prev3_wd, "AS") == 0 &&
strcasecmp(prev2_wd, "ON") == 0 &&
- (toupper(prev_wd[4]) == 'T' || toupper(prev_wd[5]) == 'T'))
+ (toupper((unsigned char) prev_wd[4]) == 'T' ||
+ toupper((unsigned char) prev_wd[5]) == 'T'))
COMPLETE_WITH_CONST("TO");
/* Complete "AS ON <sth> TO" with a table name */
else if (strcasecmp(prev4_wd, "AS") == 0 &&
#endif
#ifdef MULTIBYTE
-#define ISWORD(c) ((c >= 0 && c <= UCHAR_MAX) && \
- (isalnum(c) || (c) == '_'))
+#define ISWORD(c) (((c) >= 0 && (c) <= UCHAR_MAX) && \
+ (isalnum((unsigned char) (c)) || (c) == '_'))
#else
-#define ISWORD(c) (isalnum(c) || (c) == '_')
+#define ISWORD(c) (isalnum((unsigned char) (c)) || (c) == '_')
#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/ecpg/preproc/pgc.l,v 1.68 2000/11/20 03:51:33 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/ecpg/preproc/pgc.l,v 1.69 2000/12/03 20:45:38 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/* this should leave the last byte set to '\0' */
strncpy(lower_text, yytext, NAMEDATALEN-1);
for(i = 0; lower_text[i]; i++)
- if (isascii((int)lower_text[i]) && isupper((int) lower_text[i]))
- lower_text[i] = tolower(lower_text[i]);
+ if (isupper((unsigned char) lower_text[i]))
+ lower_text[i] = tolower((unsigned char) lower_text[i]);
if (i >= NAMEDATALEN)
{
/* skip the ";" and trailing whitespace. Note that yytext contains
at least one non-space character plus the ";" */
- for ( i = strlen(yytext)-2; i > 0 && isspace((int) yytext[i]); i-- ) {}
+ for ( i = strlen(yytext)-2;
+ i > 0 && isspace((unsigned char) yytext[i]);
+ i-- )
+ {}
yytext[i+1] = '\0';
for ( defptr = defines; defptr != NULL &&
/* skip the ";" and trailing whitespace. Note that yytext contains
at least one non-space character plus the ";" */
- for ( i = strlen(yytext)-2; i > 0 && isspace((int) yytext[i]); i-- ) {}
+ for ( i = strlen(yytext)-2;
+ i > 0 && isspace((unsigned char) yytext[i]);
+ i-- )
+ {}
yytext[i+1] = '\0';
yyin = NULL;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/libpgtcl/Attic/pgtclCmds.c,v 1.50 2000/11/27 13:29:32 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/libpgtcl/Attic/pgtclCmds.c,v 1.51 2000/12/03 20:45:39 tgl Exp $
*
*-------------------------------------------------------------------------
*/
char *reld = caserelname;
while (*rels)
- *reld++ = tolower(*rels++);
+ *reld++ = tolower((unsigned char) *rels++);
*reld = '\0';
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-connect.c,v 1.152 2000/11/30 23:20:51 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-connect.c,v 1.153 2000/12/03 20:45:39 tgl Exp $
*
*-------------------------------------------------------------------------
*/
line[strlen(line)-1] = 0;
/* ignore leading blanks */
- while(*line && isspace(line[0]))
- line++;
+ while(*line && isspace((unsigned char) line[0]))
+ line++;
/* ignore comments and empty lines */
if(strlen(line) == 0 || line[0] == '#')
- continue;
+ continue;
/* Check for right groupname */
- if(line[0] == '[') {
- if(group_found) {
- /* group info already read */
- fclose(f);
- return 0;
- }
+ if(line[0] == '[')
+ {
+ if(group_found) {
+ /* group info already read */
+ fclose(f);
+ return 0;
+ }
if(strncmp(line+1, service, strlen(service)) == 0 &&
line[strlen(service)+1] == ']')
while (*cp)
{
/* Skip blanks before the parameter name */
- if (isspace((int) *cp))
+ if (isspace((unsigned char) *cp))
{
cp++;
continue;
{
if (*cp == '=')
break;
- if (isspace((int) *cp))
+ if (isspace((unsigned char) *cp))
{
*cp++ = '\0';
while (*cp)
{
- if (!isspace((int) *cp))
+ if (!isspace((unsigned char) *cp))
break;
cp++;
}
/* Skip blanks after the '=' */
while (*cp)
{
- if (!isspace((int) *cp))
+ if (!isspace((unsigned char) *cp))
break;
cp++;
}
cp2 = pval;
while (*cp)
{
- if (isspace((int) *cp))
+ if (isspace((unsigned char) *cp))
{
*cp++ = '\0';
break;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-exec.c,v 1.96 2000/06/14 18:17:58 petere Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-exec.c,v 1.97 2000/12/03 20:45:39 tgl Exp $
*
*-------------------------------------------------------------------------
*/
}
else
for (i = 0; field_case[i]; i++)
- if (isascii((int) field_case[i]) &&
- isupper((int) field_case[i]))
- field_case[i] = tolower(field_case[i]);
+ if (isupper((unsigned char) field_case[i]))
+ field_case[i] = tolower((unsigned char) field_case[i]);
for (i = 0; i < res->numAttributes; i++)
{
nval++;
/* skip the current token */
- while ((*vp != '\0') && (! isspace(*vp))) vp++;
+ while ((*vp != '\0') && (! isspace((unsigned char) *vp))) vp++;
/* and skip the space to the next token */
- while ((*vp != '\0') && (isspace(*vp))) vp++;
+ while ((*vp != '\0') && (isspace((unsigned char) *vp))) vp++;
if (*vp == '\0')
break;
}
char key[33];
/* Separate off the key, skipping leading and trailing whitespace */
- while ((*value != '\0') && isspace(*value)) value++;
+ while ((*value != '\0') && isspace((unsigned char) *value)) value++;
sscanf(value, "%32s", key);
- while ((*value != '\0') && (! isspace(*value))) value++;
- while ((*value != '\0') && isspace(*value)) value++;
+ while ((*value != '\0') && (! isspace((unsigned char) *value))) value++;
+ while ((*value != '\0') && isspace((unsigned char) *value)) value++;
mylog("convert_escape: key='%s', val='%s'\n", key, value);
char *mapFunc;
while ((*funcEnd != '\0') && (*funcEnd != '(') &&
- (! isspace(*funcEnd))) funcEnd++;
+ (! isspace((unsigned char) *funcEnd)))
+ funcEnd++;
svchar = *funcEnd;
*funcEnd = '\0';
sscanf(value, "%32s", key);
*funcEnd = svchar;
- while ((*funcEnd != '\0') && isspace(*funcEnd)) funcEnd++;
+ while ((*funcEnd != '\0') && isspace((unsigned char) *funcEnd))
+ funcEnd++;
/* We expect left parenthesis here,
* else return fn body as-is since it is
void
encode(char *in, char *out)
{
-unsigned int i, o = 0;
+ unsigned int i, o = 0;
for (i = 0; i < strlen(in); i++) {
if ( in[i] == '+') {
sprintf(&out[o], "%%2B");
o += 3;
}
- else if ( isspace(in[i])) {
+ else if ( isspace((unsigned char) in[i])) {
out[o++] = '+';
}
- else if ( ! isalnum(in[i])) {
- sprintf(&out[o], "%%%02x", in[i]);
+ else if ( ! isalnum((unsigned char) in[i])) {
+ sprintf(&out[o], "%%%02x", (unsigned char) in[i]);
o += 3;
}
else
{
aStart = aLine + 1;
aString--;
- while (isspace(*aStart)) aStart++;
- while (isspace(*aString)) aString--;
+ while (isspace((unsigned char) *aStart)) aStart++;
+ while (isspace((unsigned char) *aString)) aString--;
*(aString+1) = '\0';
/* accept as matched if NULL key or exact match */
}
aStart = aLine;
- while(isspace(*aStart)) aStart++;
+ while (isspace((unsigned char) *aStart)) aStart++;
/* strip trailing blanks from key */
#include "iodbc.h"
#include "isql.h"
#include "isqlext.h"
-#include <ctype.h> /* for tolower function */
+#include <ctype.h>
#else
#include <windows.h>
#include <sql.h>
/* Handle action (i.e., 'cascade', 'restrict', 'setnull') */
- switch(tolower(ptr[0])) {
+ switch(tolower((unsigned char) ptr[0])) {
case 'c':
action = SQL_CASCADE;
break;
smax--;
/* skip leading delimiters */
- while (isspace(s[i]) || s[i] == ',') {
+ while (isspace((unsigned char) s[i]) || s[i] == ',') {
/* mylog("skipping '%c'\n", s[i]); */
i++;
}
if (numeric) *numeric = FALSE;
/* get the next token */
- while ( ! isspace(s[i]) && s[i] != ',' && s[i] != '\0' && out != smax) {
+ while ( ! isspace((unsigned char) s[i]) && s[i] != ',' &&
+ s[i] != '\0' && out != smax) {
/* Handle quoted stuff */
if ( out == 0 && (s[i] == '\"' || s[i] == '\'')) {
}
/* Check for numeric literals */
- if ( out == 0 && isdigit(s[i])) {
+ if ( out == 0 && isdigit((unsigned char) s[i])) {
if (numeric) *numeric = TRUE;
token[out++] = s[i++];
- while ( isalnum(s[i]) || s[i] == '.')
+ while ( isalnum((unsigned char) s[i]) || s[i] == '.')
token[out++] = s[i++];
break;
}
- if ( ispunct(s[i]) && s[i] != '_') {
+ if ( ispunct((unsigned char) s[i]) && s[i] != '_') {
mylog("got ispunct: s[%d] = '%c'\n", i, s[i]);
if (out == 0) {
token[out] = '\0';
/* find the delimiter */
- while ( isspace(s[i]))
+ while ( isspace((unsigned char) s[i]))
i++;
/* return the most priority delimiter */
}
/* skip trailing blanks */
- while ( isspace(s[i])) {
+ while ( isspace((unsigned char) s[i])) {
i++;
}
/*-------------------------------------------------------
*
- * $Id: Pg.xs,v 1.15 2000/10/24 17:00:00 tgl Exp $ with patch for NULs
+ * $Id: Pg.xs,v 1.16 2000/12/03 20:45:40 tgl Exp $ with patch for NULs
*
* Copyright (c) 1997, 1998 Edmund Mergl
*
}
} else {
while (*ptr && *ptr != ' ' && *ptr != '\t') {
- *ptr = tolower(*ptr);
+ *ptr = tolower((unsigned char) *ptr);
ptr++;
}
}
}
} else {
while (*ptr && *ptr != ' ' && *ptr != '\t') {
- *ptr = tolower(*ptr);
+ *ptr = tolower((unsigned char) *ptr);
ptr++;
}
}
* procedural language
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_funcs.c,v 1.8 2000/09/05 09:02:18 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_funcs.c,v 1.9 2000/12/03 20:45:40 tgl Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
}
else
{
- if (isupper((int) *s))
- *cp++ = tolower(*s++);
+ if (isupper((unsigned char) *s))
+ *cp++ = tolower((unsigned char) *s++);
else
*cp++ = *s++;
}
projects / thirdparty / postgresql.git / commitdiff
