CleanupHEADmaster

* include/radius/radius.h (grad_avl_fprint): Add missing prototype.
* lib/ascend.c (_get_hex_string): Fix boundary violation.
* lib/raddb.c (continuation_line_p)
(grad_read_raddb_file): Fix arguments to get_argcv.
* radiusd/auth.c: Likewise.
* radiusd/log.c (category_set_flag): Cast to int through intptr_t.
* radiusd/rewrite.y: Use union type to handle stack and code segment
data.
* radtest/gram.y: Minor fix.
* scripts/mktypes.c: Minor change.

8 files changed, 371 insertions, 303 deletions

diff --git a/include/radius/radius.h b/include/radius/radius.h
index 0937c981..f96c065f 100644
--- a/include/radius/radius.h
+++ b/include/radius/radius.h
@@ -1,6 +1,5 @@
 /* This file is part of GNU Radius.
-   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
-   2010, 2013 Free Software Foundation, Inc.
+   Copyright (C) 2000-2017 Free Software Foundation, Inc.
 
    Written by Sergey Poznyakoff
   
@@ -26,6 +25,7 @@
 #include <radius/mem.h>
 #include <radius/dictionary.h>
 #include <stdarg.h>
+#include <stdio.h>
 
 #ifdef HAVE_SYS_TIME_H
 # include <sys/time.h>
@@ -393,6 +393,8 @@ int grad_avp_cmp(grad_avp_t *a, grad_avp_t *b);
 int grad_avl_cmp(grad_avp_t *a, grad_avp_t *b, int prop);
 int grad_avp_null_string_p(grad_avp_t *pair);
 	
+void grad_avl_fprint(FILE *fp, char *prefix, int typeflag, grad_avp_t *avl);
+
 extern int grad_resolve_hostnames;
 
 char *grad_ip_gethostname (grad_uint32_t, char *buf, size_t size);
diff --git a/lib/ascend.c b/lib/ascend.c
index 8839ab41..d50458f0 100644
--- a/lib/ascend.c
+++ b/lib/ascend.c
@@ -1,6 +1,5 @@
 /* This file is part of GNU Radius.
-   Copyright (C) 2002, 2003, 2004, 2005, 2007, 2010, 2013 Free Software
-   Foundation, Inc.
+   Copyright (C) 2002-2017 Free Software Foundation, Inc.
 
    Written by Sergey Poznyakoff
   
@@ -258,7 +257,7 @@ _get_hex_string(struct ascend_parse_buf *pb, u_char *buf)
 		}
 	}
 
-	for (i = 0; i < 2*ASCEND_MAX_CMP_LENGTH; i++)
+	for (i = 0; i < ASCEND_MAX_CMP_LENGTH; i += 2)
 		*buf++ = (tmp[i] << 4) | tmp[i+1];
 	return rc;
 }
diff --git a/lib/raddb.c b/lib/raddb.c
index eff6a28f..5ecf975b 100644
--- a/lib/raddb.c
+++ b/lib/raddb.c
@@ -1,6 +1,5 @@
 /* This file is part of GNU Radius.
-   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2010,
-   2013 Free Software Foundation, Inc.
+   Copyright (C) 2000-2017 Free Software Foundation, Inc.
 
    Written by Sergey Poznyakoff
   
@@ -49,7 +48,7 @@ get_argcv(const char *str, const char *delim, size_t *pargc, char ***pargv)
 static int
 continuation_line_p(const char *str, const char *delim)
 {
-	int argc;
+	size_t argc;
 	char **argv;
 	int rc = get_argcv(str, delim, &argc, &argv) == 0
 		&& argc > 0
@@ -62,7 +61,7 @@ int
 grad_read_raddb_file(char *filename, int vital, char *delim,
 		     int (*fun)(), void *closure)
 {
-        int    argc;
+        size_t argc;
         char **argv;
         grad_locus_t loc;
 	int fd;
diff --git a/radiusd/auth.c b/radiusd/auth.c
index c75a5ac9..2c70579c 100644
--- a/radiusd/auth.c
+++ b/radiusd/auth.c
@@ -1,6 +1,5 @@
 /* This file is part of GNU Radius
-   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2006, 2007, 2008, 2010,
-   2013 Free Software Foundation, Inc.
+   Copyright (C) 2000-2017 Free Software Foundation, Inc.
 
    Written by Sergey Poznyakoff
  
@@ -1060,7 +1059,7 @@ sfn_simuse(AUTH_MACH *m)
 {
         char  name[GRAD_STRING_LENGTH];
         int rc;
-        int count;
+        size_t count;
 	
         strip_username(strip_names,
                        m->namepair->avp_strvalue, m->user_check, name);
diff --git a/radiusd/log.c b/radiusd/log.c
index 0b8a68db..b70437ef 100644
--- a/radiusd/log.c
+++ b/radiusd/log.c
@@ -1,6 +1,5 @@
 /* This file is part of GNU Radius.
-   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2010,
-   2013 Free Software Foundation, Inc.
+   Copyright (C) 2000-2017 Free Software Foundation, Inc.
 
    Written by Sergey Poznyakoff
   
@@ -967,7 +966,7 @@ static int
 category_set_flag(int argc, cfg_value_t *argv, void *block_data,
 		  void *handler_data)
 {
-	int flag = (int) handler_data;
+	int flag = (int) (intptr_t) handler_data;
 	if (argc != 2) {
 		cfg_argc_error(argc < 2);
 		return 0;
@@ -1103,7 +1102,7 @@ static int
 channel_set_flag(int argc, cfg_value_t *argv,
 		 void *block_data, void *handler_data)
 {
-	int flag = (int) handler_data;
+	int flag = (int) (intptr_t) handler_data;
 	if (argc != 2) {
 		cfg_argc_error(argc < 2);
 		return 0;
diff --git a/radiusd/rewrite.y b/radiusd/rewrite.y
index 7b7f6a6e..fe693557 100644
--- a/radiusd/rewrite.y
+++ b/radiusd/rewrite.y
@@ -1,7 +1,6 @@
 %{
 /* This file is part of GNU Radius.
-   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
-   2010, 2013 Free Software Foundation, Inc.
+   Copyright (C) 2000-2017 Free Software Foundation, Inc.
 
    Written by Sergey Poznyakoff
   
@@ -35,7 +34,6 @@
 # include <radius/radscm.h>	
 #endif
         
-typedef long RWSTYPE;
 #define RW_MIN(a,b) ((a)<(b)) ? (a) : (b)
  
 /*
@@ -77,6 +75,31 @@ typedef struct {
 
 typedef int stkoff_t;             /* Offset on stack */
 typedef unsigned int pctr_t;      /* Program counter */
+typedef void (*INSTR)();          /* program instruction */
+ 
+typedef union rw_code_cell {
+	void     *v_ptr;
+	char     *v_str;
+	int      v_int;
+	long     v_long;
+	u_int    v_u_int;
+	stkoff_t v_off;
+	pctr_t   v_pc;
+	struct comp_regex *v_rx;
+	size_t   v_size;
+} RWSTYPE;
+
+#define rw_cat(a,b) a ## b
+#define rw_c_val(x,t) ((x).rw_cat(v_,t))
+#define rw_c_cast(x,t) ((RWSTYPE)(t)(x))
+
+typedef union {
+	INSTR   c_instr;
+	RWSTYPE c_value;
+} RWCODE;
+
+#define rw_code_instr(p) ((p).c_instr)
+#define rw_code_value(p) ((p).c_value)
 
 #define RW_REG ('z'-'a'+1)
 
@@ -100,8 +123,6 @@ typedef struct {
         jmp_buf    jmp;
 } RWMACH;
 
-typedef void (*INSTR)();       /* program instruction */
- 
 /* Compiled regular expression
  */
 typedef struct comp_regex COMP_REGEX;
@@ -639,8 +660,7 @@ static void code_check();
 /*
  * Auxiliary and debugging functions
  */
-static void debug_dump_code();
-static const char * datatype_str_nom(grad_data_type_t type);
+/*static const char * datatype_str_nom(grad_data_type_t type);*/
 static const char * datatype_str_acc(grad_data_type_t type);
 static const char * datatype_str_abl(grad_data_type_t type);
 static grad_data_type_t attr_datatype(grad_dict_attr_t *);
@@ -1894,19 +1914,19 @@ yylex()
                         return c;
                 }
 
-                if (var = var_lookup(yylval.string)) {
+                if ((var = var_lookup(yylval.string))) {
                         DEBUG_LEX2("VARIABLE: %s", yylval.string);
                         yylval.var = var;
                         return VARIABLE;
                 }
                 
-                if (fun = (FUNCTION*) grad_sym_lookup(rewrite_tab, yylval.string)) {
+                if ((fun = (FUNCTION*) grad_sym_lookup(rewrite_tab, yylval.string))) {
                         DEBUG_LEX2("FUN %s", yylval.string);
                         yylval.fun = fun;
                         return FUN;
                 }
 
-                if (btin = builtin_lookup(yylval.string)) {
+                if ((btin = builtin_lookup(yylval.string))) {
                         DEBUG_LEX2("BUILTIN %s", yylval.string);
                         yylval.btin = btin;
                         return BUILTIN;
@@ -2056,7 +2076,7 @@ _list_insert(RWLIST **first, RWLIST **last, RWLIST *prev, RWLIST *obj,
         obj->prev = prev;
         obj->next = prev->next;
         
-        if (next = prev->next)
+        if ((next = prev->next))
                 next->prev = obj;
 
         prev->next = obj;
@@ -2072,12 +2092,12 @@ _list_remove(RWLIST **first, RWLIST **last, RWLIST *obj)
 {
         RWLIST *temp;
 
-        if (temp = obj->prev) 
+        if ((temp = obj->prev) )
                 temp->next = obj->next;
         else
                 *first = obj->next;
 
-        if (temp = obj->next)
+        if ((temp = obj->next))
                 temp->prev = obj->prev;
         else if (last)
                 *last = obj->prev;
@@ -2332,7 +2352,7 @@ mtx_insert(MTX *prev, MTX *mtx)
         MTX *up;
 
         rw_list_insert(&mtx_first, &mtx_last, prev, mtx, 0);
-        if (up = prev->gen.uplink) {
+        if ((up = prev->gen.uplink)) {
                 switch (up->gen.type) {
                 case Unary:
                         up->un.arg = mtx;
@@ -2762,7 +2782,7 @@ mtx_builtin(builtin_t *bin, MTX *args)
         BTIN_MTX     *call;
         int          argn;
         char         *parmp;
-        grad_data_type_t     type;
+        grad_data_type_t     type = Integer;
         /*
          * Test the number and types of arguments. Insert reasonable
          * typecasts.
@@ -2821,7 +2841,7 @@ mtx_builtin(builtin_t *bin, MTX *args)
 /* ****************************************************************************
  * Code optimizer (rudimentary)
  */
-
+#if 0
 const char *
 datatype_str_nom(grad_data_type_t type)
 {
@@ -2836,6 +2856,7 @@ datatype_str_nom(grad_data_type_t type)
                 return _("UNKNOWN");
         }
 }
+#endif
 
 const char *
 datatype_str_abl(grad_data_type_t type)
@@ -3493,7 +3514,7 @@ optimize()
  */
 
 
-static INSTR *rw_code;          /* Code segment */
+static RWCODE *rw_code;         /* Code segment */
 static pctr_t rw_pc;            /* PC when compiling the code */
 static size_t rw_codesize;      /* Length of code segment */ 
 
@@ -3511,7 +3532,7 @@ code_init()
 {
 	code_check();
         /* code cell #0 is the default return address */
-	rw_code[0] = 0;
+	rw_c_val(rw_code_value(rw_code[0]),pc) = 0;
 	rw_pc = 1;
 }
 
@@ -3532,7 +3553,7 @@ debug_dump_code()
         do {
                 fprintf(fp, "%4d:", pc);
                 for (i = 0; i < 8 && pc < rw_codesize; i++, pc++)
-                        fprintf(fp, " %8x", (u_int) rw_code[pc]);
+                        fprintf(fp, " %8x", rw_c_val(rw_code[pc], uint));
                 fprintf(fp, "\n");
         } while (pc < rw_codesize);
         
@@ -3542,14 +3563,17 @@ debug_dump_code()
 /*
  * Runtime function prototypes
  */
-static int pushn(RWSTYPE n);
+static void pushn(RWSTYPE n);
 static int cpopn(RWSTYPE *np);
 static RWSTYPE popn();
 static void checkpop(int cnt);
 static void pushref(char *str, int from, int to);
 static RWSTYPE *heap_reserve(int size);
 static void pushs(RWSTYPE *sptr, size_t size, int len);
-static void pushstr(const char *str, int len);
+static void pushstr(const char *str, size_t len);
+
+static void pushint(int);
+static int popint(void);
 
 static void rw_pushn();
 static void rw_pushs();
@@ -3656,9 +3680,12 @@ INSTR coerce_tab[Max_datatype][Max_datatype] = {
 };
 
 static void check_codesize(int delta);
-static int  code(INSTR instr);
-static int  data(int val);
-static int data_str(char *ptr);
+static pctr_t code_cell(RWCODE cell);
+static pctr_t code_cell(RWCODE cell);
+static pctr_t code_instr(INSTR instr);
+static pctr_t code_value(RWSTYPE val);
+static pctr_t data(int val);
+static pctr_t data_str(char *ptr);
 static void add_target(NOP_MTX *mtx, pctr_t pc);
 
 
@@ -3677,7 +3704,7 @@ fixup_target(NOP_MTX *mtx, pctr_t pc)
         TGT_MTX   *tgt;
         
         for (tgt = (TGT_MTX*)mtx->tgt; tgt; tgt = (TGT_MTX*)tgt->next) 
-                rw_code[tgt->pc] = (INSTR)pc;
+                rw_c_val(rw_code_value(rw_code[tgt->pc]), pc) = pc;
         mtx->tgt = NULL;
 }
 
@@ -3704,21 +3731,21 @@ codegen()
                 case Stop:
                         break;
                 case Enter:
-                        code(rw_enter);
+                        code_instr(rw_enter);
                         data(mtx->frame.stacksize);
                         break;
                 case Leave:
-                        code(rw_leave);
+                        code_instr(rw_leave);
                         break;
                 case Constant:
                         switch (mtx->cnst.datatype) {
                         case Integer:
-                                code(rw_pushn);
+                                code_instr(rw_pushn);
                                 data(mtx->cnst.datum.ival);
                                 break;
 				
                         case String:
-                                code(rw_pushs);
+                                code_instr(rw_pushs);
                                 data_str(mtx->cnst.datum.sval.data);
                                 break;
 
@@ -3727,23 +3754,23 @@ codegen()
                         }
                         break;
                 case Matchref:
-                        code(rw_pushref);
+                        code_instr(rw_pushref);
                         data(mtx->ref.num);
                         break;
                 case Variable:
                         /* Variable dereference.
                          */
-                        code(rw_pushv);
+                        code_instr(rw_pushv);
                         data(mtx->var.var->offset);
                         break;
                 case Unary:
                         switch (mtx->un.opcode) {
                         case Not:
-                                code(rw_not);
+                                code_instr(rw_not);
                                 break;
 				
                         case Neg:
-                                code(rw_neg);
+                                code_instr(rw_neg);
                                 break;
 
 			default:
@@ -3752,90 +3779,90 @@ codegen()
                         break;
                 case Binary:
                         if (mtx->bin.arg[0]->gen.datatype == String)
-                                code(bin_string_codetab[mtx->bin.opcode]);
+                                code_instr(bin_string_codetab[mtx->bin.opcode]);
                         else
-                                code(bin_codetab[mtx->bin.opcode]);
+                                code_instr(bin_codetab[mtx->bin.opcode]);
                         break;
                 case Cond:
                         /*FIXME: this needs optimization */
-                        code(rw_jne);
+                        code_instr(rw_jne);
                         add_target(&mtx->cond.if_true->nop, rw_pc);
-                        code(NULL);
+                        code_instr(NULL);
                         if (mtx->cond.if_false) {
-                                code(rw_jmp);
+                                code_instr(rw_jmp);
                                 add_target(&mtx->cond.if_false->nop, rw_pc);
-                                code(NULL);
+                                code_instr(NULL);
                         }
                         break;
                         
                 case Asgn:
-                        code(rw_asgn);
+                        code_instr(rw_asgn);
                         data(mtx->asgn.lval->offset);
                         break;
                         
                 case Match:
-                        code(rw_match);
-                        code((INSTR)mtx->match.rx);
+                        code_instr(rw_match);
+                        code_value((RWSTYPE)mtx->match.rx);
                         if (mtx->match.negated)
-                                code(rw_not);
+                                code_instr(rw_not);
                         break;
                         
                 case Coercion:
-                        code(coerce_tab[mtx->coerce.arg->gen.datatype][mtx->coerce.datatype]);
+                        code_instr(coerce_tab[mtx->coerce.arg->gen.datatype][mtx->coerce.datatype]);
                         break;
                         
                 case Jump:
-                        code(rw_jmp);
+                        code_instr(rw_jmp);
                         add_target(&mtx->jump.dest->nop, rw_pc);
-                        code(NULL);
+                        code_instr(NULL);
                         break;
 
                 case Branch:
-                        code(mtx->branch.cond ? rw_jne : rw_je);
+                        code_instr(mtx->branch.cond ? rw_jne : rw_je);
                         add_target(&mtx->branch.dest->nop, rw_pc);
-                        code(NULL);
+                        code_instr(NULL);
                         break;
                         
                 case Call:
-                        code(rw_call);
-                        code((INSTR) mtx->call.fun->entry);
-                        code(rw_adjstk);
+                        code_instr(rw_call);
+                        code_value((RWSTYPE) mtx->call.fun->entry);
+                        code_instr(rw_adjstk);
                         data(mtx->call.nargs);
                         break;
 
                 case Builtin:
-                        code(rw_builtin);
-                        code(mtx->btin.fun);
-                        code(rw_adjstk);
+                        code_instr(rw_builtin);
+                        code_instr(mtx->btin.fun);
+                        code_instr(rw_adjstk);
                         data(mtx->btin.nargs);
                         break;
 
                 case Pop:
-                        code(rw_popn);
+                        code_instr(rw_popn);
                         break;
 
                 case Popa:
-                        code(rw_popa);
+                        code_instr(rw_popa);
                         break;
                         
                 case Pusha:
-                        code(rw_pusha);
+                        code_instr(rw_pusha);
                         break;
                         
                 case Attr:
                         switch (mtx->attr.datatype) {
                         case Integer:
 				if (mtx->attr.index)
-					code(rw_attrn);
+					code_instr(rw_attrn);
 				else
-					code(rw_attrn0);
+					code_instr(rw_attrn0);
                                 break;
 				
                         case String:
 				if (mtx->attr.index)
-					code(rw_attrs);
+					code_instr(rw_attrs);
 				else
-					code(rw_attrs0);
+					code_instr(rw_attrs0);
                                 break;
 
 			default:
@@ -3846,25 +3873,25 @@ codegen()
 
                 case Attr_check:
 			if (mtx->attr.index) 
-				code(rw_attrcheck);
+				code_instr(rw_attrcheck);
 			else
-				code(rw_attrcheck0);
+				code_instr(rw_attrcheck0);
                         data(mtx->attr.attrno);
                         break;
                         
                 case Attr_asgn:
 			if (mtx->attr.index)
-				code(rw_attrasgn);
+				code_instr(rw_attrasgn);
 			else
-				code(rw_attrasgn0);
+				code_instr(rw_attrasgn0);
                         data(mtx->attr.attrno);
                         break;
                                 
 		case Attr_delete:
 			if (mtx->attr.index)
-				code(rw_attr_delete);
+				code_instr(rw_attr_delete);
 			else
-				code(rw_attr_delete0);
+				code_instr(rw_attr_delete0);
 			data(mtx->attr.attrno);
 			break;
                 }
@@ -3893,7 +3920,7 @@ void
 check_codesize(int delta)
 {
         if (rw_pc + delta >= rw_codesize) {
-                INSTR *p = grad_emalloc((rw_codesize + 4096) * sizeof(rw_code[0]));
+                RWCODE *p = grad_emalloc((rw_codesize + 4096) * sizeof(rw_code[0]));
                 memcpy(p, rw_code, rw_codesize * sizeof(rw_code[0]));
                 grad_free(rw_code);
                 rw_code = p;
@@ -3901,28 +3928,45 @@ check_codesize(int delta)
         }
 }
 
-int
-code(INSTR instr)
+pctr_t
+code_cell(RWCODE cell)
 {
         check_codesize(1);
-        rw_code[rw_pc] = instr;
+        rw_code[rw_pc] = cell;
         return rw_pc++;
 }
 
-int
+pctr_t
+code_instr(INSTR instr)
+{
+	RWCODE c;
+	rw_code_instr(c) = instr;
+	return code_cell(c);
+}
+
+pctr_t
+code_value(RWSTYPE val)
+{
+	RWCODE c;
+	rw_code_value(c) = val;
+	return code_cell(c);
+}
+
+pctr_t
 data(int val)
 {
-        return code((INSTR)(RWSTYPE)val);
+        return code_value((RWSTYPE)val);
 }
 
-int
+pctr_t
 data_str(char *ptr)
 {
         int  len   = strlen(ptr) + 1;
-        RWSTYPE delta = (len + sizeof(rw_code[0])) / sizeof(rw_code[0]);
+        u_int delta = (len + sizeof(rw_code[0])) / sizeof(rw_code[0]);
         
         check_codesize(delta+1);
-        rw_code[rw_pc++] = (INSTR)delta;
+        rw_c_val(rw_code_value(rw_code[rw_pc]), u_int) = delta;
+	rw_pc++;
         memcpy(rw_code + rw_pc, ptr, len);
         rw_pc += delta;
         return rw_pc;
@@ -4012,7 +4056,7 @@ function_cleanup()
 /*
  * Push a number on stack
  */
-int
+void
 pushn(RWSTYPE n)
 {
         if (mach.st >= mach.ht) {
@@ -4021,7 +4065,6 @@ pushn(RWSTYPE n)
                 rw_error(_("out of pushdown space"));
         }
         mach.stack[mach.st++] = n;
-        return 0;
 }
 
 /*
@@ -4038,19 +4081,19 @@ pushs(RWSTYPE *sptr, size_t size, int len)
 
         while (len)
                 mach.stack[mach.ht--] = sptr[--len];
-	mach.stack[mach.ht--] = size;
-        pushn((RWSTYPE) (mach.stack + mach.ht + 1));
+	rw_c_val(mach.stack[mach.ht--], size) = size;
+        pushn(rw_c_cast(mach.stack + mach.ht + 1, void*));
 }
 
 void
-pushstr(const char *str, int len)
+pushstr(const char *str, size_t len)
 {
         RWSTYPE *p = heap_reserve(sizeof(RWSTYPE) + len + 1);
 	char *s = (char*)(p + 1);
         memcpy(s, str, len);
         s[len] = 0;
-	p[0] = len;
-        pushn((RWSTYPE)p);
+	rw_c_val(p[0], size) = len;
+        pushn(rw_c_cast(p,void*));
 }
 
 #define B2RW(s) (s + sizeof(mach.stack[0]) - 1) / sizeof(mach.stack[0])
@@ -4105,7 +4148,7 @@ temp_space_fix(char *end)
 	len = B2RW(size);
         mach.ht -= len;
 	memmove(mach.stack + mach.ht, base, size);
-	mach.stack[--mach.ht] = strlen(base);
+	rw_c_val(mach.stack[--mach.ht], size) = strlen(base);
         return mach.stack + mach.ht--;
 }
 
@@ -4136,14 +4179,15 @@ popn()
 void
 mem2string(grad_string_t *p, RWSTYPE *loc)
 {
-	p->size = loc[0];
-	p->data = (unsigned char*) (loc + 1);
+	p->size = rw_c_val(loc[0], size);
+	p->data = (char*) (loc + 1);
 }
 
 void
 poparr(grad_string_t *p)
 {
-	mem2string(p, (RWSTYPE*) popn());
+	RWSTYPE v = popn();
+	mem2string(p, (RWSTYPE*) rw_c_val(v, ptr));
 }
 
 RWSTYPE
@@ -4174,13 +4218,26 @@ pushref(char *str, int from, int to)
 	pushstr(str + from, to - from);
 }
 
+static void
+pushint(int v)
+{
+	pushn((RWSTYPE)v);
+}
+
+static int
+popint(void)
+{
+	RWSTYPE t = popn();
+	return rw_c_val(t, int);
+}
+
 /*
  * Create a stack frame and enter the function
  */
 void
 enter(int n)
 {
-        pushn(mach.sb);
+        pushn((RWSTYPE)mach.sb);
         mach.sb = mach.st;
         mach.st += n;
 }
@@ -4195,8 +4252,8 @@ leave()
         mach.rA = popn();
         /* Restore stack frame */
         mach.st = mach.sb;
-        mach.sb = popn();
-        mach.pc = (pctr_t) popn();
+        mach.sb = rw_c_val(popn(), int);
+        mach.pc = rw_c_val(popn(), pc);
 }
 
 RWSTYPE
@@ -4234,15 +4291,16 @@ rw_error_free(char *msg)
 void
 rw_call()
 {
-        pctr_t  pc = (pctr_t) rw_code[mach.pc++];
-        pushn(mach.pc); /* save return address */
+        pctr_t  pc = rw_c_val(rw_code_value(rw_code[mach.pc]), pc);
+        pushn((RWSTYPE)(mach.pc + 1)); /* save return address */
         mach.pc = pc;
 }
 
 void
 rw_adjstk()
 {
-        int delta = (int) rw_code[mach.pc++];
+        u_int delta = rw_c_val(rw_code_value(rw_code[mach.pc]), u_int);
+	mach.pc++;
         mach.st -= delta;
         pushn(mach.rA);   /* Push the return back on stack */
 }
@@ -4251,7 +4309,7 @@ void
 rw_enter()
 {
         /*FIXME: runtime checking */
-        int n = (int) rw_code[mach.pc++];
+        int n = rw_c_val(rw_code_value(rw_code[mach.pc++]), int);
         enter(n);
 }
 
@@ -4267,7 +4325,7 @@ rw_leave()
 void
 rw_pushn()
 {
-        RWSTYPE n = (RWSTYPE) rw_code[mach.pc++];
+        RWSTYPE n = rw_code_value(rw_code[mach.pc++]);
         pushn(n);
 }
 
@@ -4277,8 +4335,8 @@ rw_pushn()
 void
 rw_pushref()
 {
-        int i = (int) rw_code[mach.pc++];
-
+        int i = rw_c_val(rw_code_value(rw_code[mach.pc]), int);
+	mach.pc++;
         pushref(mach.sA, mach.pmatch[i].rm_so, mach.pmatch[i].rm_eo);
 }
 
@@ -4288,15 +4346,15 @@ rw_pushref()
 void
 rw_pushv()
 {
-        stkoff_t n = (stkoff_t) rw_code[mach.pc++];
-
+        stkoff_t n = rw_c_val(rw_code_value(rw_code[mach.pc]), off);
+	mach.pc++;
         pushn(mach.stack[mach.sb + n]);
 }
 
 void
 rw_pushs()
 {
-        int   len = (int) rw_code[mach.pc++];
+        int   len = rw_c_val(rw_code_value(rw_code[mach.pc++]), int);
         RWSTYPE *sptr = (RWSTYPE*) (rw_code + mach.pc);
 
         mach.pc += len;
@@ -4309,7 +4367,7 @@ rw_pushs()
 void
 rw_asgn()
 {
-        stkoff_t off = (stkoff_t) rw_code[mach.pc++];
+        stkoff_t off = rw_c_val(rw_code_value(rw_code[mach.pc++]), off);
         RWSTYPE n;
 
         cpopn(&n);
@@ -4330,19 +4388,21 @@ assert_request_presence()
 void
 rw_attrcheck0()
 {
-        int attr = (int) rw_code[mach.pc++];
+        int attr = rw_c_val(rw_code_value(rw_code[mach.pc++]), int);
 
-	pushn(grad_avl_find(AVPLIST(&mach), attr) != NULL);
+	pushn(rw_c_cast(grad_avl_find(AVPLIST(&mach), attr) != NULL, int));
 }
 
 void
 rw_attrcheck()
 {
-        int attr = (int) rw_code[mach.pc++];
+        int attr = rw_c_val(rw_code_value(rw_code[mach.pc++]), int);
 	RWSTYPE index;
- 
+	int res;
+	
 	cpopn(&index);
-	pushn(grad_avl_find_n(AVPLIST(&mach), attr, index) != NULL);
+	res = grad_avl_find_n(AVPLIST(&mach), attr, rw_c_val(index, int)) != NULL;
+	pushn((RWSTYPE)res);
 }
 
 /*
@@ -4364,7 +4424,7 @@ attrasgn_internal(int attr, grad_avp_t *pair, RWSTYPE val)
 	switch (pair->type) {
 	case GRAD_TYPE_STRING:
 	case GRAD_TYPE_DATE:
-		mem2string(&str, (RWSTYPE*)val);
+		mem2string(&str, (RWSTYPE*)rw_c_val(val, ptr));
 		grad_free(pair->avp_strvalue);
 		pair->avp_strvalue = grad_malloc(str.size+1);
 		memcpy(pair->avp_strvalue, str.data, str.size);
@@ -4374,7 +4434,7 @@ attrasgn_internal(int attr, grad_avp_t *pair, RWSTYPE val)
 		
 	case GRAD_TYPE_INTEGER:
 	case GRAD_TYPE_IPADDR:
-		pair->avp_lvalue = val;
+		pair->avp_lvalue = rw_c_val(val, u_int);
 		break;
 	}
 	
@@ -4384,7 +4444,7 @@ attrasgn_internal(int attr, grad_avp_t *pair, RWSTYPE val)
 void
 rw_attrasgn0()
 {
-        int attr = (int) rw_code[mach.pc++];
+        int attr = rw_c_val(rw_code_value(rw_code[mach.pc++]), int);
         RWSTYPE val;
         
         cpopn(&val);
@@ -4394,20 +4454,22 @@ rw_attrasgn0()
 void
 rw_attrasgn()
 {
-        int attr = (int) rw_code[mach.pc++];
+        int attr = rw_c_val(rw_code_value(rw_code[mach.pc++]), int);
         RWSTYPE val;
 	RWSTYPE index;
  
         cpopn(&val);
 	cpopn(&index);
-	attrasgn_internal(attr, grad_avl_find_n(AVPLIST(&mach), attr, index),
+	attrasgn_internal(attr,
+			  grad_avl_find_n(AVPLIST(&mach), attr,
+					  rw_c_val(index, int)),
 			  val);
 }
 
 void
 rw_attrs0()
 {
-        int attr = (int) rw_code[mach.pc++];
+        int attr = rw_c_val(rw_code_value(rw_code[mach.pc++]), int);
         grad_avp_t *pair;
         
         if ((pair = grad_avl_find(AVPLIST(&mach), attr)) == NULL) 
@@ -4425,24 +4487,25 @@ rw_attrs0()
 void
 rw_attrn0()
 {
-        int attr = (int) rw_code[mach.pc++];
+        int attr = rw_c_val(rw_code_value(rw_code[mach.pc++]), int);
         grad_avp_t *pair;
 
         if ((pair = grad_avl_find(AVPLIST(&mach), attr)) == NULL)
-                pushn(0);
+                pushn(rw_c_cast(0, int));
         else
-                pushn(pair->avp_lvalue);
+                pushn(rw_c_cast(pair->avp_lvalue, u_int));
 }
 
 void
 rw_attrs()
 {
-        int attr = (int) rw_code[mach.pc++];
+        int attr = rw_c_val(rw_code_value(rw_code[mach.pc++]), int);
         grad_avp_t *pair;
 	RWSTYPE index;
 
 	cpopn(&index);
-        if ((pair = grad_avl_find_n(AVPLIST(&mach), attr, index)) == NULL) 
+	pair = grad_avl_find_n(AVPLIST(&mach), attr, rw_c_val(index, int));
+        if (pair == NULL) 
                 pushstr("", 0);
         else
                 pushstr(pair->avp_strvalue, pair->avp_strlength);
@@ -4451,33 +4514,34 @@ rw_attrs()
 void
 rw_attrn()
 {
-        int attr = (int) rw_code[mach.pc++];
+        int attr = rw_c_val(rw_code_value(rw_code[mach.pc++]), int);
         grad_avp_t *pair;
 	RWSTYPE index;
 
 	cpopn(&index);
-        if ((pair = grad_avl_find_n(AVPLIST(&mach), attr, index)) == NULL)
-                pushn(0);
+	pair = grad_avl_find_n(AVPLIST(&mach), attr, rw_c_val(index, int));
+        if (pair == NULL)
+                pushn(rw_c_cast(0, int));
         else
-                pushn(pair->avp_lvalue);
+                pushn(rw_c_cast(pair->avp_lvalue, u_int));
 }
 
 void
 rw_attr_delete0()
 {
-        int attr = (int) rw_code[mach.pc++];
+        int attr = rw_c_val(rw_code_value(rw_code[mach.pc++]), int);
 	grad_avl_delete(&mach.req->avlist, attr);
 }
 
 void
 rw_attr_delete()
 {
-        int attr = (int) rw_code[mach.pc++];
+        int attr = rw_c_val(rw_code_value(rw_code[mach.pc++]), int);
 	RWSTYPE index;
 
 	assert_request_presence();
 	cpopn(&index);
-	grad_avl_delete_n(&mach.req->avlist, attr, index);
+	grad_avl_delete_n(&mach.req->avlist, attr, rw_c_val(index, int));
 }
 
 /*
@@ -4528,8 +4592,8 @@ rw_adds()
 	memcpy(s, s2.data, s2.size);
 	s += s2.size;
 	*s = 0;
-	p[0] = s1.size + s2.size;
-        pushn((RWSTYPE)p);
+	rw_c_val(p[0], size) = s1.size + s2.size;
+        pushn(rw_c_cast(p, void*));
 }
 
 /*
@@ -4539,7 +4603,7 @@ void
 rw_neg()
 {
         checkpop(1);
-        pushn(-popn());
+        pushint(-popint());
 }
 
 /*
@@ -4551,9 +4615,9 @@ rw_b_and()
         int n1, n2;
 
         checkpop(2);
-        n2 = popn();
-        n1 = popn();
-        pushn(n1 & n2);
+        n2 = popint();
+        n1 = popint();
+        pushint(n1 & n2);
 }
 
 void
@@ -4562,9 +4626,9 @@ rw_b_or()
         int n1, n2;
 
         checkpop(2);
-        n2 = popn();
-        n1 = popn();
-        pushn(n1 | n2);
+        n2 = popint();
+        n1 = popint();
+        pushint(n1 | n2);
 }
 
 void
@@ -4573,9 +4637,9 @@ rw_b_xor()
         int n1, n2;
 
         checkpop(2);
-        n2 = popn();
-        n1 = popn();
-        pushn(n1 ^ n2);
+        n2 = popint();
+        n1 = popint();
+        pushint(n1 ^ n2);
 }
 
 void
@@ -4584,9 +4648,9 @@ rw_shl()
         int n1, n2;
 
         checkpop(2);
-        n2 = popn();
-        n1 = popn();
-        pushn(n1 << n2);
+        n2 = popint();
+        n1 = popint();
+        pushint(n1 << n2);
 }
 
 void
@@ -4595,9 +4659,9 @@ rw_shr()
         int n1, n2;
 
         checkpop(2);
-        n2 = popn();
-        n1 = popn();
-        pushn(n1 >> n2);
+        n2 = popint();
+        n1 = popint();
+        pushint(n1 >> n2);
 }
 
 /*
@@ -4609,9 +4673,9 @@ rw_add()
         int n1, n2;
 
         checkpop(2);
-        n2 = popn();
-        n1 = popn();
-        pushn(n1+n2);
+        n2 = popint();
+        n1 = popint();
+        pushint(n1+n2);
 }
 
 /*
@@ -4623,9 +4687,9 @@ rw_sub()
         int n1, n2;
 
         checkpop(2);
-        n2 = popn();
-        n1 = popn();
-        pushn(n1-n2);
+        n2 = popint();
+        n1 = popint();
+        pushint(n1-n2);
 }
 
 /*
@@ -4637,9 +4701,9 @@ rw_mul()
         int n1, n2;
 
         checkpop(2);
-        n2 = popn();
-        n1 = popn();
-        pushn(n1*n2);
+        n2 = popint();
+        n1 = popint();
+        pushint(n1*n2);
 }
 
 /*
@@ -4651,11 +4715,11 @@ rw_div()
         int n1, n2;
 
         checkpop(2);
-        n2 = popn();
-        n1 = popn();
+        n2 = popint();
+        n1 = popint();
         if (n2 == 0) 
                 rw_error(_("division by zero!"));
-        pushn(n1/n2);
+        pushint(n1/n2);
 }
 
 /*
@@ -4667,11 +4731,11 @@ rw_rem()
         int n1, n2;
 
         checkpop(2);
-        n2 = popn();