Index: /trunk/mod_coverager/xc_coverager.c
===================================================================
--- /trunk/mod_coverager/xc_coverager.c	(revision 1151)
+++ /trunk/mod_coverager/xc_coverager.c	(revision 1201)
@@ -40,5 +40,5 @@
 }
 /* }}} */
-static void xcache_mkdirs_ex(char *root, int rootlen, char *path, int pathlen TSRMLS_DC) /* {{{ */
+static void xcache_mkdirs_ex(char *root, long rootlen, char *path, long pathlen TSRMLS_DC) /* {{{ */
 {
 	char *fullpath;
@@ -76,5 +76,5 @@
 	long covlines, *phits;
 	int fd = -1;
-	int size;
+	size_t size;
 	int newfile;
 	struct stat srcstat, outstat;
@@ -277,5 +277,5 @@
 	zstr s;
 	char *outfilename;
-	int dumpdir_len, outfilelen, alloc_len = 0;
+	size_t dumpdir_len, outfilelen, alloc_len = 0;
 	uint size;
 	HashPosition pos;
@@ -334,5 +334,5 @@
 				zend_hash_move_forward_ex(cov, &pos2);
 			}
-			add_assoc_zval_ex(return_value, ZSTR_S(filename), strlen(ZSTR_S(filename)) + 1, lines);
+			add_assoc_zval_ex(return_value, ZSTR_S(filename), (uint) strlen(ZSTR_S(filename)) + 1, lines);
 
 			zend_hash_move_forward_ex(XG(coverages), &pos);
@@ -357,5 +357,5 @@
 static coverager_t xc_coverager_get(const char *filename TSRMLS_DC) /* {{{ */
 {
-	int len = strlen(filename) + 1;
+	uint len = (uint) strlen(filename) + 1;
 	coverager_t cov, *pcov;
 
@@ -473,5 +473,5 @@
 	if (XG(coverages) && XG(coverager_started)) {
 		int size = xc_coverager_get_op_array_size_no_tail(op_array);
-		int oplineno = (*EG(opline_ptr)) - op_array->opcodes;
+		int oplineno = (int) ((*EG(opline_ptr)) - op_array->opcodes);
 		if (oplineno < size) {
 			xc_coverager_add_hits(xc_coverager_get(op_array->filename TSRMLS_CC), (*EG(opline_ptr))->lineno, 1 TSRMLS_CC);
@@ -498,5 +498,5 @@
 
 	p = (long*) str;
-	len -= sizeof(long);
+	len -= (int) sizeof(long);
 	if (len < 0) {
 		return;
@@ -507,5 +507,5 @@
 	}
 
-	for (; len >= (int) sizeof(long) * 2; len -= sizeof(long) * 2, p += 2) {
+	for (; len >= (int) sizeof(long) * 2; len -= (int) sizeof(long) * 2, p += 2) {
 		add_index_long(return_value, p[0], p[1] < 0 ? 0 : p[1]);
 	}
@@ -658,5 +658,5 @@
 
 	if (cfg_get_string("xcache.coveragedump_directory", &xc_coveragedump_dir) == SUCCESS && xc_coveragedump_dir) {
-		int len;
+		size_t len;
 		xc_coveragedump_dir = pestrdup(xc_coveragedump_dir, 1);
 		len = strlen(xc_coveragedump_dir);
Index: /trunk/mod_cacher/xc_cacher.c
===================================================================
--- /trunk/mod_cacher/xc_cacher.c	(revision 1199)
+++ /trunk/mod_cacher/xc_cacher.c	(revision 1201)
@@ -411,5 +411,5 @@
 	time_t n = XG(request_time) / interval;
 	if (*curtime != n) {
-		zend_uint target_slot = n % count;
+		zend_uint target_slot = ((zend_uint) n) % count;
 		zend_uint slot;
 		for (slot = advance_wrapped(*curslot, count);
@@ -449,5 +449,5 @@
 {
 	xc_entry_t *p, **pp;
-	int i, c;
+	size_t i, c;
 
 	for (i = 0, c = cache->hentry->size; i < c; i ++) {
@@ -517,5 +517,5 @@
 static void xc_gc_expires_var(TSRMLS_D) /* {{{ */
 {
-	int i, c;
+	size_t i, c;
 
 	if (!xc_var_gc_interval || !xc_var_caches) {
@@ -736,5 +736,5 @@
 {
 	zval* list;
-	int i, c;
+	size_t i, c;
 	xc_entry_t *e;
 
@@ -934,5 +934,5 @@
 	char *tokbuf;
 	size_t path_buffer_len;
-	int size;
+	size_t size;
 	char tokens[] = { DEFAULT_DIR_SEPARATOR, '\0' };
 	int ret;
@@ -969,5 +969,5 @@
 	if (zend_is_executing(TSRMLS_C)) {
 		const char *executing_filename = zend_get_executed_filename(TSRMLS_C);
-		int dirname_len = strlen(executing_filename);
+		int dirname_len = (int) strlen(executing_filename);
 		size_t filename_len = strlen(filepath);
 
@@ -1066,5 +1066,5 @@
 
 	compiler->new_entry.entry.name.str.val = xc_expand_url(filepath, compiler->opened_path_buffer TSRMLS_CC);
-	compiler->new_entry.entry.name.str.len = strlen(compiler->new_entry.entry.name.str.val);
+	compiler->new_entry.entry.name.str.len = (int) strlen(compiler->new_entry.entry.name.str.val);
 
 	*entry_checker_data->stored_entry = (xc_entry_php_t *) xc_entry_find_unlocked(
@@ -1144,5 +1144,5 @@
 	else {
 #ifdef ZEND_ENGINE_2_3
-		char *opened_path = php_resolve_path(compiler->filename, compiler->filename_len, PG(include_path) TSRMLS_CC);
+		char *opened_path = php_resolve_path(compiler->filename, (int) compiler->filename_len, PG(include_path) TSRMLS_CC);
 		if (opened_path) {
 			strcpy(compiler->opened_path_buffer, opened_path);
@@ -1182,5 +1182,5 @@
 
 		delta = XG(request_time) - buf.st_mtime;
-		if (abs(delta) < 2 && !xc_test) {
+		if (abs((int) delta) < 2 && !xc_test) {
 			return FAILURE;
 		}
@@ -1214,5 +1214,5 @@
 			++basename_begin;
 
-			basename_hash_value = HASH_STR_L(basename_begin, filename_end - basename_begin);
+			basename_hash_value = HASH_STR_L(basename_begin, (uint) (filename_end - basename_begin));
 		}
 
@@ -1254,5 +1254,5 @@
 
 	PHP_MD5Init(&context);
-	while ((n = php_stream_read(stream, (char *) buf, sizeof(buf))) > 0) {
+	while ((n = php_stream_read(stream, (char *) buf, (int) sizeof(buf))) > 0) {
 		PHP_MD5Update(&context, buf, n);
 	}
Index: /trunk/mod_cacher/xc_cache.h
===================================================================
--- /trunk/mod_cacher/xc_cache.h	(revision 1188)
+++ /trunk/mod_cacher/xc_cache.h	(revision 1201)
@@ -155,10 +155,10 @@
 	time_t file_mtime;
 	size_t file_size;
-	int file_device;
-	int file_inode;
-
-	int    filepath_len;
+	size_t file_device;
+	size_t file_inode;
+
+	size_t filepath_len;
 	ZEND_24(NOTHING, const) char *filepath;
-	int    dirpath_len;
+	size_t dirpath_len;
 	char  *dirpath;
 #ifdef IS_UNICODE
Index: /trunk/xcache.c
===================================================================
--- /trunk/xcache.c	(revision 1182)
+++ /trunk/xcache.c	(revision 1201)
@@ -248,5 +248,5 @@
 		if (name) {
 			/* RETURN_STRING */
-			int len = strlen(name);
+			int len = (int) strlen(name);
 			return_value->value.str.len = len;
 			return_value->value.str.val = estrndup(name, len);
@@ -754,5 +754,5 @@
 		char *env;
 		if ((env = getenv("XCACHE_TEST")) != NULL) {
-			xc_test = atoi(env);
+			xc_test = (zend_bool) atoi(env);
 		}
 	}
Index: /trunk/processor/hashtable.m4
===================================================================
--- /trunk/processor/hashtable.m4	(revision 932)
+++ /trunk/processor/hashtable.m4	(revision 1201)
@@ -72,5 +72,5 @@
 		dnl only used for copy
 		IFCOPY(`uint n;')
-		IFCALCCOPY(`int bucketsize;')
+		IFCALCCOPY(`size_t bucketsize;')
 
 #if defined(HARDENING_PATCH_HASH_PROTECT) && HARDENING_PATCH_HASH_PROTECT
Index: /trunk/processor/processor.m4
===================================================================
--- /trunk/processor/processor.m4	(revision 1196)
+++ /trunk/processor/processor.m4	(revision 1201)
@@ -1178,10 +1178,10 @@
 	PROCESS(time_t, file_mtime)
 	PROCESS(size_t, file_size)
-	PROCESS(int, file_device)
-	PROCESS(int, file_inode)
-
-	PROCESS(int, filepath_len)
+	PROCESS(size_t, file_device)
+	PROCESS(size_t, file_inode)
+
+	PROCESS(size_t, filepath_len)
 	IFRESTORE(`COPY(filepath)', `PROC_STRING_L(filepath, filepath_len)')
-	PROCESS(int, dirpath_len)
+	PROCESS(size_t, dirpath_len)
 	IFRESTORE(`COPY(dirpath)', `PROC_STRING_L(dirpath, dirpath_len)')
 #ifdef IS_UNICODE
Index: /trunk/processor/head.m4
===================================================================
--- /trunk/processor/head.m4	(revision 1135)
+++ /trunk/processor/head.m4	(revision 1201)
@@ -89,5 +89,5 @@
 struct _xc_processor_t {
 	char *p;
-	zend_uint size;
+	size_t size;
 	HashTable strings;
 	HashTable zvalptrs;
@@ -159,5 +159,5 @@
 #endif
 /* {{{ xc_zstrlen_char */
-static inline int xc_zstrlen_char(const_zstr s)
+static inline size_t xc_zstrlen_char(const_zstr s)
 {
 	return strlen(ZSTR_S(s));
@@ -166,5 +166,5 @@
 #ifdef IS_UNICODE
 /* {{{ xc_zstrlen_uchar */
-static inline int xc_zstrlen_uchar(zstr s)
+static inline size_t xc_zstrlen_uchar(zstr s)
 {
 	return u_strlen(ZSTR_U(s));
@@ -172,5 +172,5 @@
 /* }}} */
 /* {{{ xc_zstrlen */
-static inline int xc_zstrlen(int type, const_zstr s)
+static inline size_t xc_zstrlen(int type, const_zstr s)
 {
 	return type == IS_UNICODE ? xc_zstrlen_uchar(s) : xc_zstrlen_char(s);
@@ -192,5 +192,5 @@
 static inline void xc_calc_string_n(xc_processor_t *processor, zend_uchar type, const_zstr str, long size IFAUTOCHECK(`, int relayline')) {
 	pushdef(`__LINE__', `relayline')
-	int realsize = UNISW(size, (type == IS_UNICODE) ? UBYTES(size) : size);
+	size_t realsize = UNISW(size, (type == IS_UNICODE) ? UBYTES(size) : size);
 	long dummy = 1;
 
@@ -198,5 +198,5 @@
 		ALLOC(, char, realsize)
 	}
-	else if (zend_u_hash_add(&processor->strings, type, str, size, (void *) &dummy, sizeof(dummy), NULL) == SUCCESS) {
+	else if (zend_u_hash_add(&processor->strings, type, str, (uint) size, (void *) &dummy, sizeof(dummy), NULL) == SUCCESS) {
 		/* new string */
 		ALLOC(, char, realsize)
@@ -214,5 +214,5 @@
 static inline zstr xc_store_string_n(xc_processor_t *processor, zend_uchar type, const_zstr str, long size IFAUTOCHECK(`, int relayline')) {
 	pushdef(`__LINE__', `relayline')
-	int realsize = UNISW(size, (type == IS_UNICODE) ? UBYTES(size) : size);
+	size_t realsize = UNISW(size, (type == IS_UNICODE) ? UBYTES(size) : size);
 	zstr ret, *pret;
 
@@ -223,5 +223,5 @@
 	}
 
-	if (zend_u_hash_find(&processor->strings, type, str, size, (void **) &pret) == SUCCESS) {
+	if (zend_u_hash_find(&processor->strings, type, str, (uint) size, (void **) &pret) == SUCCESS) {
 		return *pret;
 	}
@@ -230,5 +230,5 @@
 	ALLOC(ZSTR_V(ret), char, realsize)
 	memcpy(ZSTR_V(ret), ZSTR_V(str), realsize);
-	zend_u_hash_add(&processor->strings, type, str, size, (void *) &ret, sizeof(zstr), NULL);
+	zend_u_hash_add(&processor->strings, type, str, (uint) size, (void *) &ret, sizeof(zstr), NULL);
 	return ret;
 
@@ -239,6 +239,6 @@
  * return class_index + 1
  */
-static zend_ulong xc_get_class_num(xc_processor_t *processor, zend_class_entry *ce) {
-	zend_ulong i;
+static zend_uint xc_get_class_num(xc_processor_t *processor, zend_class_entry *ce) {
+	zend_uint i;
 	const xc_entry_data_php_t *php = processor->php_src;
 	zend_class_entry *ceptr;
@@ -357,13 +357,13 @@
 /* {{{ field name checker */
 IFAUTOCHECK(`dnl
-static int xc_check_names(const char *file, int line, const char *functionName, const char **assert_names, int assert_names_count, HashTable *done_names)
+static int xc_check_names(const char *file, int line, const char *functionName, const char **assert_names, size_t assert_names_count, HashTable *done_names)
 {
 	int errors = 0;
 	if (assert_names_count) {
-		int i;
+		size_t i;
 		Bucket *b;
 
 		for (i = 0; i < assert_names_count; ++i) {
-			if (!zend_u_hash_exists(done_names, IS_STRING, assert_names[i], strlen(assert_names[i]) + 1)) {
+			if (!zend_u_hash_exists(done_names, IS_STRING, assert_names[i], (uint) strlen(assert_names[i]) + 1)) {
 				fprintf(stderr
 					, "Error: missing field at %s `#'%d %s`' : %s\n"
Index: /trunk/processor/main.m4
===================================================================
--- /trunk/processor/main.m4	(revision 1132)
+++ /trunk/processor/main.m4	(revision 1201)
@@ -207,5 +207,5 @@
 dnl {{{ DONE_*
 define(`DONE_SIZE', `IFAUTOCHECK(`dnl
-	xc_autocheck_done_size += $1`';
+	xc_autocheck_done_size += (int) $1`';
 	xc_autocheck_done_count ++;
 ')')
Index: /trunk/devel/run
===================================================================
--- /trunk/devel/run	(revision 1193)
+++ /trunk/devel/run	(revision 1201)
@@ -171,5 +171,5 @@
 	phpize --clean \
 	&& phpize \
-	&& CFLAGS="-g -O0 $pedanti -Wno-variadic-macros -Wno-long-long -Wall -Wno-unused-parameter -Wno-unused-function -W -Wshadow -Werror=implicit-function-declaration -std=c89 -D_GNU_SOURCE -D_POSIX_SOURCE -Dinline=" ./configure \
+	&& CFLAGS="-g -O0 $pedantic -Wno-variadic-macros -Wno-long-long -Wall -Wno-unused-parameter -Wno-unused-function -W -Wshadow -Werror=implicit-function-declaration -Wconversion -std=c89 -D_GNU_SOURCE -D_POSIX_SOURCE -Dinline=" ./configure \
 		--enable-xcache-cacher \
 		--enable-xcache-optimizer \