Changeset 201

Timestamp:

04/11/06 17:59:53 (4 years ago)

Author:

bart

Message:

A lot of fixes to silence the compile warnings generated when compiling with the default Fedora compiler options

Location:

eaccelerator/trunk

Files:

• ChangeLog (modified) (1 diff)
• Makefile.in (modified) (1 diff)
• cache.c (modified) (2 diffs)
• content.c (modified) (10 diffs)
• ea_dasm.c (modified) (12 diffs)
• ea_restore.c (modified) (5 diffs)
• ea_store.c (modified) (3 diffs)
• eaccelerator.c (modified) (6 diffs)
• encoder.c (modified) (9 diffs)
• loader.c (modified) (6 diffs)
• mm.c (modified) (3 diffs)
• optimize.c (modified) (7 diffs)

eaccelerator/trunk/ChangeLog

@@ +1 @@
+2006-04-11  Bart Vanbrabant <bart.vanbrabant at zoeloelip.be>
+
+        * A lot of fixes to silence the compile warnings generated when compiling
+          with the default Fedora compiler options
+
 2006-04-11  Bart Vanbrabant <bart.vanbrabant at zoeloelip.be>
 

eaccelerator/trunk/Makefile.in

@@ -3 +3 @@
 LTLIBRARY_SHARED_NAME = eaccelerator.la
 
-EXTRA_CFLAGS = -O2
+EXTRA_CFLAGS = -O2 -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector --param=ssp-buffer-size=4 -m32 -march=i386 -mtune=generic -fasynchronous-unwind-tables
 
 include $(top_srcdir)/build/dynlib.mk

eaccelerator/trunk/cache.c

@@ -279 +279 @@
                 hdr.crc32 = eaccelerator_crc32((const char *) q, q->size);
                 if (write(f, &hdr, sizeof(hdr)) == sizeof(hdr)) {
-                    write(f, q, q->size);
+                    ssize_t result = 0;
+                    result = write(f, q, q->size);
                     EACCELERATOR_FLOCK(f, LOCK_UN);
                     close(f);
@@ -597 +598 @@
     unsigned int i, xlen;
     zval *list;
-    char *xkey;
+    char *xkey = "";
     mm_user_cache_entry *p;
     time_t t = time(0);

eaccelerator/trunk/content.c

@@ -122 +122 @@
 static int eaccelerator_is_not_modified(zval* return_value TSRMLS_DC) {
   char  etag[256];
-  zval  **server_vars, **match;
+  union {
+    zval **v;
+    void *ptr;
+  } server_vars, match;
 
   if (!SG(headers_sent)) {
     sprintf(etag,"ETag: eaccelerator-%u",eaccelerator_crc32(Z_STRVAL_P(return_value),Z_STRLEN_P(return_value)));
     sapi_add_header(etag, strlen(etag), 1);
-    if (zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), (void **) &server_vars) == SUCCESS &&
-        Z_TYPE_PP(server_vars) == IS_ARRAY &&
-        zend_hash_find(Z_ARRVAL_PP(server_vars), "HTTP_IF_NONE_MATCH", sizeof("HTTP_IF_NONE_MATCH"), (void **) &match)==SUCCESS &&
-        Z_TYPE_PP(match) == IS_STRING) {
-      if (strcmp(etag+6,Z_STRVAL_PP(match)) == 0 &&
+    if (zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), &server_vars.ptr) == SUCCESS &&
+        Z_TYPE_PP(server_vars.v) == IS_ARRAY &&
+        zend_hash_find(Z_ARRVAL_PP(server_vars.v), "HTTP_IF_NONE_MATCH", sizeof("HTTP_IF_NONE_MATCH"), &match.ptr)==SUCCESS &&
+        Z_TYPE_PP(match.v) == IS_STRING) {
+      if (strcmp(etag+6,Z_STRVAL_PP(match.v)) == 0 &&
           sapi_add_header("HTTP/1.0 304", sizeof("HTTP/1.0 304") - 1, 1) == SUCCESS &&
           sapi_add_header("Status: 304 Not Modified", sizeof("Status: 304 Not Modified") - 1, 1) == SUCCESS) {
@@ -184 +187 @@
   int   ret = 0;
   zval cache_array;
-  zval **headers;
-  zval **content;
+  union {
+    zval **v;
+    void *ptr;
+  } headers, content;
   if (eaccelerator_get(key, key_len, &cache_array, eaccelerator_content_cache_place TSRMLS_CC)) {
     if (Z_TYPE(cache_array) == IS_ARRAY) {
-      if (zend_hash_find(Z_ARRVAL(cache_array),"content",sizeof("content"),(void**)&content) == SUCCESS &&
-         Z_TYPE_PP(content) == IS_STRING) {
-        if (zend_hash_find(Z_ARRVAL(cache_array),"headers",sizeof("headers"),(void**)&headers) == SUCCESS &&
-           Z_TYPE_PP(headers) == IS_ARRAY) {
-          zend_hash_apply(Z_ARRVAL_PP(headers), (apply_func_t)eaccelerator_send_header TSRMLS_CC);
+      if (zend_hash_find(Z_ARRVAL(cache_array),"content",sizeof("content"),&content.ptr) == SUCCESS &&
+         Z_TYPE_PP(content.v) == IS_STRING) {
+        if (zend_hash_find(Z_ARRVAL(cache_array),"headers",sizeof("headers"),&headers.ptr) == SUCCESS &&
+           Z_TYPE_PP(headers.v) == IS_ARRAY) {
+          zend_hash_apply(Z_ARRVAL_PP(headers.v), (apply_func_t)eaccelerator_send_header TSRMLS_CC);
         }
-        memcpy(return_value,*content, sizeof(zval));
+        memcpy(return_value,*content.v, sizeof(zval));
         zval_copy_ctor(return_value);
         ret = 1;
@@ -205 +210 @@
 
 static void eaccelerator_compress(char* key, int key_len, zval* return_value, time_t ttl TSRMLS_DC) {
-  zval  **server_vars, **encoding;
+  union {
+    zval **v;
+    void *ptr;
+  } server_vars, encoding;
 
   if (EAG(compression_enabled) &&
       EAG(compress_content) &&
       !SG(headers_sent) &&
-      zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), (void **) &server_vars) == SUCCESS &&
-      Z_TYPE_PP(server_vars) == IS_ARRAY &&
-      zend_hash_find(Z_ARRVAL_PP(server_vars), "HTTP_ACCEPT_ENCODING", sizeof("HTTP_ACCEPT_ENCODING"), (void **) &encoding)==SUCCESS &&
-      Z_TYPE_PP(encoding) == IS_STRING &&
+      zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), &server_vars.ptr) == SUCCESS &&
+      Z_TYPE_PP(server_vars.v) == IS_ARRAY &&
+      zend_hash_find(Z_ARRVAL_PP(server_vars.v), "HTTP_ACCEPT_ENCODING", sizeof("HTTP_ACCEPT_ENCODING"), &encoding.ptr)==SUCCESS &&
+      Z_TYPE_PP(encoding.v) == IS_STRING &&
       Z_TYPE_P(return_value) == IS_STRING &&
       Z_STRLEN_P(return_value) >= EACCELERATOR_COMPRESS_MIN) {
@@ -235 +243 @@
     }
 
-    if (strstr(Z_STRVAL_PP(encoding),"x-gzip")) {
+    if (strstr(Z_STRVAL_PP(encoding.v),"x-gzip")) {
       zkey_len = sizeof("gzip_") + key_len - 1;
       zkey = emalloc(zkey_len+1);
@@ -244 +252 @@
       params[0] = return_value;
       gzip = 1;
-    } else if (strstr(Z_STRVAL_PP(encoding),"gzip")) {
+    } else if (strstr(Z_STRVAL_PP(encoding.v),"gzip")) {
       zkey_len = sizeof("gzip_") + key_len - 1;
       zkey = emalloc(zkey_len+1);
@@ -253 +261 @@
       params[0] = return_value;
       gzip = 1;
-    } else if (strstr(Z_STRVAL_PP(encoding),"deflate")) {
+    } else if (strstr(Z_STRVAL_PP(encoding.v),"deflate")) {
       zkey_len = sizeof("deflate_") + key_len - 1;
       zkey = emalloc(zkey_len+1);
@@ -380 +388 @@
   int   key_len;
   long  ttl = 0;
-  zval  **server_vars, **encoding;
+  union {
+    zval **v;
+    void *ptr;
+  } server_vars, encoding;
 
   if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
@@ -395 +406 @@
       EAG(compress_content) &&
       !SG(headers_sent) &&
-      zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), (void **) &server_vars) == SUCCESS &&
-      Z_TYPE_PP(server_vars) == IS_ARRAY &&
-      zend_hash_find(Z_ARRVAL_PP(server_vars), "HTTP_ACCEPT_ENCODING", sizeof("HTTP_ACCEPT_ENCODING"), (void **) &encoding)==SUCCESS &&
-      Z_TYPE_PP(encoding) == IS_STRING) {
+      zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), &server_vars.ptr) == SUCCESS &&
+      Z_TYPE_PP(server_vars.v) == IS_ARRAY &&
+      zend_hash_find(Z_ARRVAL_PP(server_vars.v), "HTTP_ACCEPT_ENCODING", sizeof("HTTP_ACCEPT_ENCODING"), &encoding.ptr)==SUCCESS &&
+      Z_TYPE_PP(encoding.v) == IS_STRING) {
     char* zkey = NULL;
     char* enc = NULL;
     int   zkey_len = 0;
-    if (strstr(Z_STRVAL_PP(encoding),"x-gzip")) {
+    if (strstr(Z_STRVAL_PP(encoding.v),"x-gzip")) {
       zkey_len = sizeof("gzip_") + key_len - 1;
       zkey = emalloc(zkey_len+1);
@@ -408 +419 @@
       memcpy(zkey+sizeof("gzip_")-1,key,key_len+1);
       enc = "Content-Encoding: x-gzip";
-    } else if (strstr(Z_STRVAL_PP(encoding),"gzip")) {
+    } else if (strstr(Z_STRVAL_PP(encoding.v),"gzip")) {
       zkey_len = sizeof("gzip_") + key_len - 1;
       zkey = emalloc(zkey_len+1);
@@ -414 +425 @@
       memcpy(zkey+sizeof("gzip_")-1,key,key_len+1);
       enc = "Content-Encoding: gzip";
-    } else if (strstr(Z_STRVAL_PP(encoding),"deflate")) {
+    } else if (strstr(Z_STRVAL_PP(encoding.v),"deflate")) {
       zkey_len = sizeof("deflate_") + key_len - 1;
       zkey = emalloc(zkey_len+1);

eaccelerator/trunk/ea_dasm.c

@@ -270 +270 @@
                     snprintf(buf, sizeof(buf), "ZEND_ISEMPTY");
                 } else {
-                    snprintf(buf, sizeof(buf), "");
+                                        buf[0] = '\0';
                 }
 #ifdef ZEND_ENGINE_2
@@ -279 +279 @@
                     snprintf(buf, sizeof(buf), "ZEND_ASSIGN_DIM");
                 } else {
-                    snprintf(buf, sizeof(buf), "");
+                                        buf[0] = '\0';
                 }
 #ifndef ZEND_ENGINE_2_1
@@ -288 +288 @@
                     snprintf(buf, sizeof(buf), "ZEND_UNSET_OBJ");
                 } else {
-                    snprintf(buf, sizeof(buf), "");
+                                        buf[0] = '\0';
                 }
 #endif
@@ -295 +295 @@
                 snprintf(buf, sizeof(buf), "%ld", opline->extended_value);
             } else {
-                snprintf(buf, sizeof(buf), "");
+                                buf[0] = '\0';
             }
             add_assoc_string(el, "extended_value", buf, 1);
@@ -315 +315 @@
             } else if ((op->ops & OP1_MASK) == OP1_UCLASS) {
                 if (opline->op1.op_type == IS_UNUSED) {
-                    snprintf(buf, sizeof(buf), "");
+                                        buf[0] = '\0';
                 } else {
                     snprintf(buf, sizeof(buf), "$class%u", VAR_NUM(opline->op1.u.var));
@@ -329 +329 @@
                             goto brk_failed;
                         }
+                                                jmp_to = &op_array->brk_cont_array[offset];
                         offset = jmp_to->parent;
                     } while (--level > 0);
@@ -368 +369 @@
                     snprintf(buf, sizeof(buf), "$var%u", VAR_NUM(opline->op1.u.var));
                 } else if (opline->op1.op_type == IS_UNUSED) {
-                    snprintf(buf, sizeof(buf), "");
+                                        buf[0] = '\0';
                 } else {
                     snprintf(buf, sizeof(buf), "UNKNOWN NODE %d", opline->op1.op_type);
@@ -416 +417 @@
                                         snprintf(buf, sizeof(buf), "ZEND_REQUIRE_ONCE");
                                 } else {
-                    snprintf(buf, sizeof(buf), "");
+                                        buf[0] = '\0';
                                 }
                         } else if ((op->ops & OP2_MASK) == OP2_ARG) {
@@ -426 +427 @@
                                         snprintf(buf, sizeof(buf), "ZEND_ISEMPTY");
                                 } else {
-                                        snprintf(buf, sizeof(buf), "");
+                                        buf[0] = '\0';
                                 }
                         } else {
@@ -437 +438 @@
                                         snprintf(buf, sizeof(buf), "$var%u", VAR_NUM(opline->op2.u.var));
                                 } else if (opline->op2.op_type == IS_UNUSED) {
-                                        snprintf(buf, sizeof(buf), "");
+                                        buf[0] = '\0';
                                 } else {
                                         snprintf(buf, sizeof(buf), "UNKNOWN NODE %d", opline->op2.op_type);
@@ -467 +468 @@
                         }
                                 } else if (opline->result.op_type == IS_UNUSED) {
-                        snprintf(buf, sizeof(buf), "");
+                                                buf[0] = '\0';
                                 } else {
                                         snprintf(buf, sizeof(buf), "UNKNOWN NODE %d", opline->result.op_type);
@@ -486 +487 @@
                                 break;
                         case RES_UNUSED:
-                    snprintf(buf, sizeof(buf), "");
+                                        buf[0] = '\0';
                                 break;
                         default:

eaccelerator/trunk/ea_restore.c

@@ -466 +466 @@
                                                                 eaccelerator_op_array * from TSRMLS_DC)
 {
-        zend_function *function;
+    union {
+        zend_function *v;
+        void *ptr;
+    } function;
 #ifdef ZEND_ENGINE_2
         int fname_len = 0;
@@ -530 +533 @@
          */
         if (from->scope_name != NULL) {
+        union {
+            zend_class_entry *v;
+            void *ptr;
+        } scope;
                 char *from_scope_lc = zend_str_tolower_dup(from->scope_name, from->scope_name_len);
-                if (zend_hash_find (CG(class_table), (void *) from_scope_lc, from->scope_name_len + 1, (void **) &to->scope) != SUCCESS) {
+        scope.v = to->scope;
+                if (zend_hash_find (CG(class_table), (void *) from_scope_lc, from->scope_name_len + 1, &scope.ptr) != SUCCESS) {
                         DBG(ea_debug_pad, (EA_DEBUG TSRMLS_CC));
                         DBG(ea_debug_printf, (EA_DEBUG, "[%d]                   can't find '%s' in class_table. use EAG(class_entry).\n", getpid(), from->scope_name));
@@ -549 +557 @@
                                 DBG(ea_debug_pad, (EA_DEBUG TSRMLS_CC));
                                 DBG(ea_debug_printf, (EA_DEBUG, "[%d]                   checking parent '%s' have '%s'\n", getpid(), p->name, fname_lc));
-                                if (zend_hash_find(&p->function_table, fname_lc, fname_len + 1, (void **) &function) == SUCCESS) {
+                                if (zend_hash_find(&p->function_table, fname_lc, fname_len + 1, &function.ptr) == SUCCESS) {
                                         DBG(ea_debug_pad, (EA_DEBUG TSRMLS_CC));
                                         DBG(ea_debug_printf, (EA_DEBUG, "[%d]                                   '%s' has '%s' of scope '%s'\n", 
-                            getpid(), p->name, fname_lc, function->common.scope->name));
-                                        to->scope = function->common.scope;
+                            getpid(), p->name, fname_lc, function.v->common.scope->name));
+                                        to->scope = function.v->common.scope;
                                         break;
                                 }
@@ -583 +591 @@
                 to->function_name, strlen(to->function_name) + 1,
 #endif
-                                (void **) &function) == SUCCESS && function->type == ZEND_INTERNAL_FUNCTION) {
+                                &function.ptr) == SUCCESS && function.v->type == ZEND_INTERNAL_FUNCTION) {
                         DBG(ea_debug_pad, (EA_DEBUG TSRMLS_CC));
                         DBG(ea_debug_printf, (EA_DEBUG, "[%d]                                       found in function table\n", getpid()));
-                        ((zend_internal_function *) (to))->handler = ((zend_internal_function *) function)->handler;
+                        ((zend_internal_function *) (to))->handler = ((zend_internal_function *) function.v)->handler;
                 } else {
                         /* FIXME. I don't know how to fix handler.
@@ -806 +814 @@
 {
         zend_class_entry *old;
-        zend_function *f = NULL;
 
         DBG(ea_debug_pad, (EA_DEBUG TSRMLS_CC));

eaccelerator/trunk/ea_store.c

@@ -86 +86 @@
 }
 
+
 /* Calculate the size of a point to a class entry */
+/* not used
 static void calc_class_entry_ptr(zend_class_entry ** from TSRMLS_DC)
 {
         calc_class_entry(*from TSRMLS_CC);
 }
+*/
 #endif
 
@@ -781 +784 @@
         zend_class_entry *from = from_ce;
         zend_class_entry *parent = from->parent;
-        zend_property_info *pinfo, *cinfo = NULL;
-        zval **pprop = NULL;
-        zval **cprop = p->pData;
+    union {
+        zend_property_info *v;
+        void *ptr;
+    } pinfo, cinfo;
+    union {
+        zval **v;
+        void *ptr;
+    } pprop, cprop;
         char *mname, *cname = NULL;
 
+    cprop.v = p->pData;
         /* Check if this is a parent class. If so, copy unconditionally */
         if (parent) {
@@ -792 +801 @@
         
                 /* lookup the member's info in parent and child */
-                if((zend_hash_find(&parent->properties_info, mname, strlen(mname)+1, (void**)&pinfo) == SUCCESS) &&
-                        (zend_hash_find(&from->properties_info, mname, strlen(mname)+1, (void**)&cinfo) == SUCCESS)) {
+                if((zend_hash_find(&parent->properties_info, mname, strlen(mname)+1, &pinfo.ptr) == SUCCESS) &&
+                        (zend_hash_find(&from->properties_info, mname, strlen(mname)+1, &cinfo.ptr) == SUCCESS)) {
                         /* don't copy this static property if protected in parent and static public in child.
                            inheritance will handle this properly on restore */
-                        if(cinfo->flags & ZEND_ACC_STATIC && (pinfo->flags & ZEND_ACC_PROTECTED && cinfo->flags & ZEND_ACC_PUBLIC)) {
+                        if(cinfo.v->flags & ZEND_ACC_STATIC && (pinfo.v->flags & ZEND_ACC_PROTECTED && cinfo.v->flags & ZEND_ACC_PUBLIC)) {
                                 return ZEND_HASH_APPLY_REMOVE;
                         }
                         /* If the static member points to the same value in parent and child, remove for proper inheritance during restore */
 #  ifdef ZEND_ENGINE_2_1
-                        if(zend_hash_quick_find(&parent->default_static_members, p->arKey, p->nKeyLength, p->h, (void**)&pprop) == SUCCESS) {
+                        if(zend_hash_quick_find(&parent->default_static_members, p->arKey, p->nKeyLength, p->h, &pprop.ptr) == SUCCESS) {
 #  else
-                        if(zend_hash_quick_find(parent->static_members, p->arKey, p->nKeyLength, p->h, (void**)&pprop) == SUCCESS) {
+                        if(zend_hash_quick_find(parent->static_members, p->arKey, p->nKeyLength, p->h, &pprop.ptr) == SUCCESS) {
 #  endif
-                                if(*pprop == *cprop) {
+                                if(*pprop.v == *cprop.v) {
                                         return ZEND_HASH_APPLY_REMOVE;
                                 }

eaccelerator/trunk/eaccelerator.c

@@ -350 +350 @@
 }
 
+/* This function isn't used. So disable it for now
 static void decode_version(char *version, int v) {
   int t = (v & 0x000f00) >> 8;
@@ -364 +365 @@
                                      c,
                                      (v & 0x0000ff));
-}
+} 
+*/
 
 #ifdef EACCELERATOR_USE_INODE
@@ -1034 +1036 @@
 }
 
+#ifndef EACCELERATOR_USE_INODE
 static char* eaccelerator_realpath(const char* name, char* realname TSRMLS_DC) {
 /* ???TODO it is possibe to cache name->realname mapping to avoid lstat() calls */
@@ -1042 +1045 @@
 #endif
 }
+#endif
 
 static int eaccelerator_stat(zend_file_handle *file_handle,
@@ -1227 +1231 @@
   time_t compile_time;
   int stat_result = 0;
+#ifdef DEBUG
   struct timeval tv_start;
+#endif
 
 #ifdef EACCELERATOR_USE_INODE
@@ -2096 +2102 @@
         EAG(hostname)[0] = '\000';
         {
-                zval  **server_vars, **hostname;
-
-                if (zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), (void **) &server_vars) == SUCCESS &&
-                        Z_TYPE_PP(server_vars) == IS_ARRAY &&
-                        zend_hash_find(Z_ARRVAL_PP(server_vars), "SERVER_NAME", sizeof("SERVER_NAME"), (void **) &hostname)==SUCCESS &&
-                        Z_TYPE_PP(hostname) == IS_STRING &&
-                        Z_STRLEN_PP(hostname) > 0)
+        union {
+            zval **v;
+            void *ptr;
+        } server_vars;
+        union {
+            zval **v;
+            void *ptr;
+        } hostname;
+
+                if (zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), &server_vars.ptr) == SUCCESS &&
+                        Z_TYPE_PP(server_vars.v) == IS_ARRAY &&
+                        zend_hash_find(Z_ARRVAL_PP(server_vars.v), "SERVER_NAME", sizeof("SERVER_NAME"), &hostname.ptr)==SUCCESS &&
+                        Z_TYPE_PP(hostname.v) == IS_STRING &&
+                        Z_STRLEN_PP(hostname.v) > 0)
                 {
-                        if (sizeof(EAG(hostname)) > Z_STRLEN_PP(hostname))
+                        if (sizeof(EAG(hostname)) > Z_STRLEN_PP(hostname.v))
                         {
-                                memcpy(EAG(hostname),Z_STRVAL_PP(hostname),Z_STRLEN_PP(hostname)+1);
+                                memcpy(EAG(hostname),Z_STRVAL_PP(hostname.v),Z_STRLEN_PP(hostname.v)+1);
                         }
                         else
                         {
-                                memcpy(EAG(hostname),Z_STRVAL_PP(hostname),sizeof(EAG(hostname))-1);
+                                memcpy(EAG(hostname),Z_STRVAL_PP(hostname.v),sizeof(EAG(hostname))-1);
                                 EAG(hostname)[sizeof(EAG(hostname))-1] = '\000';
                         }

eaccelerator/trunk/encoder.c

@@ -250 +250 @@
       allow = 1;
     } else if (allow && ch == '_') {
+      size_t result = 0;
       label[0] = ch = fgetc(yyin);
       if (ch == EOF) {break;}
       if (ch == '_') {
         label[1] = ch = fgetc(yyin);
-        if (ch == EOF) {fwrite(label,1,1,yyout); break;}
+        if (ch == EOF) {result = fwrite(label,1,1,yyout); break;}
         if (IEQ('f')) {
           label[2] = ch = fgetc(yyin);
-          if (ch == EOF) {fwrite(label,2,1,yyout); break;}
+          if (ch == EOF) {result = fwrite(label,2,1,yyout); break;}
           if (IEQ('i')) {
             label[3] = ch = fgetc(yyin);
-            if (ch == EOF) {fwrite(label,3,1,yyout); break;}
+            if (ch == EOF) {result = fwrite(label,3,1,yyout); break;}
             if (IEQ('l')) {
               label[4] = ch = fgetc(yyin);
-              if (ch == EOF) {fwrite(label,4,1,yyout); break;}
+              if (ch == EOF) {result = fwrite(label,4,1,yyout); break;}
               if (IEQ('e')) {
                 label[5] = ch = fgetc(yyin);
-                if (ch == EOF) {fwrite(label,5,1,yyout); break;}
+                if (ch == EOF) {result = fwrite(label,5,1,yyout); break;}
                 if (ch == '_') {
                   label[6] = ch = fgetc(yyin);
-                  if (ch == EOF) {fwrite(label,6,1,yyout); break;}
+                  if (ch == EOF) {result = fwrite(label,6,1,yyout); break;}
                   if (ch == '_') {
                     ch = fgetc(yyin);
@@ -278 +279 @@
                         (ch >= '\x7f' && ch <= '\xff') ||
                         ch == '_') {
-                      fwrite(label,7,1,yyout);
+                      result = fwrite(label,7,1,yyout);
                     } else {
                       fputs("eaccelerator_loader_file()",yyout);
                     }
                   } else {
-                    fwrite(label,7,1,yyout);
+                    result = fwrite(label,7,1,yyout);
                   }
                 } else {
-                  fwrite(label,6,1,yyout);
+                  result = fwrite(label,6,1,yyout);
                 }
               } else {
-                fwrite(label,5,1,yyout);
+                result = fwrite(label,5,1,yyout);
               }
             } else {
-              fwrite(label,4,1,yyout);
+              result = fwrite(label,4,1,yyout);
             }
           } else {
-            fwrite(label,3,1,yyout);
+            result = fwrite(label,3,1,yyout);
           }
         } else if (IEQ('l')) {
           label[2] = ch = fgetc(yyin);
-          if (ch == EOF) {fwrite(label,2,1,yyout); break;}
+          if (ch == EOF) {result = fwrite(label,2,1,yyout); break;}
           if (IEQ('i')) {
             label[3] = ch = fgetc(yyin);
-            if (ch == EOF) {fwrite(label,3,1,yyout); break;}
+            if (ch == EOF) {result = fwrite(label,3,1,yyout); break;}
             if (IEQ('n')) {
               label[4] = ch = fgetc(yyin);
-              if (ch == EOF) {fwrite(label,4,1,yyout); break;}
+              if (ch == EOF) {result = fwrite(label,4,1,yyout); break;}
               if (IEQ('e')) {
                 label[5] = ch = fgetc(yyin);
-                if (ch == EOF) {fwrite(label,5,1,yyout); break;}
+                if (ch == EOF) {result = fwrite(label,5,1,yyout); break;}
                 if (ch == '_') {
                   label[6] = ch = fgetc(yyin);
-                  if (ch == EOF) {fwrite(label,6,1,yyout); break;}
+                  if (ch == EOF) {result = fwrite(label,6,1,yyout); break;}
                   if (ch == '_') {
                     ch = fgetc(yyin);
@@ -320 +321 @@
                         (ch >= '\x7f' && ch <= '\xff') ||
                         ch == '_') {
-                      fwrite(label,7,1,yyout);
+                      result = fwrite(label,7,1,yyout);
                     } else {
                       fputs("eaccelerator_loader_line()",yyout);
                     }
                   } else {
-                    fwrite(label,7,1,yyout);
+                    result = fwrite(label,7,1,yyout);
                   }
                 } else {
-                  fwrite(label,6,1,yyout);
+                  result = fwrite(label,6,1,yyout);
                 }
               } else {
-                fwrite(label,5,1,yyout);
+                result = fwrite(label,5,1,yyout);
               }
             } else {
-              fwrite(label,4,1,yyout);
+              result = fwrite(label,4,1,yyout);
             }
           } else {
-            fwrite(label,3,1,yyout);
+            result = fwrite(label,3,1,yyout);
           }
         } else {
-          fwrite(label,2,1,yyout);
+          result = fwrite(label,2,1,yyout);
         }
       } else {
-        fwrite(label,1,1,yyout);
+        result = fwrite(label,1,1,yyout);
       }
       allow = 0;
@@ -695 +696 @@
 static void encode_class_entry(zend_class_entry* from);
 
+/* not used 
 static void encode_class_entry_ptr(zend_class_entry** from) {
   encode_class_entry(*from);
 }
+*/
 #endif
 
@@ -719 +722 @@
 }
 
+/* not used 
 #ifdef ZEND_ENGINE_2
 #define encode_zval_hash_ex(from,p) encode_hash_ex(from, p, (encode_bucket_t)encode_zval_ptr)
@@ -745 +749 @@
 }
 #endif
+*/
 
 static void encode_op(zend_op_array* from, zend_op* opline, unsigned int ops) {
@@ -1183 +1188 @@
                                 if (prefix != NULL)
                                 {
+                    size_t result = 0;
                                         prefix->type = IS_STRING;
                                         prefix->value.str.len = pos;
                                         prefix->value.str.val = emalloc(pos+1);
                                         rewind(src_fp);
-                                        fread(prefix->value.str.val, pos, 1, src_fp);
+                                        result = fread(prefix->value.str.val, pos, 1, src_fp);
                                         prefix->value.str.val[prefix->value.str.len] = '\000';
                                 }
@@ -1204 +1210 @@
                                 if (tmp_fp)
                                 {
+                    size_t result = 0;
                                         if (pre_content_len > 0)
                                         {
-                                                fwrite(pre_content, pre_content_len, 1, tmp_fp);
+                        result = fwrite(pre_content, pre_content_len, 1, tmp_fp);
                                         }
 #ifndef WITHOUT_FILE_FILTER
@@ -1220 +1227 @@
                                         if (post_content_len > 0)
                                         {
-                                                fwrite(post_content, post_content_len, 1, tmp_fp);
+                                                result = fwrite(post_content, post_content_len, 1, tmp_fp);
                                         }
                                         rewind(tmp_fp);

eaccelerator/trunk/loader.c

@@ -213 +213 @@
 }
 
+#ifndef ZEND_ENGINE_2
 static unsigned char* decode_pstr(char** p, unsigned int* l) {
   unsigned char c = decode(p, l);
@@ -230 +231 @@
   }
 }
+#endif
 
 static double decode_double(char** p, unsigned int* l) {
@@ -251 +253 @@
 
 #define decode_zval_hash(to, p, l) decode_hash(to, sizeof(zval*), (decode_bucket_t)decode_zval_ptr, p, l TSRMLS_CC)
-#define decode_zval_hash_noref(to, p, l) decode_hash(to, sizeof(zval*), (decode_bucket_t)decode_zval_ptr_noref, p, l TSRMLS_CC)
 
 static HashTable* decode_hash(HashTable* to, int size, decode_bucket_t decode_bucket, char**p, unsigned int* l TSRMLS_DC);
@@ -316 +317 @@
 }
 
+#ifndef ZEND_ENGINE_2
+#define decode_zval_hash_noref(to, p, l) decode_hash(to, sizeof(zval*), (decode_bucket_t)decode_zval_ptr_noref, p, l TSRMLS_CC)
 static zval* decode_zval_ptr_noref(zval* to, char** p, unsigned int* l TSRMLS_DC) {
   if (to == NULL) {
@@ -325 +328 @@
   return to;
 }
+#endif
 
 static void decode_znode(znode* to, unsigned int vars_count, char** p, unsigned int* l TSRMLS_DC) {
@@ -616 +620 @@
         to->fn_flags         = decode32(p, l);
         scope_name = decode_lstr((unsigned int*)&scope_name_len, p, l);
-        if (to->scope == NULL && scope_name != NULL) {
-                if (zend_hash_find(CG(class_table), (void *)scope_name, 
-                    scope_name_len, (void **)&to->scope) == SUCCESS) {
-                        to->scope = *(zend_class_entry**)to->scope;
-                } else {
-            to->scope = NULL;
-        }
-        }
+    if (to->scope == NULL && scope_name != NULL) {
+      union {
+        zend_class_entry *v;
+        void *ptr;
+      } scope;
+      scope.v = to->scope;
+      if (zend_hash_find(CG(class_table), (void *)scope_name, 
+            scope_name_len, &scope.ptr) == SUCCESS) {
+        to->scope = *(zend_class_entry**)to->scope;
+      } else {
+        to->scope = NULL;
+      }
+    }
 #endif
   if (to->type == ZEND_INTERNAL_FUNCTION) {

eaccelerator/trunk/mm.c

@@ -158 +158 @@
 #undef MM_SHM_CAN_ATTACH
 
+#if defined(MM_SEM_POSIX) || defined(MM_SEM_FCNTL) || defined(MM_SEM_FLOCK) || defined(MM_SEM_WIN32) || defined(MM_SHM_MMAP_POSIX) || defined(MM_SHM_MMAP_FILE)
 static int strxcat(char* dst, const char* src, int size) {
   int dst_len = strlen(dst);
@@ -170 +171 @@
   }
 }
+#endif
 
 #if defined(MM_SEM_SPINLOCK)
@@ -192 +194 @@
 } mm_mutex;
 
+/* not used 
 static int mm_attach_lock(const char* key, mm_mutex* lock) {
   return 1;
 }
+*/
 
 static int mm_init_lock(const char* key, mm_mutex* lock) {

eaccelerator/trunk/optimize.c

@@ -1500 +1500 @@
       (name_len == sizeof("false")-1 && strcmp(name,"false") == 0) ||
       (name_len == sizeof("true")-1 && strcmp(name,"true") == 0)) {
-    zend_constant *c;
+    union {
+      zend_constant *v;
+      void *ptr;
+    } c;
     int retval;
     char *lookup_name = do_alloca(name_len+1);
@@ -1506 +1509 @@
     lookup_name[name_len] = '\0';
 
-    if (zend_hash_find(EG(zend_constants), lookup_name, name_len+1, (void **) &c)==SUCCESS) {
-      *result = c;
+    if (zend_hash_find(EG(zend_constants), lookup_name, name_len+1, &c.ptr)==SUCCESS) {
+      *result = c.v;
       retval=1;
     } else {
       zend_str_tolower(lookup_name, name_len);
 
-      if (zend_hash_find(EG(zend_constants), lookup_name, name_len+1, (void **) &c)==SUCCESS) {
-        if ((c->flags & CONST_CS) && (memcmp(c->name, name, name_len)!=0)) {
+      if (zend_hash_find(EG(zend_constants), lookup_name, name_len+1, &c.ptr)==SUCCESS) {
+        if ((c.v->flags & CONST_CS) && (memcmp(c.v->name, name, name_len)!=0)) {
           retval=0;
         } else {
-          *result = c;
+          *result = c.v;
           retval=1;
         }
@@ -2544 +2547 @@
             IS_DEFINED(op->op1)) {
           zend_op *x = DEFINED_OP(op->op1);
-          if ((x->opcode == ZEND_FETCH_W || x->opcode == ZEND_FETCH_RW) &&
-              x->op1.op_type == IS_CONST &&
-              x->op1.u.constant.type == IS_STRING) {
+          if ((x->opcode == ZEND_FETCH_W || x->opcode == ZEND_FETCH_RW) && 
+              x->op1.op_type == IS_CONST && x->op1.u.constant.type == IS_STRING) {
+            union {
+              zend_op *v;
+              void *ptr;
+            } op_copy;
             char *s = emalloc(x->op1.u.constant.value.str.len+2);
+            op_copy.v = op;
             memcpy(s,x->op1.u.constant.value.str.val,x->op1.u.constant.value.str.len);
             s[x->op1.u.constant.value.str.len] = (char)FETCH_TYPE(x);
             s[x->op1.u.constant.value.str.len+1] = '\0';
-            zend_hash_update(&assigns,
-                             s, x->op1.u.constant.value.str.len+2,
-                             (void**)&op, sizeof(void*), NULL);
+            zend_hash_update(&assigns, s, x->op1.u.constant.value.str.len+2, &op_copy.ptr, 
+                sizeof(void*), NULL);
             efree(s);
           }
         }
-      } else if ((op->opcode == ZEND_FETCH_R ||
-                  op->opcode == ZEND_FETCH_IS) &&
-                 !global[VAR_NUM(op->result.u.var)] &&
-                 op->op1.op_type == IS_CONST &&
-                 op->op1.u.constant.type == IS_STRING) {
-        zend_op *x;
+      } else if ((op->opcode == ZEND_FETCH_R || op->opcode == ZEND_FETCH_IS) && 
+          !global[VAR_NUM(op->result.u.var)] && op->op1.op_type == IS_CONST &&
+          op->op1.u.constant.type == IS_STRING) {
+        union {
+          zend_op *v;
+          void *ptr;
+        } x;
         char *s = emalloc(op->op1.u.constant.value.str.len+2);
         memcpy(s,op->op1.u.constant.value.str.val,op->op1.u.constant.value.str.len);
@@ -2568 +2575 @@
         s[op->op1.u.constant.value.str.len+1] = '\0';
 
-        if (zend_hash_find(&assigns,
-                           s, op->op1.u.constant.value.str.len+2,
-                           (void**)&x) == SUCCESS) {
-          x = *(zend_op**)x;
-/*
-          if (x->opcode == ZEND_ASSIGN && x->op2.op_type == IS_CONST) {
-            zend_printf("possible const propogation in %s:%s (%s,%u:%u)<br>\n",op_array->filename, op_array->function_name, op->op1.u.constant.value.str.val, x-op_array->opcodes, op-op_array->opcodes);
-          }
-*/
-          memcpy(&x->result, &op->result, sizeof(op->result));
-          x->result.u.EA.type = 0;
-          SET_DEFINED(x);
-          zend_hash_del(&assigns,
-                        s, op->op1.u.constant.value.str.len+2);
+        if (zend_hash_find(&assigns, s, op->op1.u.constant.value.str.len+2, 
+              &x.ptr) == SUCCESS) {
+          x.v = *(zend_op**)x.v;
+          memcpy(&x.v->result, &op->result, sizeof(op->result));
+          x.v->result.u.EA.type = 0;
+          SET_DEFINED(x.v);
+          zend_hash_del(&assigns, s, op->op1.u.constant.value.str.len+2);
           STR_FREE(op->op1.u.constant.value.str.val);
           SET_TO_NOP(op);
@@ -2587 +2587 @@
         efree(s);
       } else if (op->opcode == ZEND_FETCH_DIM_R &&
-                 op->extended_value != ZEND_FETCH_ADD_LOCK &&
-                 op->op1.op_type == IS_VAR &&
-                 IS_DEFINED(op->op1)) {
+          op->extended_value != ZEND_FETCH_ADD_LOCK &&
+          op->op1.op_type == IS_VAR &&
+          IS_DEFINED(op->op1)) {
         zend_op *x = DEFINED_OP(op->op1);
         while ((x->opcode == ZEND_ASSIGN_REF ||
@@ -2610 +2610 @@
           x = DEFINED_OP(x->op1);
         }
-        if ((x->opcode == ZEND_FETCH_R ||
-             x->opcode == ZEND_FETCH_W ||
-             x->opcode == ZEND_FETCH_RW) &&
-             x->op1.op_type == IS_CONST &&
-             x->op1.u.constant.type == IS_STRING) {
-          zend_op *y;
+        if ((x->opcode == ZEND_FETCH_R || x->opcode == ZEND_FETCH_W || 
+              x->opcode == ZEND_FETCH_RW) && x->op1.op_type == IS_CONST && 
+            x->op1.u.constant.type == IS_STRING) {
+          union {
+            zend_op *v;
+            void *ptr;
+          } y;
+          union {
+            zend_op *v;
+            void *ptr;
+          } op_copy;
           char *s = emalloc(x->op1.u.constant.value.str.len+2);
+          op_copy.v = op;
           memcpy(s,x->op1.u.constant.value.str.val,x->op1.u.constant.value.str.len);
           s[x->op1.u.constant.value.str.len] = (char)FETCH_TYPE(x);
           s[x->op1.u.constant.value.str.len+1] = '\0';
-          if (zend_hash_find(&fetch_dim,
-                             s, x->op1.u.constant.value.str.len+2,
-                             (void**)&y) == SUCCESS) {
-            y = *(zend_op**)y;
-            y->extended_value = ZEND_FETCH_ADD_LOCK;
-            zend_hash_update(&fetch_dim,
-                             s, x->op1.u.constant.value.str.len+2,
-                             (void**)&op, sizeof(void*), NULL);
+          if (zend_hash_find(&fetch_dim, s, x->op1.u.constant.value.str.len+2, 
+                &y.ptr) == SUCCESS) {
+            y.v = *(zend_op**)y.v;
+            y.v->extended_value = ZEND_FETCH_ADD_LOCK;
+            zend_hash_update(&fetch_dim, s, x->op1.u.constant.value.str.len+2, 
+                &op_copy.ptr, sizeof(void*), NULL);
             SET_UNDEFINED(x->result);
             STR_FREE(x->op1.u.constant.value.str.val);
             SET_TO_NOP(x);
-            memcpy(&op->op1,&y->op1,sizeof(op->op1));
+            memcpy(&op->op1, &y.v->op1, sizeof(op->op1));
           } else {
-            zend_hash_update(&fetch_dim,
-                             s, x->op1.u.constant.value.str.len+2,
-                             (void**)&op, sizeof(void*), NULL);
+            zend_hash_update(&fetch_dim, s, x->op1.u.constant.value.str.len+2, 
+                &op_copy.ptr, sizeof(void*), NULL);
           }
           efree(s);
@@ -3171 +3174 @@
   zend_uint i;
   zend_uint n = 0;
+#ifndef ZEND_ENGINE_2
   int uses_globals = 0;
+#endif
   int* assigned = do_alloca(op_array->T * sizeof(int));
   char* reg_pool = do_alloca(op_array->T * sizeof(char));