diff --git a/src/backend/regex/regc_locale.c b/src/backend/regex/regc_locale.c
index 7cb3a40..3e2d3be 100644
--- a/src/backend/regex/regc_locale.c
+++ b/src/backend/regex/regc_locale.c
@@ -742,7 +742,7 @@ static int						/* 0 for equal, nonzero for unequal */
 cmp(const chr *x, const chr *y, /* strings to compare */
 	size_t len)					/* exact length of comparison */
 {
-	return memcmp(VS(x), VS(y), len * sizeof(chr));
+	return memcmp((const void *)x, (const void *)y, len * sizeof(chr));
 }
 
 /*
diff --git a/src/backend/regex/regcomp.c b/src/backend/regex/regcomp.c
index ed95474..90a134d 100644
--- a/src/backend/regex/regcomp.c
+++ b/src/backend/regex/regcomp.c
@@ -375,7 +375,7 @@ pg_regcomp(regex_t *re,
 	re->re_csize = sizeof(chr);
 	re->re_collation = collation;
 	re->re_guts = NULL;
-	re->re_fns = VS(&functions);
+	re->re_fns = &functions;
 
 	/* more complex setup, malloced things */
 	re->re_guts = VS(MALLOC(sizeof(struct guts)));
diff --git a/src/backend/regex/rege_dfa.c b/src/backend/regex/rege_dfa.c
index b98c9d3..46dd918 100644
--- a/src/backend/regex/rege_dfa.c
+++ b/src/backend/regex/rege_dfa.c
@@ -38,19 +38,19 @@
  * On success, returns match endpoint address.  Returns NULL on no match.
  * Internal errors also return NULL, with v->err set.
  */
-static chr *
+static const chr *
 longest(struct vars * v,
 		struct dfa * d,
-		chr *start,				/* where the match should start */
-		chr *stop,				/* match must end at or before here */
+		const chr *start,		/* where the match should start */
+		const chr *stop,		/* match must end at or before here */
 		int *hitstopp)			/* record whether hit v->stop, if non-NULL */
 {
-	chr		   *cp;
-	chr		   *realstop = (stop == v->stop) ? stop : stop + 1;
+	const chr  *cp;
+	const chr  *realstop = (stop == v->stop) ? stop : stop + 1;
 	color		co;
 	struct sset *css;
 	struct sset *ss;
-	chr		   *post;
+	const chr  *post;
 	int			i;
 	struct colormap *cm = d->cm;
 
@@ -164,18 +164,18 @@ longest(struct vars * v,
  * On success, returns match endpoint address.  Returns NULL on no match.
  * Internal errors also return NULL, with v->err set.
  */
-static chr *
+static const chr *
 shortest(struct vars * v,
 		 struct dfa * d,
-		 chr *start,			/* where the match should start */
-		 chr *min,				/* match must end at or after here */
-		 chr *max,				/* match must end at or before here */
-		 chr **coldp,			/* store coldstart pointer here, if non-NULL */
+		 const chr *start,		/* where the match should start */
+		 const chr *min,		/* match must end at or after here */
+		 const chr *max,		/* match must end at or before here */
+		 const chr **coldp,		/* store coldstart pointer here, if non-NULL */
 		 int *hitstopp)			/* record whether hit v->stop, if non-NULL */
 {
-	chr		   *cp;
-	chr		   *realmin = (min == v->stop) ? min : min + 1;
-	chr		   *realmax = (max == v->stop) ? max : max + 1;
+	const chr  *cp;
+	const chr  *realmin = (min == v->stop) ? min : min + 1;
+	const chr  *realmax = (max == v->stop) ? max : max + 1;
 	color		co;
 	struct sset *css;
 	struct sset *ss;
@@ -302,11 +302,11 @@ shortest(struct vars * v,
 static int
 matchuntil(struct vars * v,
 		   struct dfa * d,
-		   chr *probe,			/* we want to know if a match ends here */
-		   struct sset ** lastcss,		/* state storage across calls */
-		   chr **lastcp)		/* state storage across calls */
+		   const chr *probe,		/* we want to know if a match ends here */
+		   struct sset ** lastcss,	/* state storage across calls */
+		   const chr **lastcp)		/* state storage across calls */
 {
-	chr		   *cp = *lastcp;
+	const chr  *cp = *lastcp;
 	color		co;
 	struct sset *css = *lastcss;
 	struct sset *ss;
@@ -413,12 +413,12 @@ matchuntil(struct vars * v,
 /*
  * lastcold - determine last point at which no progress had been made
  */
-static chr *					/* endpoint, or NULL */
+static const chr *					/* endpoint, or NULL */
 lastcold(struct vars * v,
 		 struct dfa * d)
 {
 	struct sset *ss;
-	chr		   *nopr;
+	const chr   *nopr;
 	int			i;
 
 	nopr = d->lastnopr;
@@ -556,7 +556,7 @@ hash(unsigned *uv,
 static struct sset *
 initialize(struct vars * v,
 		   struct dfa * d,
-		   chr *start)
+		   const chr *start)
 {
 	struct sset *ss;
 	int			i;
@@ -604,8 +604,8 @@ miss(struct vars * v,
 	 struct dfa * d,
 	 struct sset * css,
 	 color co,
-	 chr *cp,					/* next chr */
-	 chr *start)				/* where the attempt got started */
+	 const chr *cp,					/* next chr */
+	 const chr *start)				/* where the attempt got started */
 {
 	struct cnfa *cnfa = d->cnfa;
 	int			i;
@@ -742,13 +742,13 @@ miss(struct vars * v,
 static int						/* predicate:  constraint satisfied? */
 lacon(struct vars * v,
 	  struct cnfa * pcnfa,		/* parent cnfa */
-	  chr *cp,
+	  const chr *cp,
 	  color co)					/* "color" of the lookaround constraint */
 {
 	int			n;
 	struct subre *sub;
 	struct dfa *d;
-	chr		   *end;
+	const chr  *end;
 	int			satisfied;
 
 	/* Since this is recursive, it could be driven to stack overflow */
@@ -769,7 +769,7 @@ lacon(struct vars * v,
 	{
 		/* used to use longest() here, but shortest() could be much cheaper */
 		end = shortest(v, d, cp, cp, v->stop,
-					   (chr **) NULL, (int *) NULL);
+					   (const chr **) NULL, (int *) NULL);
 		satisfied = LATYPE_IS_POS(sub->subno) ? (end != NULL) : (end == NULL);
 	}
 	else
@@ -799,8 +799,8 @@ lacon(struct vars * v,
 static struct sset *
 getvacant(struct vars * v,
 		  struct dfa * d,
-		  chr *cp,
-		  chr *start)
+		  const chr *cp,
+		  const chr *start)
 {
 	int			i;
 	struct sset *ss;
@@ -870,13 +870,13 @@ getvacant(struct vars * v,
 static struct sset *
 pickss(struct vars * v,
 	   struct dfa * d,
-	   chr *cp,
-	   chr *start)
+	   const chr *cp,
+	   const chr *start)
 {
 	int			i;
 	struct sset *ss;
 	struct sset *end;
-	chr		   *ancient;
+	const chr   *ancient;
 
 	/* shortcut for cases where cache isn't full */
 	if (d->nssused < d->nssets)
diff --git a/src/backend/regex/regexec.c b/src/backend/regex/regexec.c
index 5cbfd9b..700be35 100644
--- a/src/backend/regex/regexec.c
+++ b/src/backend/regex/regexec.c
@@ -55,7 +55,7 @@ struct sset
 #define  LOCKED		 04			/* locked in cache */
 #define  NOPROGRESS  010		/* zero-progress state set */
 	struct arcp ins;			/* chain of inarcs pointing here */
-	chr		   *lastseen;		/* last entered on arrival here */
+	const chr   *lastseen;		/* last entered on arrival here */
 	struct sset **outs;			/* outarc vector indexed by color */
 	struct arcp *inchain;		/* chain-pointer vector for outarcs */
 };
@@ -74,8 +74,8 @@ struct dfa
 	struct arcp *incarea;		/* inchain storage */
 	struct cnfa *cnfa;
 	struct colormap *cm;
-	chr		   *lastpost;		/* location of last cache-flushed success */
-	chr		   *lastnopr;		/* location of last cache-flushed NOPROGRESS */
+	const chr   *lastpost;		/* location of last cache-flushed success */
+	const chr   *lastnopr;		/* location of last cache-flushed NOPROGRESS */
 	struct sset *search;		/* replacement-search-pointer memory */
 	int			cptsmalloced;	/* were the areas individually malloced? */
 	char	   *mallocarea;		/* self, or master malloced area, or NULL */
@@ -108,14 +108,14 @@ struct vars
 	size_t		nmatch;
 	regmatch_t *pmatch;
 	rm_detail_t *details;
-	chr		   *start;			/* start of string */
-	chr		   *search_start;	/* search start of string */
-	chr		   *stop;			/* just past end of string */
+	const chr   *start;			/* start of string */
+	const chr   *search_start;	/* search start of string */
+	const chr   *stop;			/* just past end of string */
 	int			err;			/* error code if any (0 none) */
 	struct dfa **subdfas;		/* per-tree-subre DFAs */
 	struct dfa **ladfas;		/* per-lacon-subre DFAs */
 	struct sset **lblastcss;	/* per-lacon-subre lookbehind restart data */
-	chr		  **lblastcp;		/* per-lacon-subre lookbehind restart data */
+	const chr  **lblastcp;		/* per-lacon-subre lookbehind restart data */
 	struct smalldfa dfa1;
 	struct smalldfa dfa2;
 };
@@ -138,31 +138,31 @@ static struct dfa *getsubdfa(struct vars *, struct subre *);
 static struct dfa *getladfa(struct vars *, int);
 static int	find(struct vars *, struct cnfa *, struct colormap *);
 static int	cfind(struct vars *, struct cnfa *, struct colormap *);
-static int	cfindloop(struct vars *, struct cnfa *, struct colormap *, struct dfa *, struct dfa *, chr **);
+static int	cfindloop(struct vars *, struct cnfa *, struct colormap *, struct dfa *, struct dfa *, const chr **);
 static void zapallsubs(regmatch_t *, size_t);
 static void zaptreesubs(struct vars *, struct subre *);
-static void subset(struct vars *, struct subre *, chr *, chr *);
-static int	cdissect(struct vars *, struct subre *, chr *, chr *);
-static int	ccondissect(struct vars *, struct subre *, chr *, chr *);
-static int	crevcondissect(struct vars *, struct subre *, chr *, chr *);
-static int	cbrdissect(struct vars *, struct subre *, chr *, chr *);
-static int	caltdissect(struct vars *, struct subre *, chr *, chr *);
-static int	citerdissect(struct vars *, struct subre *, chr *, chr *);
-static int	creviterdissect(struct vars *, struct subre *, chr *, chr *);
+static void subset(struct vars *, struct subre *, const chr *, const chr *);
+static int	cdissect(struct vars *, struct subre *, const chr *, const chr *);
+static int	ccondissect(struct vars *, struct subre *, const chr *, const chr *);
+static int	crevcondissect(struct vars *, struct subre *, const chr *, const chr *);
+static int	cbrdissect(struct vars *, struct subre *, const chr *, const chr *);
+static int	caltdissect(struct vars *, struct subre *, const chr *, const chr *);
+static int	citerdissect(struct vars *, struct subre *, const chr *, const chr *);
+static int	creviterdissect(struct vars *, struct subre *, const chr *, const chr *);
 
 /* === rege_dfa.c === */
-static chr *longest(struct vars *, struct dfa *, chr *, chr *, int *);
-static chr *shortest(struct vars *, struct dfa *, chr *, chr *, chr *, chr **, int *);
-static int	matchuntil(struct vars *, struct dfa *, chr *, struct sset **, chr **);
-static chr *lastcold(struct vars *, struct dfa *);
+static const chr *longest(struct vars *, struct dfa *, const chr *, const chr *, int *);
+static const chr *shortest(struct vars *, struct dfa *, const chr *, const chr *, const chr *, const chr **, int *);
+static int	matchuntil(struct vars *, struct dfa *, const chr *, struct sset **, const chr **);
+static const chr *lastcold(struct vars *, struct dfa *);
 static struct dfa *newdfa(struct vars *, struct cnfa *, struct colormap *, struct smalldfa *);
 static void freedfa(struct dfa *);
 static unsigned hash(unsigned *, int);
-static struct sset *initialize(struct vars *, struct dfa *, chr *);
-static struct sset *miss(struct vars *, struct dfa *, struct sset *, color, chr *, chr *);
-static int	lacon(struct vars *, struct cnfa *, chr *, color);
-static struct sset *getvacant(struct vars *, struct dfa *, chr *, chr *);
-static struct sset *pickss(struct vars *, struct dfa *, chr *, chr *);
+static struct sset *initialize(struct vars *, struct dfa *, const chr *);
+static struct sset *miss(struct vars *, struct dfa *, struct sset *, color, const chr *, const chr *);
+static int	lacon(struct vars *, struct cnfa *, const chr *, color);
+static struct sset *getvacant(struct vars *, struct dfa *, const chr *, const chr *);
+static struct sset *pickss(struct vars *, struct dfa *, const chr *, const chr *);
 
 
 /*
@@ -227,9 +227,9 @@ pg_regexec(regex_t *re,
 	else
 		v->pmatch = pmatch;
 	v->details = details;
-	v->start = (chr *) string;
-	v->search_start = (chr *) string + search_start;
-	v->stop = (chr *) string + len;
+	v->start = (const chr *) string;
+	v->search_start = (const chr *) string + search_start;
+	v->stop = (const chr *) string + len;
 	v->err = 0;
 	v->subdfas = NULL;
 	v->ladfas = NULL;
@@ -266,7 +266,7 @@ pg_regexec(regex_t *re,
 		for (i = 0; i < n; i++)
 			v->ladfas[i] = NULL;
 		v->lblastcss = (struct sset **) MALLOC(n * sizeof(struct sset *));
-		v->lblastcp = (chr **) MALLOC(n * sizeof(chr *));
+		v->lblastcp = (const chr **) MALLOC(n * sizeof(const chr *));
 		if (v->lblastcss == NULL || v->lblastcp == NULL)
 		{
 			st = REG_ESPACE;
@@ -378,11 +378,11 @@ find(struct vars * v,
 {
 	struct dfa *s;
 	struct dfa *d;
-	chr		   *begin;
-	chr		   *end = NULL;
-	chr		   *cold;
-	chr		   *open;			/* open and close of range of possible starts */
-	chr		   *close;
+	const chr  *begin;
+	const chr  *end = NULL;
+	const chr  *cold;
+	const chr  *open;			/* open and close of range of possible starts */
+	const chr  *close;
 	int			hitend;
 	int			shorter = (v->g->tree->flags & SHORTER) ? 1 : 0;
 
@@ -423,7 +423,7 @@ find(struct vars * v,
 		MDEBUG(("\nfind trying at %ld\n", LOFF(begin)));
 		if (shorter)
 			end = shortest(v, d, begin, begin, v->stop,
-						   (chr **) NULL, &hitend);
+						   (const chr **) NULL, &hitend);
 		else
 			end = longest(v, d, begin, v->stop, &hitend);
 		if (ISERR())
@@ -469,7 +469,7 @@ cfind(struct vars * v,
 {
 	struct dfa *s;
 	struct dfa *d;
-	chr		   *cold;
+	const chr  *cold;
 	int			ret;
 
 	s = newdfa(v, &v->g->search, cm, &v->dfa1);
@@ -508,15 +508,15 @@ cfindloop(struct vars * v,
 		  struct colormap * cm,
 		  struct dfa * d,
 		  struct dfa * s,
-		  chr **coldp)			/* where to put coldstart pointer */
+		  const chr **coldp)	/* where to put coldstart pointer */
 {
-	chr		   *begin;
-	chr		   *end;
-	chr		   *cold;
-	chr		   *open;			/* open and close of range of possible starts */
-	chr		   *close;
-	chr		   *estart;
-	chr		   *estop;
+	const chr  *begin;
+	const chr  *end;
+	const chr  *cold;
+	const chr  *open;			/* open and close of range of possible starts */
+	const chr  *close;
+	const chr  *estart;
+	const chr  *estop;
 	int			er;
 	int			shorter = v->g->tree->flags & SHORTER;
 	int			hitend;
@@ -551,7 +551,7 @@ cfindloop(struct vars * v,
 				/* Here we use the top node's detailed RE */
 				if (shorter)
 					end = shortest(v, d, begin, estart,
-								   estop, (chr **) NULL, &hitend);
+								   estop, (const chr **) NULL, &hitend);
 				else
 					end = longest(v, d, begin, estop,
 								  &hitend);
@@ -659,8 +659,8 @@ zaptreesubs(struct vars * v,
 static void
 subset(struct vars * v,
 	   struct subre * sub,
-	   chr *begin,
-	   chr *end)
+	   const chr *begin,
+	   const chr *end)
 {
 	int			n = sub->subno;
 
@@ -691,8 +691,8 @@ subset(struct vars * v,
 static int						/* regexec return code */
 cdissect(struct vars * v,
 		 struct subre * t,
-		 chr *begin,			/* beginning of relevant substring */
-		 chr *end)				/* end of same */
+		 const chr *begin,		/* beginning of relevant substring */
+		 const chr *end)		/* end of same */
 {
 	int			er;
 
@@ -762,12 +762,12 @@ cdissect(struct vars * v,
 static int						/* regexec return code */
 ccondissect(struct vars * v,
 			struct subre * t,
-			chr *begin,			/* beginning of relevant substring */
-			chr *end)			/* end of same */
+			const chr *begin,	/* beginning of relevant substring */
+			const chr *end)		/* end of same */
 {
 	struct dfa *d;
 	struct dfa *d2;
-	chr		   *mid;
+	const chr  *mid;
 	int			er;
 
 	assert(t->op == '.');
@@ -840,12 +840,12 @@ ccondissect(struct vars * v,
 static int						/* regexec return code */
 crevcondissect(struct vars * v,
 			   struct subre * t,
-			   chr *begin,		/* beginning of relevant substring */
-			   chr *end)		/* end of same */
+			   const chr *begin,	/* beginning of relevant substring */
+			   const chr *end)		/* end of same */
 {
 	struct dfa *d;
 	struct dfa *d2;
-	chr		   *mid;
+	const chr  *mid;
 	int			er;
 
 	assert(t->op == '.');
@@ -860,7 +860,7 @@ crevcondissect(struct vars * v,
 	MDEBUG(("crevcon %d\n", t->id));
 
 	/* pick a tentative midpoint */
-	mid = shortest(v, d, begin, begin, end, (chr **) NULL, (int *) NULL);
+	mid = shortest(v, d, begin, begin, end, (const chr **) NULL, (int *) NULL);
 	NOERR();
 	if (mid == NULL)
 		return REG_NOMATCH;
@@ -895,7 +895,7 @@ crevcondissect(struct vars * v,
 			MDEBUG(("%d no midpoint\n", t->id));
 			return REG_NOMATCH;
 		}
-		mid = shortest(v, d, begin, mid + 1, end, (chr **) NULL, (int *) NULL);
+		mid = shortest(v, d, begin, mid + 1, end, (const chr **) NULL, (int *) NULL);
 		NOERR();
 		if (mid == NULL)
 		{
@@ -918,15 +918,15 @@ crevcondissect(struct vars * v,
 static int						/* regexec return code */
 cbrdissect(struct vars * v,
 		   struct subre * t,
-		   chr *begin,			/* beginning of relevant substring */
-		   chr *end)			/* end of same */
+		   const chr *begin,	/* beginning of relevant substring */
+		   const chr *end)		/* end of same */
 {
 	int			n = t->subno;
 	size_t		numreps;
 	size_t		tlen;
 	size_t		brlen;
-	chr		   *brstring;
-	chr		   *p;
+	const chr  *brstring;
+	const chr  *p;
 	int			min = t->min;
 	int			max = t->max;
 
@@ -999,8 +999,8 @@ cbrdissect(struct vars * v,
 static int						/* regexec return code */
 caltdissect(struct vars * v,
 			struct subre * t,
-			chr *begin,			/* beginning of relevant substring */
-			chr *end)			/* end of same */
+			const chr *begin,	/* beginning of relevant substring */
+			const chr *end)		/* end of same */
 {
 	struct dfa *d;
 	int			er;
@@ -1036,12 +1036,12 @@ caltdissect(struct vars * v,
 static int						/* regexec return code */
 citerdissect(struct vars * v,
 			 struct subre * t,
-			 chr *begin,		/* beginning of relevant substring */
-			 chr *end)			/* end of same */
+			 const chr *begin,	/* beginning of relevant substring */
+			 const chr *end)	/* end of same */
 {
 	struct dfa *d;
-	chr		  **endpts;
-	chr		   *limit;
+	const chr  **endpts;
+	const chr  *limit;
 	int			min_matches;
 	size_t		max_matches;
 	int			nverified;
@@ -1081,7 +1081,7 @@ citerdissect(struct vars * v,
 		max_matches = t->max;
 	if (max_matches < min_matches)
 		max_matches = min_matches;
-	endpts = (chr **) MALLOC((max_matches + 1) * sizeof(chr *));
+	endpts = (const chr **) MALLOC((max_matches + 1) * sizeof(const chr *));
 	if (endpts == NULL)
 		return REG_ESPACE;
 	endpts[0] = begin;
@@ -1197,7 +1197,7 @@ backtrack:
 		 */
 		while (k > 0)
 		{
-			chr		   *prev_end = endpts[k - 1];
+			const chr	   *prev_end = endpts[k - 1];
 
 			if (endpts[k] > prev_end)
 			{
@@ -1237,12 +1237,12 @@ backtrack:
 static int						/* regexec return code */
 creviterdissect(struct vars * v,
 				struct subre * t,
-				chr *begin,		/* beginning of relevant substring */
-				chr *end)		/* end of same */
+				const chr *begin,	/* beginning of relevant substring */
+				const chr *end)		/* end of same */
 {
 	struct dfa *d;
-	chr		  **endpts;
-	chr		   *limit;
+	const chr  **endpts;
+	const chr  *limit;
 	int			min_matches;
 	size_t		max_matches;
 	int			nverified;
@@ -1282,7 +1282,7 @@ creviterdissect(struct vars * v,
 		max_matches = t->max;
 	if (max_matches < min_matches)
 		max_matches = min_matches;
-	endpts = (chr **) MALLOC((max_matches + 1) * sizeof(chr *));
+	endpts = (const chr **) MALLOC((max_matches + 1) * sizeof(const chr *));
 	if (endpts == NULL)
 		return REG_ESPACE;
 	endpts[0] = begin;
@@ -1325,7 +1325,7 @@ creviterdissect(struct vars * v,
 
 		/* try to find an endpoint for the k'th sub-match */
 		endpts[k] = shortest(v, d, endpts[k - 1], limit, end,
-							 (chr **) NULL, (int *) NULL);
+							 (const chr **) NULL, (int *) NULL);
 		if (ISERR())
 		{
 			FREE(endpts);
diff --git a/src/backend/regex/regfree.c b/src/backend/regex/regfree.c
index ae17ae7..2aac3db 100644
--- a/src/backend/regex/regfree.c
+++ b/src/backend/regex/regfree.c
@@ -50,5 +50,5 @@ pg_regfree(regex_t *re)
 {
 	if (re == NULL)
 		return;
-	(*((struct fns *) re->re_fns)->free) (re);
+	(*((const struct fns *) re->re_fns)->free) (re);
 }
diff --git a/src/include/regex/regcustom.h b/src/include/regex/regcustom.h
index 04a1893..b97bce2 100644
--- a/src/include/regex/regcustom.h
+++ b/src/include/regex/regcustom.h
@@ -28,6 +28,18 @@
  * src/include/regex/regcustom.h
  */
 
+/*
+ * Modification Notice:
+ *
+ * I have modified the software in this regex package, including files in the
+ * src/include/regex and src/backend/regex directories, to avoid casting away
+ * const and enable compiling the software with the -Wcast-qual flag without
+ * warning.  This notice is given to comply with the license requirement, above,
+ * which requires me to indicate the origin and nature of modifications.
+ *
+ *		Mark Dilger, September 26, 2016
+ */
+
 /* headers if any */
 #include "postgres.h"
 
diff --git a/src/include/regex/regex.h b/src/include/regex/regex.h
index cc73db2..fed55ce 100644
--- a/src/include/regex/regex.h
+++ b/src/include/regex/regex.h
@@ -47,6 +47,8 @@
  */
 typedef long regoff_t;
 
+struct fns;
+
 /*
  * other interface types
  */
@@ -76,7 +78,7 @@ typedef struct
 	Oid			re_collation;	/* Collation that defines LC_CTYPE behavior */
 	/* the rest is opaque pointers to hidden innards */
 	char	   *re_guts;		/* `char *' is more portable than `void *' */
-	char	   *re_fns;
+	const struct fns   *re_fns;
 } regex_t;
 
 /* result reporting (may acquire more fields later) */
diff --git a/src/include/regex/regguts.h b/src/include/regex/regguts.h
index 69816f1..86eb6e0 100644
--- a/src/include/regex/regguts.h
+++ b/src/include/regex/regguts.h
@@ -450,10 +450,10 @@ struct fns
 };
 
 #define CANCEL_REQUESTED(re)  \
-	((*((struct fns *) (re)->re_fns)->cancel_requested) ())
+	((*((const struct fns *) (re)->re_fns)->cancel_requested) ())
 
 #define STACK_TOO_DEEP(re)	\
-	((*((struct fns *) (re)->re_fns)->stack_too_deep) ())
+	((*((const struct fns *) (re)->re_fns)->stack_too_deep) ())
 
 
 /*