Sort-out regression-test failures. Provide fixes for all of them except one

(multiplexer), which shall remain disabled until upstream figures it out.

3 files changed, 2342 insertions, 11 deletions

diff --git a/devel/tcllib/Makefile b/devel/tcllib/Makefile
index ee9360b96105..ebeb51b2019d 100644
--- a/devel/tcllib/Makefile
+++ b/devel/tcllib/Makefile
@@ -104,7 +104,7 @@ do-install:
 	${RM} ${WRKSRC}/modules/tcllibc/license.terms
 	${CP} -Rp ${WRKSRC}/modules/tcllibc ${STAGEDIR}${PREFIX}/lib/tcllib/
 
-test check xregression-test: build
+test check regression-test: build
 	cd ${WRKSRC} && ${SETENV} LANG=C LC_ALL=C DISPLAY= ${MAKE} test
 
 .include <bsd.port.mk>
diff --git a/devel/tcllib/files/patch-tests b/devel/tcllib/files/patch-tests
index 3e6aaa8c3def..4653ae2c1281 100644
--- a/devel/tcllib/files/patch-tests
+++ b/devel/tcllib/files/patch-tests
@@ -1,18 +1,32 @@
+Submitted upstream:
+
+	http://core.tcl.tk/tcllib/tktview/ea3f40b29fdc42ccc7d3429ec6746400643aaf4a
 --- modules/clock/iso8601.test	2014-02-11 14:04:18.000000000 -0500
 +++ modules/clock/iso8601.test	2014-12-09 00:12:22.000000000 -0500
 @@ -27,5 +27,5 @@
  test clock-iso8601-1.1 {parse_date, bad option} -body {
      clock::iso8601 parse_date 1994-11-05 -foo x
 -} -returnCodes error -result {bad switch "-foo", must be -base, -format, -gmt, -locale or -timezone}
-+} -returnCodes error -match regexp -result {bad (option|switch) "-foo", must be -base, -format, -gmt, -locale or -timezone}
++} -returnCodes error -match regexp -result {^bad (option|switch) "-foo"}
  
  # NOTE: While listed as legal, -format is NOT. This is because the
---- modules/struct/sets.test	2014-02-11 14:04:18.000000000 -0500
-+++ modules/struct/sets.test	2014-12-09 01:39:00.000000000 -0500
-@@ -87,5 +87,5 @@
- 	}
- 	tcl {
--	    if {[package vsatisfies [package present Tcl] 8.5]} {
-+	    if {$tcl_version == 8.5} {
- 		# In 8.5 head the alias itself is reported, not what it
- 		# resolved to.
+
+This awaits fix:
+
+	http://core.tcl.tk/tcllib/tktview/ced089d5fec86a1b4722ffbd93810820ccc06845
+--- modules/multiplexer/multiplexer.test	2015-04-30 00:21:20 -0400
++++ modules/multiplexer/multiplexer.test	2015-05-27 18:58:34 -0400
+@@ -190,5 +190,5 @@
+ }
+ 
+-test multiplexer-5.2 {add access filter which denies access} {
++test multiplexer-5.2 {add access filter which denies access} -body {
+     set ::forever {}
+     set mp [multiplexer::create]
+@@ -208,5 +208,5 @@
+     ${mp}::destroy
+     set result
+-} {socket blocked}
++} -result {socket blocked} -constraints knownBug
+ 
+ 
diff --git a/devel/tcllib/files/patch-warnings b/devel/tcllib/files/patch-warnings
new file mode 100644
index 000000000000..3432d51d696c
--- /dev/null
+++ b/devel/tcllib/files/patch-warnings
@@ -0,0 +1,2317 @@
+--- modules/struct/graph/arc.c	2014-02-11 14:04:18 -0500
++++ modules/struct/graph/arc.c	2014-12-08 18:42:51 -0500
+@@ -3,8 +3,9 @@
+  */
+ 
+-#include <arc.h>
+-#include <attr.h>
+-#include <graph.h>
+-#include <util.h>
++#include "arc.h"
++#include "attr.h"
++#include "graph.h"
++#include "nacommon.h"
++#include "util.h"
+ 
+ /* .................................................. */
+--- modules/struct/graph/attr.c	2014-02-11 14:04:18 -0500
++++ modules/struct/graph/attr.c	2014-12-08 18:52:56 -0500
+@@ -3,6 +3,8 @@
+  */
+ 
+-#include <attr.h>
+-#include <util.h>
++#include "attr.h"
++#include "util.h"
++#include <string.h>
++
+ 
+ /* .................................................. */
+--- modules/struct/graph/filter.c	2014-02-11 14:04:18 -0500
++++ modules/struct/graph/filter.c	2014-12-08 19:09:17 -0500
+@@ -3,7 +3,8 @@
+  */
+ 
+-#include <nacommon.h>
+-#include <util.h>
+-#include <node.h>
++#include <string.h>
++#include "nacommon.h"
++#include "util.h"
++#include "node.h"
+ 
+ /* .................................................. */
+@@ -254,11 +254,10 @@
+ 	filter_none (interp, gx, &l);
+     } else {
+-	if (na->mode != NA_NONE) {
+-	    if (nodes) {
+-		filter_mode_n (na->mode, gx, &l, na->nc, na->nv, g);
+-	    } else {
+-		filter_mode_a (na->mode, gx, &l, na->nc, na->nv, g);
+-	    }
++	if (nodes) {
++	    filter_mode_n (na->mode, gx, &l, na->nc, na->nv, g);
++	} else {
++	    filter_mode_a (na->mode, gx, &l, na->nc, na->nv, g);
+ 	}
++
+ 	if (na->key && na->value) {
+ 	    filter_kv (interp, gx, &l, gf, g, na->key, na->value);
+@@ -325,4 +324,5 @@
+     case NA_INNER:     filter_mode_a_inn (gx, l, nc, nv, g); break;
+     case NA_OUT:       filter_mode_a_out (gx, l, nc, nv, g); break;
++    case NA_NONE:      /* nothing */;
+     }
+ }
+@@ -585,4 +585,5 @@
+     case NA_INNER:     filter_mode_n_inn (gx, l, nc, nv, g); break;
+     case NA_OUT:       filter_mode_n_out (gx, l, nc, nv, g); break;
++    case NA_NONE:      /* nothing */;
+     }
+ }
+--- modules/struct/sets_c.tcl	2014-02-11 14:04:18 -0500
++++ modules/struct/sets_c.tcl	2014-12-08 19:14:25 -0500
+@@ -54,5 +54,5 @@
+             S_intersect3,       S_size, S_subsetof,     S_subtract,
+             S_symdiff,  S_union
+-        };
++        } method;
+ 
+ 	int m;
+@@ -70,5 +70,5 @@
+          */
+ 
+-        switch (m) {
++        switch (method = m) {
+             case S_add:        return sm_ADD        (NULL, interp, objc, objv);
+             case S_contains:   return sm_CONTAINS   (NULL, interp, objc, objv);
+--- modules/struct/stack/ms.c	2014-02-11 14:04:18 -0500
++++ modules/struct/stack/ms.c	2014-12-08 20:27:34 -0500
+@@ -40,5 +40,5 @@
+ 	M_CLEAR, M_DESTROY, M_GET,    M_GETR, M_PEEK, M_PEEKR,
+ 	M_POP,   M_PUSH,    M_ROTATE, M_SIZE, M_TRIM, M_TRIMV
+-    };
++    } method;
+ 
+     if (objc < 2) {
+@@ -54,5 +54,5 @@
+      */
+ 
+-    switch (m) {
++    switch (method = m) {
+     case M_CLEAR:	return stm_CLEAR   (s, interp, objc, objv);
+     case M_DESTROY:	return stm_DESTROY (s, interp, objc, objv);
+--- modules/pt/pt_rdengine_c.tcl	2014-02-11 14:04:18 -0500
++++ modules/pt/pt_rdengine_c.tcl	2014-12-08 19:24:26 -0500
+@@ -49,5 +49,5 @@
+ 
+ 	typedef struct PARAMg {
+-	    long int counter;
++	    size_t counter;
+ 	    char     buf [50];
+ 	} PARAMg;
+@@ -77,5 +77,5 @@
+ 	    
+ 	    paramg->counter ++;
+-	    sprintf (paramg->buf, "rde%ld", paramg->counter);
++	    sprintf (paramg->buf, "rde%td", paramg->counter);
+ 	    return paramg->buf;
+ 
+--- modules/struct/queue_c.tcl	2014-02-11 14:04:18 -0500
++++ modules/struct/queue_c.tcl	2014-12-08 19:52:34 -0500
+@@ -36,5 +36,5 @@
+ 
+ 	typedef struct QDg {
+-	    long int counter;
++	    size_t counter;
+ 	    char buf [50];
+ 	} QDg;
+@@ -64,5 +64,5 @@
+ 	    
+ 	    qdg->counter ++;
+-	    sprintf (qdg->buf, "queue%d", qdg->counter);
++	    sprintf (qdg->buf, "queue%td", qdg->counter);
+ 	    return qdg->buf;
+ 
+--- modules/struct/stack_c.tcl	2014-02-11 14:04:18 -0500
++++ modules/struct/stack_c.tcl	2014-12-08 19:52:34 -0500
+@@ -41,5 +41,5 @@
+ 
+ 	typedef struct SDg {
+-	    long int counter;
++	    size_t counter;
+ 	    char buf [50];
+ 	} SDg;
+@@ -69,5 +69,5 @@
+ 	    
+ 	    sdg->counter ++;
+-	    sprintf (sdg->buf, "stack%d", sdg->counter);
++	    sprintf (sdg->buf, "stack%td", sdg->counter);
+ 	    return sdg->buf;
+ 
+--- modules/struct/tree_c.tcl	2014-02-11 14:04:18 -0500
++++ modules/struct/tree_c.tcl	2014-12-08 19:52:34 -0500
+@@ -42,5 +42,5 @@
+ 
+ 	typedef struct TDg {
+-	    long int counter;
++	    size_t   counter;
+ 	    char buf [50];
+ 	} TDg;
+@@ -70,5 +70,5 @@
+ 	    
+ 	    tdg->counter ++;
+-	    sprintf (tdg->buf, "tree%d", tdg->counter);
++	    sprintf (tdg->buf, "tree%td", tdg->counter);
+ 	    return tdg->buf;
+ 
+--- modules/struct/graph/ds.h	2014-02-11 14:04:18 -0500
++++ modules/struct/graph/ds.h	2014-12-08 20:36:48 -0500
+@@ -161,5 +161,5 @@
+ 
+ typedef struct GG {
+-    long int counter;  /* Graph id generator */
++    size_t   counter;  /* Graph id generator */
+     char     buf [50]; /* Buffer for handle construction */
+ } GG;
+--- modules/struct/graph/global.c	2014-02-11 14:04:18 -0500
++++ modules/struct/graph/global.c	2014-12-08 20:35:07 -0500
+@@ -25,5 +25,5 @@
+ 	    
+   gg->counter ++;
+-  sprintf (gg->buf, "graph%d", gg->counter);
++  sprintf (gg->buf, "graph%td", gg->counter);
+   return gg->buf;
+ }
+--- modules/pt/rde_critcl/param.h	2015-04-30 04:21:20 UTC
++++ modules/pt/rde_critcl/param.h	2015-05-27 18:01:30 UTC
+@@ -10,4 +10,5 @@
+ #include <util.h>  /* Scoping */
+ #include <stack.h> /* Stack handling */
++#include <stdint.h> /* intptr_t */
+ 
+ /*
+@@ -55,5 +55,5 @@ SCOPE Tcl_Obj*           rde_param_query
+ SCOPE void               rde_param_query_es      (RDE_PARAM p, long int* ec, ERROR_STATE*** ev);
+ SCOPE void               rde_param_query_ls      (RDE_PARAM p, long int* lc, void*** lv);
+-SCOPE long int           rde_param_query_lstop   (RDE_PARAM p);
++SCOPE intptr_t           rde_param_query_lstop   (RDE_PARAM p);
+ SCOPE Tcl_HashTable*     rde_param_query_nc      (RDE_PARAM p);
+ SCOPE int                rde_param_query_st      (RDE_PARAM p);
+--- modules/pt/rde_critcl/param.c	2015-04-30 04:21:20 UTC
++++ modules/pt/rde_critcl/param.c	2015-05-27 18:11:57
+@@ -4,9 +4,11 @@
+  */
+ 
+-#include <param.h> /* Public and private APIs */
+-#include <stack.h> /* Stack handling */
+-#include <tc.h>    /* Token cache handling */
+-#include <util.h>  /* Allocation utilities */
++#include <stdint.h>
++#include <stdlib.h>
+ #include <string.h>
++#include "param.h" /* Public and private APIs */
++#include "stack.h" /* Stack handling */
++#include "tc.h"    /* Token cache handling */
++#include "util.h"  /* Allocation utilities */
+ 
+ /*
+@@ -421,8 +423,8 @@ rde_param_query_ls (RDE_PARAM p, long in
+ }
+ 
+-SCOPE long int
++SCOPE intptr_t
+ rde_param_query_lstop (RDE_PARAM p)
+ {
+-    (long int) rde_stack_top (p->LS);
++    return (intptr_t) rde_stack_top (p->LS);
+ }
+ 
+@@ -671,5 +673,5 @@ error_set (RDE_PARAM p, long int s)
+     ASSERT_BOUNDS(s,p->numstr);
+ 
+-    rde_stack_push (p->ER->msg, (void*) s);
++    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ }
+ 
+@@ -821,5 +823,5 @@ rde_param_i_symbol_restore (RDE_PARAM p,
+ 
+     tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+     if (!hPtr) { return 0; }
+ 
+@@ -862,5 +864,5 @@ rde_param_i_symbol_save (RDE_PARAM p, lo
+      */
+ 
+-    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 
+     if (isnew) {
+@@ -872,5 +874,5 @@ rde_param_i_symbol_save (RDE_PARAM p, lo
+     }
+ 
+-    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 
+     if (isnew) {
+@@ -1072,5 +1074,7 @@ static int
+ UniCharIsHexDigit (int character)
+ {
+-    return (character >= 0) && (character < 0x80) && isxdigit(character);
++    return UniCharIsDecDigit(character) ||
++	(character >= 'a' && character <= 'f') ||
++	(character >= 'A' && character <= 'F');
+ }
+ 
+@@ -1078,5 +1082,5 @@ static int
+ UniCharIsDecDigit (int character)
+ {
+-    return (character >= 0) && (character < 0x80) && isdigit(character);
++    return (character >= '0') && (character <= '9');
+ }
+ 
+--- modules/struct/tree/m.c	2014-02-11 14:04:18 -0500
++++ modules/struct/tree/m.c	2014-12-08 20:05:53 -0500
+@@ -5,4 +5,6 @@
+  */
+ 
++#include <ctype.h>
++#include <stdint.h>
+ #include <string.h>
+ #include "util.h"
+@@ -19,4 +21,6 @@
+ static int TclGetIntForIndex (Tcl_Interp* interp, Tcl_Obj* objPtr,
+ 			      int endValue, int* indexPtr);
++static int TclCheckBadOctal (Tcl_Interp *interp, const char *value);
++static int TclFormatInt (char *buffer, long n);
+ 
+ /* .................................................. */
+@@ -2546,5 +2550,5 @@
+     res = t_walk (interp, tn, type, order,
+ 		  t_walk_invokecmd,
+-		  (Tcl_Obj*) cc, (Tcl_Obj*) ev, objv [0]);
++		  (void *)(intptr_t)cc, (Tcl_Obj*) ev, objv [0]);
+ 
+     ckfree ((char*) ev);
+--- modules/struct/tree/walk.c	2014-02-11 14:04:18 -0500
++++ modules/struct/tree/walk.c	2014-12-08 20:07:16 -0500
+@@ -1,7 +1,8 @@
+ 
++#include <stdint.h>
+ #include <string.h>
+-#include "tcl.h"
+-#include <t.h>
+-#include <util.h>
++#include <tcl.h>
++#include "t.h"
++#include "util.h"
+ 
+ /* .................................................. */
+@@ -238,5 +239,5 @@
+ {
+     int	      res;
+-    int	      cc = (int)       dummy0;
++    int	      cc = (intptr_t)  dummy0;
+     Tcl_Obj** ev = (Tcl_Obj**) dummy1; /* cc+3 elements */
+ 
+--- modules/md5/md5.h	2014-02-11 14:04:18 -0500
++++ modules/md5/md5.h	2014-12-08 20:23:10 -0500
+@@ -60,5 +60,5 @@
+ 
+ void MD5Init   (MD5_CTX *mdContext);
+-void MD5Update (MD5_CTX *mdContext, unsigned char *buf, unsigned int len);
++void MD5Update (MD5_CTX *mdContext, const unsigned char *buf, unsigned int len);
+ void MD5Final  (unsigned char digest[16], MD5_CTX *mdContext);
+ void Transform (UINT4 *buf, UINT4 *in);
+--- modules/md5/md5.c	2014-02-11 14:04:18 -0500
++++ modules/md5/md5.c	2014-12-08 20:22:05 -0500
+@@ -116,5 +116,5 @@
+  */
+ void MD5Update (mdContext, inBuf, inLen)
+-register MD5_CTX *mdContext; unsigned char *inBuf;
++register MD5_CTX *mdContext; const unsigned char *inBuf;
+ 		 unsigned int inLen;
+ {
+--- modules/md5crypt/md5cryptc.tcl	2014-02-11 14:04:18 -0500
++++ modules/md5crypt/md5cryptc.tcl	2014-12-08 20:20:05 -0500
+@@ -57,6 +58,7 @@
+                                const char *magic)
+         {
+-            static char     passwd[120], *p;
+-            static const unsigned char *sp,*ep;
++            static char     passwd[120];
++            char     *p;
++            const unsigned char *sp,*ep;
+             unsigned char	final[16];
+             int sl,pl,i;
+@@ -113,5 +115,5 @@
+             
+             /* Now make the output string */
+-            snprintf(passwd, sizeof(passwd), "%s%.*s$", (char *)magic,
++            p = passwd + snprintf(passwd, sizeof(passwd), "%s%.*s$", (char *)magic,
+                     sl, (const char *)sp);
+             
+@@ -143,6 +145,4 @@
+             }
+ 
+-            p = passwd + strlen(passwd);
+-            
+             l = (final[ 0]<<16) | (final[ 6]<<8) | final[12]; to64(p,l,4); p += 4;
+             l = (final[ 1]<<16) | (final[ 7]<<8) | final[13]; to64(p,l,4); p += 4;
+--- modules/rc4/rc4c.tcl	2014-02-11 14:04:18 -0500
++++ modules/rc4/rc4c.tcl	2014-12-08 20:25:20 -0500
+@@ -21,4 +21,6 @@
+ 
+     critcl::ccode {
++	#include <string.h>
++
+         typedef struct RC4_CTX {
+             unsigned char x;
+--- modules/struct/sets/m.c	2014-02-11 14:04:18 -0500
++++ modules/struct/sets/m.c	2014-12-08 20:40:10 -0500
+@@ -81,5 +81,5 @@
+ 	    }
+ 
+-	    (void*) Tcl_CreateHashEntry(&vs->el, key, &new);
++	    Tcl_CreateHashEntry(&vs->el, key, &new);
+ 	    nx = 1;
+ 	}
+--- modules/struct/sets/s.c	2014-02-11 14:04:18 -0500
++++ modules/struct/sets/s.c	2014-12-08 21:36:17 -0500
+@@ -294,5 +294,5 @@
+ 	/* key is in a, not in b <=> in (a-b) */
+ 
+-	(void*) Tcl_CreateHashEntry(&s->el, key, &new);
++	Tcl_CreateHashEntry(&s->el, key, &new);
+     }
+ 
+@@ -330,5 +330,5 @@
+ 	/* key is in a, in b <=> in (a*b) */
+ 
+-	(void*) Tcl_CreateHashEntry(&s->el, key, &new);
++	Tcl_CreateHashEntry(&s->el, key, &new);
+     }
+ 
+@@ -366,5 +366,5 @@
+ 	    he = Tcl_NextHashEntry(&hs)) {
+ 	    key = Tcl_GetHashKey (&b->el, he);
+-	    (void*) Tcl_CreateHashEntry(&a->el, key, &new);
++	    Tcl_CreateHashEntry(&a->el, key, &new);
+ 	    if (new) {nx = 1;}
+ 	}
+@@ -378,5 +378,5 @@
+     int new;
+ 
+-    (void*) Tcl_CreateHashEntry(&a->el, item, &new);
++    Tcl_CreateHashEntry(&a->el, item, &new);
+ }
+ 
+--- modules/struct/tree/ms.c	2014-02-11 14:04:18 -0500
++++ modules/struct/tree/ms.c	2014-12-08 21:02:50 -0500
+@@ -313,5 +313,5 @@
+ 	M_ROOTNAME,    M_SERIALIZE,   M_SET,	   M_SIZE,     M_SPLICE,
+ 	M_SWAP,	       M_UNSET,	      M_WALK,	   M_WALKPROC
+-    };
++    } method;
+ 
+     if (objc < 2) {
+@@ -327,5 +327,5 @@
+      */
+ 
+-    switch (m) {
++    switch (method = m) {
+     case M_TASSIGN:	return tm_TASSIGN     (t, interp, objc, objv);
+     case M_TSET:	return tm_TSET	      (t, interp, objc, objv);
+--- modules/struct/tree/t.c	2014-02-11 14:04:18 -0500
++++ modules/struct/tree/t.c	2014-12-08 21:07:14 -0500
+@@ -3,7 +3,8 @@
+  */
+ 
+-#include <t.h>
+-#include <tn.h>
+-#include <util.h>
++#include <string.h>
++#include "t.h"
++#include "tn.h"
++#include "util.h"
+ 
+ /* .................................................. */
+--- modules/struct/tree/tn.c	2014-02-11 14:04:18 -0500
++++ modules/struct/tree/tn.c	2014-12-08 21:09:28 -0500
+@@ -3,6 +3,7 @@
+  */
+ 
+-#include <tn.h>
+-#include <util.h>
++#include "t.h"
++#include "tn.h"
++#include "util.h"
+ 
+ /* .................................................. */
+--- modules/struct/tree/util.h	2014-02-11 14:04:18 -0500
++++ modules/struct/tree/util.h	2014-12-08 21:15:54 -0500
+@@ -53,5 +53,5 @@
+ void  nlq_push   (NLQ* q, void* n);
+ void* nlq_pop    (NLQ* q);
+-void* nlq_clear  (NLQ* q);
++void  nlq_clear  (NLQ* q);
+ 
+ #endif /* _UTIL_H */
+--- modules/struct/tree/util.c	2014-02-11 14:04:18 -0500
++++ modules/struct/tree/util.c	2014-12-08 21:15:58 -0500
+@@ -78,5 +78,5 @@
+  */
+ 
+-void*
++void
+ nlq_clear (NLQ* q)
+ {
+--- modules/struct/graph/util.h	2014-02-11 14:04:18 -0500
++++ modules/struct/graph/util.h	2014-12-08 21:56:17 -0500
+@@ -54,5 +54,5 @@
+ void  g_nlq_push   (NLQ* q, void* n);
+ void* g_nlq_pop    (NLQ* q);
+-void* g_nlq_clear  (NLQ* q);
++void  g_nlq_clear  (NLQ* q);
+ 
+ #endif /* _G_UTIL_H */
+--- modules/struct/graph/util.c	2014-02-11 14:04:18 -0500
++++ modules/struct/graph/util.c	2014-12-08 21:55:44 -0500
+@@ -78,5 +78,5 @@
+  */
+ 
+-void*
++void
+ g_nlq_clear (NLQ* q)
+ {
+--- modules/pt/rde_critcl/p.c	2014-02-11 14:04:18 -0500
++++ modules/pt/rde_critcl/p.c	2014-12-08 21:21:53 -0500
+@@ -3,7 +3,8 @@
+  */
+ 
+-#include <pInt.h> /* Our public and internal APIs */
+-#include <util.h> /* Allocation macros */
++#include <stdint.h>
+ #include <string.h>
++#include "pInt.h" /* Our public and internal APIs */
++#include "util.h" /* Allocation macros */
+ 
+ /* .................................................. */
+@@ -129,5 +130,5 @@
+     ASSERT (isnew, "Should have found entry");
+ 
+-    Tcl_SetHashValue (hPtr, p->numstr);
++    Tcl_SetHashValue (hPtr, (intptr_t)p->numstr);
+ 
+     if (p->numstr >= p->maxnum) {
+--- modules/pt/pt_parse_peg_c.tcl	2015-04-30 04:21:20 UTC
++++ modules/pt/pt_parse_peg_c.tcl	2015-05-27 18:21:29 UTC
+@@ -46,4 +46,6 @@
+ 	/* -*- c -*- */
+ 
++	#include <stdint.h>
++	#include <stdlib.h>
+ 	#include <string.h>
+ 	#define SCOPE static
+@@ -733,8 +735,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -883,5 +885,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -972,5 +974,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void *)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -988,5 +990,5 @@
+ 	rde_param_i_symbol_save (RDE_PARAM p, int s)
+ 	{
+-	    long int       at = (long int) rde_stack_top (p->LS);
++	    intptr_t       at = (intptr_t)rde_stack_top (p->LS);
+ 	    NC_STATE*      scs;
+ 	    Tcl_HashEntry* hPtr;
+@@ -997,5 +999,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*) at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -1005,5 +1007,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void*)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1150,10 +1152,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+@@ -4693,5 +4697,5 @@
+ 
+ 	typedef struct PARSERg {
+-	    long int counter;
++	    size_t   counter;
+ 	    char     buf [50];
+ 	} PARSERg;
+@@ -4721,5 +4725,5 @@
+ 
+ 	    parserg->counter ++;
+-	    sprintf (parserg->buf, "peg%ld", parserg->counter);
++	    sprintf (parserg->buf, "peg%td", parserg->counter);
+ 	    return parserg->buf;
+ #undef  KEY
+--- modules/struct/graph/graph.c	2014-02-11 14:04:18 -0500
++++ modules/struct/graph/graph.c	2014-12-08 21:33:22 -0500
+@@ -3,10 +3,11 @@
+  */
+ 
+-#include <arc.h>
+-#include <attr.h>
+-#include <graph.h>
+-#include <node.h>
+-#include <objcmd.h>
+-#include <util.h>
++#include <stdint.h>
++#include "arc.h"
++#include "attr.h"
++#include "graph.h"
++#include "node.h"
++#include "objcmd.h"
++#include "util.h"
+ 
+ /* .................................................. */
+@@ -160,9 +161,9 @@
+ 		goto abort;
+ 	    }
+-	    if (Tcl_FindHashEntry (&cn, (char*) n)) continue;
++	    if (Tcl_FindHashEntry (&cn, (void *) n)) continue;
+ 	    ASSERT_BOUNDS(j, lc-1);
+-	    he = Tcl_CreateHashEntry (&cn, (char*) n, &new);
++	    he = Tcl_CreateHashEntry (&cn, (void *) n, &new);
+ 	    lv [j] = n->base.name;
+-	    Tcl_SetHashValue (he, (ClientData) j);
++	    Tcl_SetHashValue (he, (ClientData)(intptr_t)j);
+ 	    j += 3;
+ 	}
+@@ -181,5 +182,5 @@
+ 	    he = Tcl_CreateHashEntry (&cn, (char*) n, &new);
+ 	    lv [j] = n->base.name;
+-	    Tcl_SetHashValue (he, (ClientData) j);
++	    Tcl_SetHashValue (he, (ClientData)(intptr_t)j);
+ 	    j += 3;
+ 	}
+--- modules/struct/graph/methods.c	2014-02-11 14:04:18 -0500
++++ modules/struct/graph/methods.c	2014-12-08 21:39:41 -0500
+@@ -5,12 +5,14 @@
+  */
+ 
++#include <ctype.h>
+ #include <string.h>
+-#include <arc.h>
+-#include <graph.h>
+-#include <methods.h>
+-#include <nacommon.h>
+-#include <node.h>
+-#include <util.h>
+-#include <walk.h>
++#include "arc.h"
++#include "attr.h"
++#include "graph.h"
++#include "methods.h"
++#include "nacommon.h"
++#include "node.h"
++#include "util.h"
++#include "walk.h"
+ 
+ /* ..................................................
+--- modules/struct/graph/nacommon.c	2014-02-11 14:04:18 -0500
++++ modules/struct/graph/nacommon.c	2014-12-08 21:41:25 -0500
+@@ -3,7 +3,8 @@
+  */
+ 
+-#include <nacommon.h>
+-#include <util.h>
+-#include <node.h>
++#include "attr.h"
++#include "nacommon.h"
++#include "util.h"
++#include "node.h"
+ 
+ /* .................................................. */
+--- modules/struct/graph/node.c	2014-02-11 14:04:18 -0500
++++ modules/struct/graph/node.c	2014-12-08 21:43:45 -0500
+@@ -3,7 +3,8 @@
+  */
+ 
+-#include <arc.h>
+-#include <node.h>
+-#include <util.h>
++#include "nacommon.h"
++#include "arc.h"
++#include "node.h"
++#include "util.h"
+ 
+ /* .................................................. */
+--- modules/struct/graph/methods.h	2014-02-11 14:04:18 -0500
++++ modules/struct/graph/methods.h	2014-12-08 21:47:58 -0500
+@@ -31,4 +31,5 @@
+ int gm_arc_DELETE     (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv);
+ int gm_arc_EXISTS     (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv);
++int gm_arc_FLIP	      (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv);
+ int gm_arc_GET	      (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv);
+ int gm_arc_GETALL     (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv);
+@@ -40,4 +41,8 @@
+ int gm_arc_KEYS	      (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv);
+ int gm_arc_LAPPEND    (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv);
++int gm_arc_MOVE       (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv);
++int gm_arc_MOVE_SRC   (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv);
++int gm_arc_MOVE_TARG  (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv);
++int gm_arc_NODES      (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv);
+ int gm_arc_RENAME     (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv);
+ int gm_arc_SET	      (G* g, Tcl_Interp* interp, int objc, Tcl_Obj* const* objv);
+--- modules/struct/graph/objcmd.c	2014-02-11 14:04:18 -0500
++++ modules/struct/graph/objcmd.c	2014-12-08 21:53:43 -0500
+@@ -41,5 +41,5 @@
+ 	M_NODE,	   M_NODES,   M_SERIALIZE, M_SET,	M_SWAP, M_UNSET,
+ 	M_WALK
+-    };
++    } method;
+ 
+     static CONST char* a_methods [] = {
+@@ -58,5 +58,5 @@
+ 	MA_SETWEIGHT,	MA_SOURCE,      MA_TARGET,        MA_UNSET,     MA_UNSETWEIGHT,
+ 	MA_WEIGHTS
+-    };
++    } a_method;
+ 
+     static CONST char* n_methods [] = {
+@@ -70,5 +70,5 @@
+ 	MN_GET,	    MN_GETALL,	 MN_INSERT, MN_KEYEXISTS, MN_KEYS,
+ 	MN_LAPPEND, MN_OPPOSITE, MN_RENAME, MN_SET,	  MN_UNSET
+-    };
++    } n_method;
+ 
+     if (objc < 2) {
+@@ -84,5 +84,5 @@
+      */
+ 
+-    switch (m) {
++    switch (method = m) {
+     case M_GSET:	return gm_GSET	      (g, interp, objc, objv);
+     case M_GASSIGN:	return gm_GASSIGN     (g, interp, objc, objv);
+@@ -96,5 +96,5 @@
+ 	    return TCL_ERROR;
+ 	}
+-	switch (m) {
++	switch (a_method = m) {
+ 	case MA_APPEND:	       return gm_arc_APPEND     (g, interp, objc, objv);
+ 	case MA_ATTR:	       return gm_arc_ATTR	(g, interp, objc, objv);
+@@ -142,5 +142,5 @@
+ 	    return TCL_ERROR;
+ 	}
+-	switch (m) {
++	switch (n_method = m) {
+ 	case MN_APPEND:	   return gm_node_APPEND    (g, interp, objc, objv);
+ 	case MN_ATTR:	   return gm_node_ATTR	    (g, interp, objc, objv);
+--- modules/struct/graph/walk.c	2014-02-11 14:04:18 -0500
++++ modules/struct/graph/walk.c	2014-12-08 21:58:59 -0500
+@@ -1,7 +1,7 @@
+-
+-#include "tcl.h"
+-#include <graph.h>
+-#include <util.h>
+-#include <walk.h>
++#include <string.h>
++#include <tcl.h>
++#include "graph.h"
++#include "util.h"
++#include "walk.h"
+ 
+ /* .................................................. */
+@@ -23,5 +23,5 @@
+ 			int cc, Tcl_Obj** ev, Tcl_Obj* action);
+ 
+-static int walk_neighbours (GN* n, Tcl_HashTable* v, int dir,
++static void walk_neighbours (GN* n, Tcl_HashTable* v, int dir,
+ 			    int* nc, GN*** nv);
+ 
+@@ -288,5 +288,5 @@
+ /* .................................................. */
+ 
+-static int
++static void
+ walk_neighbours (GN* n, Tcl_HashTable* vn, int dir,
+ 		 int* nc, GN*** nv)
+--- modules/struct/queue/ms.c	2014-02-11 14:04:18 -0500
++++ modules/struct/queue/ms.c	2014-12-08 22:02:03 -0500
+@@ -42,5 +42,5 @@
+ 	M_PEEK,  M_PUT,     M_SIZE,
+ 	M_UNGET
+-    };
++    } method;
+ 
+     if (objc < 2) {
+@@ -56,5 +56,5 @@
+      */
+ 
+-    switch (m) {
++    switch (method = m) {
+     case M_CLEAR:	return qum_CLEAR   (q, interp, objc, objv);
+     case M_DESTROY:	return qum_DESTROY (q, interp, objc, objv);
+--- modules/sha1/sha1c.tcl	2015-04-30 00:21:20 -0400
++++ modules/sha1/sha1c.tcl	2015-05-27 13:54:27 -0400
+@@ -33,6 +33,5 @@
+         sha1_free_rep(Tcl_Obj* obj)
+         {
+-            SHA1_CTX* mp = (SHA1_CTX*) obj->internalRep.otherValuePtr;
+-            Tcl_Free ((char*)mp);
++            Tcl_Free(obj->internalRep.otherValuePtr);
+         }
+         
+--- modules/pt/pt_cparam_config_critcl.tcl	2015-04-30 04:21:20 UTC
++++ modules/pt/pt_cparam_config_critcl.tcl	2015-05-27 21:42:23 UTC
+@@ -115,4 +115,6 @@ proc ::pt::cparam::configuration::critcl
+ 		/* -*- c -*- */
+ 
++		#include <stdint.h>
++		#include <stdlib.h>
+ 		#include <string.h>
+ 		#define SCOPE static
+--- modules/pt/tests/data/ok/peg_cparam-critcl/0_basic_arithmetic	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-critcl/0_basic_arithmetic	2015-05-27 22:50:17 UTC
+@@ -46,4 +46,6 @@
+ 	/* -*- c -*- */
+ 
++	#include <stdint.h>
++	#include <stdlib.h>
+ 	#include <string.h>
+ 	#define SCOPE static
+@@ -733,8 +735,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -897,5 +899,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -987,5 +989,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -1012,5 +1014,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -1020,5 +1022,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1170,10 +1172,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-critcl/1_functions	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-critcl/1_functions	2015-05-27 22:50:47 UTC
+@@ -46,4 +46,6 @@
+ 	/* -*- c -*- */
+ 
++	#include <stdint.h>
++	#include <stdlib.h>
+ 	#include <string.h>
+ 	#define SCOPE static
+@@ -733,8 +735,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -897,5 +899,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -987,5 +989,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -1012,5 +1014,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -1020,5 +1022,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1170,10 +1172,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-critcl/2_fun_arithmetic	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-critcl/2_fun_arithmetic	2015-05-27 22:50:47 UTC
+@@ -46,4 +46,6 @@
+ 	/* -*- c -*- */
+ 
++	#include <stdint.h>
++	#include <stdlib.h>
+ 	#include <string.h>
+ 	#define SCOPE static
+@@ -733,8 +735,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -897,5 +899,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -987,5 +989,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -1012,5 +1014,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -1020,5 +1022,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1170,10 +1172,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-critcl/3_peg_itself	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-critcl/3_peg_itself	2015-05-27 22:50:47 UTC
+@@ -46,4 +46,6 @@
+ 	/* -*- c -*- */
+ 
++	#include <stdint.h>
++	#include <stdlib.h>
+ 	#include <string.h>
+ 	#define SCOPE static
+@@ -733,8 +735,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -897,5 +899,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -987,5 +989,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -1012,5 +1014,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -1020,5 +1022,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1170,10 +1172,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-critcl/4_choice	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-critcl/4_choice	2015-05-27 22:50:47 UTC
+@@ -46,4 +46,6 @@
+ 	/* -*- c -*- */
+ 
++	#include <stdint.h>
++	#include <stdlib.h>
+ 	#include <string.h>
+ 	#define SCOPE static
+@@ -733,8 +735,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -897,5 +899,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -987,5 +989,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -1012,5 +1014,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -1020,5 +1022,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1170,10 +1172,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-critcl/5_sequence	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-critcl/5_sequence	2015-05-27 22:50:47 UTC
+@@ -46,4 +46,6 @@
+ 	/* -*- c -*- */
+ 
++	#include <stdint.h>
++	#include <stdlib.h>
+ 	#include <string.h>
+ 	#define SCOPE static
+@@ -733,8 +735,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -897,5 +899,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -987,5 +989,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -1012,5 +1014,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -1020,5 +1022,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1170,10 +1172,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-critcl/6_optional	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-critcl/6_optional	2015-05-27 22:50:47 UTC
+@@ -46,4 +46,6 @@
+ 	/* -*- c -*- */
+ 
++	#include <stdint.h>
++	#include <stdlib.h>
+ 	#include <string.h>
+ 	#define SCOPE static
+@@ -733,8 +735,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -897,5 +899,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -987,5 +989,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -1012,5 +1014,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -1020,5 +1022,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1170,10 +1172,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-critcl/7_kleene	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-critcl/7_kleene	2015-05-27 22:50:47 UTC
+@@ -46,4 +46,6 @@
+ 	/* -*- c -*- */
+ 
++	#include <stdint.h>
++	#include <stdlib.h>
+ 	#include <string.h>
+ 	#define SCOPE static
+@@ -733,8 +735,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -897,5 +899,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -987,5 +989,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -1012,5 +1014,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -1020,5 +1022,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1170,10 +1172,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-critcl/8_pkleene	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-critcl/8_pkleene	2015-05-27 22:50:47 UTC
+@@ -46,4 +46,6 @@
+ 	/* -*- c -*- */
+ 
++	#include <stdint.h>
++	#include <stdlib.h>
+ 	#include <string.h>
+ 	#define SCOPE static
+@@ -733,8 +735,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -897,5 +899,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -987,5 +989,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -1012,5 +1014,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -1020,5 +1022,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1170,10 +1172,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-critcl/9_ahead	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-critcl/9_ahead	2015-05-27 22:50:47 UTC
+@@ -46,4 +46,6 @@
+ 	/* -*- c -*- */
+ 
++	#include <stdint.h>
++	#include <stdlib.h>
+ 	#include <string.h>
+ 	#define SCOPE static
+@@ -733,8 +735,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -897,5 +899,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -987,5 +989,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -1012,5 +1014,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -1020,5 +1022,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1170,10 +1172,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-critcl/10_notahead	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-critcl/10_notahead	2015-05-27 22:50:47 UTC
+@@ -46,4 +46,6 @@
+ 	/* -*- c -*- */
+ 
++	#include <stdint.h>
++	#include <stdlib.h>
+ 	#include <string.h>
+ 	#define SCOPE static
+@@ -733,8 +735,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -897,5 +899,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -987,5 +989,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -1012,5 +1014,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -1020,5 +1022,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1170,10 +1172,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-critcl/11_epsilon	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-critcl/11_epsilon	2015-05-27 22:50:47 UTC
+@@ -46,4 +46,6 @@
+ 	/* -*- c -*- */
+ 
++	#include <stdint.h>
++	#include <stdlib.h>
+ 	#include <string.h>
+ 	#define SCOPE static
+@@ -733,8 +735,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -897,5 +899,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -987,5 +989,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -1012,5 +1014,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -1020,5 +1022,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1170,10 +1172,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/pt_cparam_config_tea.tcl	2015-04-30 04:21:20 UTC
++++ modules/pt/pt_cparam_config_tea.tcl	2015-05-28 00:27:17 UTC
+@@ -95,4 +95,5 @@ proc ::pt::cparam::configuration::tea::d
+ 		#include <string.h>
+ 		#include <tcl.h>
++		#include <stdint.h>
+ 		#include <stdlib.h>
+ 		#include <ctype.h>
+--- modules/pt/tests/data/ok/peg_cparam-tea/0_basic_arithmetic	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-tea/0_basic_arithmetic	2015-05-28 00:08:47 UTC
+@@ -12,4 +12,5 @@
+ 	#include <string.h>
+ 	#include <tcl.h>
++	#include <stdint.h>
+ 	#include <stdlib.h>
+ 	#include <ctype.h>
+@@ -700,8 +700,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -864,5 +864,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -954,5 +954,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -979,5 +979,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -987,5 +987,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1137,10 +1137,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-tea/1_functions	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-tea/1_functions	2015-05-28 00:09:06 UTC
+@@ -12,4 +12,5 @@
+ 	#include <string.h>
+ 	#include <tcl.h>
++	#include <stdint.h>
+ 	#include <stdlib.h>
+ 	#include <ctype.h>
+@@ -700,8 +700,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -864,5 +864,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -954,5 +954,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -979,5 +979,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -987,5 +987,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1137,10 +1137,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-tea/2_fun_arithmetic	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-tea/2_fun_arithmetic	2015-05-28 00:09:06 UTC
+@@ -12,4 +12,5 @@
+ 	#include <string.h>
+ 	#include <tcl.h>
++	#include <stdint.h>
+ 	#include <stdlib.h>
+ 	#include <ctype.h>
+@@ -700,8 +700,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -864,5 +864,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -954,5 +954,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -979,5 +979,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -987,5 +987,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1137,10 +1137,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-tea/3_peg_itself	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-tea/3_peg_itself	2015-05-28 00:09:08 UTC
+@@ -12,4 +12,5 @@
+ 	#include <string.h>
+ 	#include <tcl.h>
++	#include <stdint.h>
+ 	#include <stdlib.h>
+ 	#include <ctype.h>
+@@ -700,8 +700,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -864,5 +864,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -954,5 +954,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -979,5 +979,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -987,5 +987,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1137,10 +1137,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-tea/4_choice	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-tea/4_choice	2015-05-28 00:09:09 UTC
+@@ -12,4 +12,5 @@
+ 	#include <string.h>
+ 	#include <tcl.h>
++	#include <stdint.h>
+ 	#include <stdlib.h>
+ 	#include <ctype.h>
+@@ -700,8 +700,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -864,5 +864,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -954,5 +954,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -979,5 +979,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -987,5 +987,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1137,10 +1137,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-tea/5_sequence	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-tea/5_sequence	2015-05-28 00:09:10 UTC
+@@ -12,4 +12,5 @@
+ 	#include <string.h>
+ 	#include <tcl.h>
++	#include <stdint.h>
+ 	#include <stdlib.h>
+ 	#include <ctype.h>
+@@ -700,8 +700,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -864,5 +864,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -954,5 +954,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -979,5 +979,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -987,5 +987,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1137,10 +1137,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-tea/6_optional	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-tea/6_optional	2015-05-28 00:09:10 UTC
+@@ -12,4 +12,5 @@
+ 	#include <string.h>
+ 	#include <tcl.h>
++	#include <stdint.h>
+ 	#include <stdlib.h>
+ 	#include <ctype.h>
+@@ -700,8 +700,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -864,5 +864,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -954,5 +954,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -979,5 +979,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -987,5 +987,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1137,10 +1137,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-tea/7_kleene	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-tea/7_kleene	2015-05-28 00:09:10 UTC
+@@ -12,4 +12,5 @@
+ 	#include <string.h>
+ 	#include <tcl.h>
++	#include <stdint.h>
+ 	#include <stdlib.h>
+ 	#include <ctype.h>
+@@ -700,8 +700,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -864,5 +864,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -954,5 +954,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -979,5 +979,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -987,5 +987,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1137,10 +1137,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-tea/8_pkleene	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-tea/8_pkleene	2015-05-28 00:09:10 UTC
+@@ -12,4 +12,5 @@
+ 	#include <string.h>
+ 	#include <tcl.h>
++	#include <stdint.h>
+ 	#include <stdlib.h>
+ 	#include <ctype.h>
+@@ -700,8 +700,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -864,5 +864,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -954,5 +954,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -979,5 +979,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -987,5 +987,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1137,10 +1137,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-tea/9_ahead	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-tea/9_ahead	2015-05-28 00:09:10 UTC
+@@ -12,4 +12,5 @@
+ 	#include <string.h>
+ 	#include <tcl.h>
++	#include <stdint.h>
+ 	#include <stdlib.h>
+ 	#include <ctype.h>
+@@ -700,8 +700,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -864,5 +864,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -954,5 +954,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -979,5 +979,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -987,5 +987,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1137,10 +1137,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-tea/10_notahead	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-tea/10_notahead	2015-05-28 00:08:47 UTC
+@@ -12,4 +12,5 @@
+ 	#include <string.h>
+ 	#include <tcl.h>
++	#include <stdint.h>
+ 	#include <stdlib.h>
+ 	#include <ctype.h>
+@@ -700,8 +700,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -864,5 +864,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -954,5 +954,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -979,5 +979,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -987,5 +987,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1137,10 +1137,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void
+--- modules/pt/tests/data/ok/peg_cparam-tea/11_epsilon	2015-04-30 04:21:20 UTC
++++ modules/pt/tests/data/ok/peg_cparam-tea/11_epsilon	2015-05-28 00:09:05 UTC
+@@ -12,4 +12,5 @@
+ 	#include <string.h>
+ 	#include <tcl.h>
++	#include <stdint.h>
+ 	#include <stdlib.h>
+ 	#include <ctype.h>
+@@ -700,8 +700,8 @@
+ 	    rde_stack_get (p->LS, lc, lv);
+ 	}
+-	SCOPE long int
++	SCOPE intptr_t
+ 	rde_param_query_lstop (RDE_PARAM p)
+ 	{
+-	    (long int) rde_stack_top (p->LS);
++	    return (intptr_t) rde_stack_top (p->LS);
+ 	}
+ 	SCOPE Tcl_HashTable*
+@@ -864,5 +864,5 @@
+ 	    p->ER->msg      = rde_stack_new (NULL);
+ 	    ASSERT_BOUNDS(s,p->numstr);
+-	    rde_stack_push (p->ER->msg, (void*) s);
++	    rde_stack_push (p->ER->msg, (void*)(intptr_t)s);
+ 	}
+ 	static void
+@@ -954,5 +954,5 @@
+ 	    if (!hPtr) { return 0; }
+ 	    tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+-	    hPtr = Tcl_FindHashEntry (tablePtr, (char*) s);
++	    hPtr = Tcl_FindHashEntry (tablePtr, (void*)(intptr_t)s);
+ 	    if (!hPtr) { return 0; }
+ 	    
+@@ -979,5 +979,5 @@
+ 	    TRACE (("INT       %d",s));
+ 	    
+-	    hPtr = Tcl_CreateHashEntry (&p->NC, (char*) at, &isnew);
++	    hPtr = Tcl_CreateHashEntry (&p->NC, (void*)(intptr_t)at, &isnew);
+ 	    if (isnew) {
+ 		tablePtr = ALLOC (Tcl_HashTable);
+@@ -987,5 +987,5 @@
+ 		tablePtr = (Tcl_HashTable*) Tcl_GetHashValue (hPtr);
+ 	    }
+-	    hPtr = Tcl_CreateHashEntry (tablePtr, (char*) s, &isnew);
++	    hPtr = Tcl_CreateHashEntry (tablePtr, (void *)(intptr_t)s, &isnew);
+ 	    if (isnew) {
+ 		
+@@ -1137,10 +1137,12 @@
+ 	UniCharIsHexDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isxdigit(character);
++	    return UniCharIsDecDigit(character) ||
++		(character >= 'a' && character <= 'f') ||
++		(character >= 'A' && character <= 'F');
+ 	}
+ 	static int
+ 	UniCharIsDecDigit (int character)
+ 	{
+-	    return (character >= 0) && (character < 0x80) && isdigit(character);
++	    return (character >= '0') && (character <= '9');
+ 	}
+ 	SCOPE void