This commit was manufactured by cvs2svn to create tag 'php_4_0_4RC4'.

I'm not sure what used to be the behavior - but the new code puts the -f
argument as $argv[0], which is the Right Thing to do IMHO...  Comments
welcome

CODING_STANDARDS

@@ -64,11 +64,11 @@ Exceptions:
 Naming Conventions
 ------------------
 
-[1] Function names for user-level functions should be enclosed with in
+[1] Function names for user functions should be enclosed with in
     the PHP_FUNCTION() macro. They should be in lowercase, with words
     underscore delimited, with care taken to minimize the letter count.
-    Abbreviations should not be used when they greatly decrease the
-    readability of the function name itself.
+    If they are part of a "parent set" of functions, that parent should
+    be included in the user function name.
 
     Good:
     'mcrypt_enc_self_test'
@@ -83,35 +83,17 @@ Naming Conventions
     Bad:
     'hw_GetObjectByQueryCollObj'
     'pg_setclientencoding'
-    'jf_n_s_i'
-    
-    
-[2] If they are part of a "parent set" of functions, that parent should
-    be included in the user function name, and should be clearly related
-    to the parent program or function family. This should be in the form
-    of parent_*.
-    
-    A family of 'foo' functions, for example:
-    Good:
-    'foo_select_bar'
-    'foo_insert_baz'
-    'foo_delete_baz'
 
-    Bad:
-    'fooselect_bar'
-    'fooinsertbaz'
-    'delete_foo_baz'
-
-[3] Function names used by user functions should be prefixed
+[2] Function names used by user functions should be prefixed
     with "_php_", and followed by a word or an underscore-delimited list of
     words, in lowercase letters, that describes the function.  If applicable,
     they should be declared 'static'.
     
-[4] Variable names must be meaningful.  One letter variable names must be
+[3] Variable names must be meaningful.  One letter variable names must be
     avoided, except for places where the variable has no real meaning or
     a trivial meaning (e.g. for (i=0; i<100; i++) ...).
 
-[5] Variable names should be in lowercase;  Use underscores to seperate
+[4] Variable names should be in lowercase;  Use underscores to seperate
     between words.
 
 
@@ -171,10 +153,11 @@ PHP_FUNCTION(abs)
 /* }}} */
 
 The {{{ symbols are the default folding symbols for the folding mode in
-Emacs and vim (set fdm=marker).  Folding is very useful when dealing with 
-large files because you can scroll through the file quickly and just unfold 
-the function you wish to work on.  The }}} at the end of each function marks 
-the end of the fold, and should be on a separate line.
+Emacs.  vim will soon have support for folding as well.  Folding is very
+useful when dealing with large files because you can scroll through the 
+file quickly and just unfold the function you wish to work on.  The }}}
+at the end of each function marks the end of the fold, and should be on
+a separate line.
 
 The "proto" keyword there is just a helper for the doc/genfuncsummary script
 which generates a full function summary.  Having this keyword in front of the
@@ -184,23 +167,8 @@ messing up the function summary.
 Optional arguments are written like this:
 
 /* {{{ proto object imap_header(int stream_id, int msg_no [, int from_length [, int subject_length [, string default_host]]])
-   Returns a header object with the defined parameters. */
 
-And yes, please keep the prototype on a single line, even if that line
-is massive.
-
-New and Experimental Functions
------------------------------------
-To reduce the problems normally associated with the first public
-implementation of a new set of functions, it has been suggested
-that the first implementation include a file labeled 'EXPERIMENTAL'
-in the function directory, and that the functions follow the
-standard prefixing conventions during their initial implementation.
-
-The file labelled 'EXPERIMENTAL' should include the following
-information:
-   Any authoring infomration (known bugs, future directions of the module).
-   Ongoing status notes which may not be appropriate for CVS comments.
+And yes, please keep everything on a single line, even if that line is massive.
 
 Aliases & Legacy Documentation
 -----------------------------------

EXTENSIONS

@@ -109,7 +109,7 @@ STATUS:              Experimental
 SINCE:               4.0.2
 -------------------------------------------------------------------------------
 EXTENSION:           interbase
-PRIMARY MAINTAINER:  Jouni Ahto <jouni.ahto@exdec.fi>
+PRIMARY MAINTAINER:  Jouni Ahto <jah@mork.net>
 MAINTENANCE:         Odd Fixes
 STATUS:              Working
 -------------------------------------------------------------------------------
@@ -128,7 +128,7 @@ MAINTENANCE:         Unknown
 STATUS:              Working
 -------------------------------------------------------------------------------
 EXTENSION:           pgsql
-PRIMARY MAINTAINER:  Jouni Ahto <jouni.ahto@exdec.fi>
+PRIMARY MAINTAINER:  Jouni Ahto <jah@mork.net>
 MAINTENANCE:         Odd fixes
 STATUS:              Working
 -------------------------------------------------------------------------------
@@ -171,12 +171,6 @@ EXTENSION:           bcmath
 MAINTENANCE:         Unknown
 STATUS:              Unknown
 -------------------------------------------------------------------------------
-EXTENSION:           bz2
-PRIMARY MAINTAINER:  Sterling Hughes <sterling@php.net>
-MAINTENANCE:         Maintained
-STATUS:              Working
-SINCE:               4.0.3
--------------------------------------------------------------------------------
 EXTENSION:           calendar
 MAINTENANCE:         Unknown
 STATUS:              Unknown
@@ -190,15 +184,10 @@ PRIMARY MAINTAINER:  Uwe Steinmann <steinm@php.net>
 MAINTENANCE:         Maintained
 STATUS:              Working
 -------------------------------------------------------------------------------
-EXTENSION:           crack
-MAINTENANCE:         Unknown
-STATUS:              Experimental
-SINCE:               4.0.5
--------------------------------------------------------------------------------
-EXTENSION:           curl
+EXTENSION:           CURL
 PRIMARY MAINTAINER:  Sterling Hughes <sterling@php.net>
 MAINTENANCE:         Maintained
-STATUS:              Working
+STATUS:              Experimental
 SINCE:               4.0.2
 -------------------------------------------------------------------------------
 EXTENSION:           cybercash
@@ -239,11 +228,6 @@ EXTENSION:           gettext
 MAINTENANCE:         Unknown
 STATUS:              Working
 -------------------------------------------------------------------------------
-EXTENSION:           gmp
-MAINTENANCE:         Unknown
-STATUS:              Unknown
-SINCE:               4.0.4
--------------------------------------------------------------------------------
 EXTENSION:           icap
 MAINTENANCE:         Unknown
 STATUS:              Obsolete
@@ -278,18 +262,10 @@ PRIMARY MAINTAINER:  Sascha Schumann <sascha@schumann.cx>
 MAINTENANCE:         Maintained
 STATUS:              Working
 -------------------------------------------------------------------------------
-EXTENSION:           muscat
-PRIMARY MAINTAINER:  Sam Liddicott <sam@ananova.com>
-MAINTENANCE:         Maintained
-STATUS:              Working
-SINCE:               4.0.5
-COMMENT:             Not tested against windows, only core API completed, rest under development
--------------------------------------------------------------------------------
 EXTENSION:           openssl
-PRIMARY MAINTAINER:  Wez Furlong <wez@php.net>
+PRIMARY MAINTAINER:  Stig Venaas <venaas@php.net>
 MAINTENANCE:         Maintained
 STATUS:              Experimental
-SINCE:               4.0.4
 -------------------------------------------------------------------------------
 EXTENSION:           pcre
 PRIMARY MAINTAINER:  Andrei Zmievski <andrei@ispi.net>
@@ -312,24 +288,12 @@ PRIMARY MAINTAINER:  Kristian K
 MAINTENANCE:         Maintained
 STATUS:              Working
 -------------------------------------------------------------------------------
-EXTENSION:           printer
-PRIMARY MAINTAINER:  Daniel Beulshausen <daniel@php4win.de>
-MAINTENANCE:         Maintained
-STATUS:              Working
-SINCE:               4.0.4
-COMMENT:             Only for Win32
--------------------------------------------------------------------------------
 EXTENSION:           pspell
 PRIMARY MAINTAINER:  Vlad Krupin <phpdevel@echospace.com>
 MAINTENANCE:         Unknown
 STATUS:              Unknown
 SINCE:               4.0.2
 -------------------------------------------------------------------------------
-EXTENSION:           qtdom
-MAINTENANCE:         Unknown
-STATUS:              Experimental
-SINCE:               4.0.4
--------------------------------------------------------------------------------
 EXTENSION:           readline
 MAINTENANCE:         Unknown
 STATUS:              Unknown
@@ -339,12 +303,6 @@ PRIMARY MAINTAINER:  Kristian K
 MAINTENANCE:         Maintained
 STATUS:              Working
 -------------------------------------------------------------------------------
-EXTENSION:           sablot
-PRIMARY MAINTAINER:  Sterling Hughes <sterling@php.net>
-MAINTENANCE:         Maintained
-STATUS:              Experimental
-SINCE:               4.0.3
--------------------------------------------------------------------------------
 EXTENSION:           satellite
 PRIMARY MAINTAINER:  David Eriksson <eriksson@php.net>
 MAINTENANCE:         Odd Fixes
@@ -356,12 +314,6 @@ PRIMARY MAINTAINER:  Sascha Schumann <sascha@schumann.cx>
 MAINTENANCE:         Maintained
 STATUS:              Working
 -------------------------------------------------------------------------------
-EXTENSION:           shmop
-PRIMARY MAINTAINER:  Unknown
-MAINTENANCE:         Unknown
-STATUS:              Experimental
-SINCE:               4.0.3
--------------------------------------------------------------------------------
 EXTENSION:           snmp
 PRIMARY MAINTAINER:  Rasmus Lerdorf <rasmus@php.net>
 MAINTENANCE:         Odd Fixes
@@ -369,15 +321,14 @@ STATUS:              Working
 -------------------------------------------------------------------------------
 EXTENSION:           sockets
 PRIMARY MAINTAINER:  Chris Vandomelen <chrisv@b0rked.dhs.org>
-MAINTENANCE:         Maintained
-STATUS:              Experimental
+MAINTENANCE:         Unknown
+STATUS:              Unknown
 SINCE:               4.0.2
 -------------------------------------------------------------------------------
 EXTENSION:           swf
 PRIMARY MAINTAINER:  Sterling Hughes <sterling@php.net>
 MAINTENANCE:         Maintained
-STATUS:              Depreciated (Use the ming swf extension instead)
-COMMENT:             Only for Unix (won't change)
+STATUS:              Unix (won't change)
 -------------------------------------------------------------------------------
 EXTENSION:           sysvsem
 MAINTENANCE:         Unknown
@@ -387,11 +338,6 @@ EXTENSION:           sysvshm
 MAINTENANCE:         Unknown
 STATUS:              Working
 -------------------------------------------------------------------------------
-EXTENSION:           vpopmail
-MAINTENANCE:         Unknown
-STATUS:              Experimental
-SINCE:               4.0.5
--------------------------------------------------------------------------------
 EXTENSION:           wddx
 PRIMARY MAINTAINER:  Andrei Zmievski <andrei@ispi.net>
 MAINTENANCE:         Maintained
@@ -400,7 +346,7 @@ STATUS:              Working
 EXTENSION:           xml
 PRIMARY MAINTAINER:  Thies C. Arntzen <thies@thieso.net>
 MAINTENANCE:         Maintained
-STATUS:              Working
+STATUS:              Unknown
 -------------------------------------------------------------------------------
 EXTENSION:           yaz
 PRIMARY MAINTAINER:  Adam Dickmeiss <adam@indexdata.dk>
@@ -408,19 +354,10 @@ MAINTENANCE:         Maintained
 STATUS:              Unknown
 SINCE:               4.0.1
 -------------------------------------------------------------------------------
-EXTENSION:           yp
-MAINTENANCE:         Unknown
-STATUS:              Unknown
--------------------------------------------------------------------------------
 EXTENSION:           zlib
 PRIMARY MAINTAINER:  Stefan Roehrich <sr@linux.de>
 MAINTENANCE:         Maintained
 STATUS:              Working
 -------------------------------------------------------------------------------
-EXTENSION:           zziplib
-PRIMARY MAINTAINER:  Sterling Hughes <sterling@php.net>
-MAINTENANCE:         Maintained
-STATUS:              Experimental
-SINCE:               4.0.5
--------------------------------------------------------------------------------
+
 # iptc?

FUNCTION_LIST.txt

@@ -0,0 +1,538 @@
+Functions:
+
+Functions marked with 'u' do not work, or may not work correctly under windows.
+
+basic_functions
+	include
+	_include
+	isset
+
+	intval
+	doubleval
+	strval
+	short_tags
+	sleep						
+u	usleep				
+	ksort
+	asort
+	sort
+	count
+	chr
+	ord
+	flush
+	end
+	prev
+	next
+	reset
+	current
+	key
+	gettype
+	settype
+	min
+	max
+
+	addslashes
+	chop
+	pos
+
+	fsockopen
+	getimagesize
+	htmlspecialchars
+	md5
+
+	parse_url
+
+	parse_str
+	phpinfo
+	phpversion
+	strlen
+	strtok
+	strtoupper
+	strtolower
+	strchr
+	basename
+	dirname 
+	stripslashes
+	strstr
+	strrchr
+	substr
+	quotemeta
+	urlencode
+	urldecode
+	ucfirst
+	strtr
+	sprintf
+	printf
+
+	exec
+	system
+	escapeshellcmd
+	passthru
+
+	soundex
+
+	rand
+	srand
+	getrandmax
+	gethostbyaddr
+	gethostbyname
+	explode
+	implode
+	error_reporting
+	clearstatcache
+
+	get_current_user
+	getmyuid
+	getmypid
+u	getmyinode
+	getlastmod
+
+	base64_decode
+	base64_encode
+
+	abs
+	ceil
+	floor
+	sin
+	cos
+	tan
+	asin
+	acos
+	atan
+	pi
+	pow
+	exp
+	log
+	log10
+	sqrt
+	bindec
+	hexdec
+	octdec
+	decbin
+	decoct
+	dechex
+
+	getenv
+	putenv
+
+	time
+	mktime
+	date
+	gmdate
+	getdate
+	checkdate
+	microtime
+	uniqid
+
+u	linkinfo
+u	readlink
+u	symlink
+u	link
+u	unlink
+
+
+bcmath_functions
+	bcadd
+	bcsub
+	bcmul
+	bcdiv
+	bcmod
+	bcpow
+	bcsqrt
+	bcscale
+	bccomp
+
+dir_functions
+	opendir
+	closedir
+	chdir
+	rewinddir
+	readdir
+	dir
+
+dl_functions
+	dl(string module_name);  dynamicly load a module
+
+dns_functions
+	gethostbyaddr
+	gethostbyname
+
+file_functions
+	pclose
+	popen
+	readfile
+	rewind
+	rmdir
+	umask
+	fclose
+	feof
+	fgets
+	fgetss
+	fopen
+	fpassthru
+	fseek
+	ftell
+	fputs
+	mkdir
+	rename
+	copy
+	tempnam
+	file
+
+filestat_functions
+	fileatime
+	filectime
+u	filegroup
+u	fileinode
+	filemtime
+u	fileowner
+	fileperms
+	filesize
+	filetype
+	stat
+u	chown
+u	chgrp
+u	chmod
+	touch
+	file_exists
+	is_executable
+	is_dir
+	is_readable
+	is_writeable
+u	is_link
+
+header_functions
+	setcookie
+	header
+
+mail_functions
+	mail
+
+reg_functions
+	ereg
+	ereg_replace
+	eregi
+	eregi_replace
+	split
+	sql_regcase
+
+syslog_functions (writes to event log on win NT)
+	openlog
+	syslog
+	closelog
+
+The following are optional modules and may or may not be compiled into php, or may be compiled as a loadable module.
+
+odbc_functions (obsolete, use uodbc below)
+	sqlconnect
+	sqldisconnect
+	sqlfetch
+	sqlexecdirect
+	sqlgetdata
+	sqlfree
+	sqlrowcount
+
+uodbc_functions
+    (int) odbc_autocommit($connection_id, $OnOff)
+    (void) odbc_close($connection_id)
+    (void) odbc_close_all(void)
+    (int) odbc_commit($connection_id)
+    (int) odbc_connect($dsn, $user, $password)
+    (int) odbc_pconnect($dsn, $user, $password)
+    (string) odbc_cursor($result_id)
+    (int) odbc_do($connection_id, $query_string)
+    (int) odbc_exec($connection_id, $query_string)
+    (int) odbc_prepare($connection_id, $query_string)
+    (int) odbc_execute($result_id, $array)
+    (int) odbc_fetch_row($result_id, $row_number)
+    (int) odbc_fetch_into($result_id, $row_number, $array_ptr)
+    (int) odbc_field_len($result_id, $field_number)
+    (string) odbc_field_name($result_id, $field_number)
+    (string) odbc_field_type($result_id, $field)
+    (int) odbc_free_result($result_id)
+    (int) odbc_num_fields($result_id)
+    (int) odbc_num_rows($result_id)
+    (string) odbc_result($result_id, $field)
+    (int) odbc_result_all($result_id, $format)
+    (int) odbc_rollback($connection_id)
+
+msql_functions
+	msql_connect
+	msql_pconnect
+	msql_close
+	msql_select_db
+	msql_create_db
+	msql_drop_db
+	msql_query
+	msql
+	msql_list_dbs
+	msql_list_tables
+	msql_list_fields
+	msql_result
+	msql_num_rows
+	msql_num_fields
+	msql_fetch_row
+	msql_fetch_array
+	msql_fetch_object
+	msql_data_seek
+	msql_fetch_field
+	msql_field_seek
+	msql_free_result
+	msql_fieldname
+	msql_fieldtable
+	msql_fieldlen
+	msql_fieldtype
+	msql_fieldflags
+	msql_regcase
+	/* for downwards compatability */
+	msql_selectdb
+	msql_createdb
+	msql_dropdb
+	msql_freeresult
+	msql_numfields
+	msql_numrows
+	msql_listdbs
+	msql_listtables
+	msql_listfields
+	msql_dbname
+	msql_tablename
+
+ldap_functions
+	ldap_connect
+	ldap_bind
+	ldap_unbind
+	ldap_read
+	ldap_list
+	ldap_search
+	ldap_free_result
+	ldap_count_entries
+	ldap_first_entry
+	ldap_next_entry
+	ldap_get_entries
+	ldap_free_entry
+	ldap_first_attribute
+	ldap_next_attribute
+	ldap_get_attributes
+	ldap_get_values
+	ldap_get_dn
+	ldap_dn2ufn
+	ldap_add
+	ldap_delete
+	ldap_modify
+
+gd_functions
+	imagearc
+	imagechar
+	imagecharup
+	imagecolorallocate
+	imagecolorclosest
+	imagecolorexact
+	imagecolortransparent
+	imagecopyresized
+	imagecreate
+	imagecreatefromgif
+	imagedestroy
+	imagefill
+	imagefilledpolygon
+	imagefilledrectangle
+	imagefilltoborder
+	imagegif
+	imageinterlace
+	imageline
+	imagepolygon
+	imagerectangle
+	imagesetpixel
+	imagestring
+	imagestringup
+	imagesx
+	imagesy
+
+filepro_functions
+	filepro
+	filepro_rowcount
+	filepro_fieldname
+	filepro_fieldtype
+	filepro_fieldwidth
+	filepro_fieldcount
+	filepro_retrieve
+
+dbm_functions
+	dblist
+	dbmopen
+	dbmclose
+	dbminsert
+	dbmfetch
+	dbmreplace
+	dbmexists
+	dbmdelete
+	dbmfirstkey
+	dbmnextkey
+
+dbase_functions
+	dbase_open
+	dbase_create
+	dbase_close
+	dbase_numrecords
+	dbase_numfields
+	dbase_add_record
+	dbase_get_record
+	dbase_delete_record
+	dbase_pack
+
+calendar_functions
+	jdtogregorian
+	gregoriantojd
+	jdtojulian
+	juliantojd
+	jdtojewish
+	jewishtojd
+	jdtofrench
+	frenchtojd
+	jddayofweek
+	jdmonthname
+
+adabas_functions
+(int) ada_afetch($result_id, $rownumber, $result array)
+(int) ada_autocommit($connection_id, $OnOff)
+(void) ada_close($connection_id)
+    ada_closeall
+(int) ada_commit($connection_id)
+(int) ada_connect($dsn, $user, $password)
+(int) ada_exec($connection_id, $query_string)
+(int) ada_fetchrow($result_id, $row?number)
+    ada_fieldlen
+(string) ada_fieldname($result_id, $field_number)
+(string) ada_fieldtype($result_id, $field)
+(int) ada_freeresult($result_id)
+(int) ada_numfields($result_id)
+(int) ada_numrows($result_id)
+(string) ada_result($result_id, $field)
+(int) ada_resultall($result_id, $format)
+(int) ada_rollback($connection_id)
+***(int) ada_fieldnum($result_id, $field_name) (this function is not in 	adabase.c
+
+crypt_functions
+	crypt
+
+mysql_functions
+	mysql_connect
+	mysql_pconnect
+	mysql_close
+	mysql_select_db
+	mysql_create_db
+	mysql_drop_db
+	mysql_query
+	mysql
+	mysql_list_dbs
+	mysql_list_tables
+	mysql_list_fields
+	mysql_affected_rows
+	mysql_insert_id
+	mysql_result
+	mysql_num_rows
+	mysql_num_fields
+	mysql_fetch_row
+	mysql_fetch_array
+	mysql_fetch_object
+	mysql_data_seek
+	mysql_fetch_lengths
+	mysql_fetch_field
+	mysql_field_seek
+	mysql_free_result
+	mysql_fieldname
+	mysql_fieldtable
+	mysql_fieldlen
+	mysql_fieldtype
+	mysql_fieldflags
+	/* for downwards compatability */
+	mysql_selectdb
+	mysql_createdb
+	mysql_dropdb
+	mysql_freeresult
+	mysql_numfields
+	mysql_numrows
+	mysql_listdbs
+	mysql_listtables
+	mysql_listfields
+	mysql_dbname
+	mysql_tablename
+
+oracle_functions
+	ora_close
+	ora_commit
+	ora_commitoff
+	ora_commiton
+	ora_error
+	ora_errorcode
+	ora_exec
+	ora_fetch
+	ora_getcolumn
+	ora_logoff
+	ora_logon
+	ora_open
+	ora_parse
+	ora_rollback
+
+pgsql_functions
+	pg_connect
+	pg_pconnect
+	pg_close
+	pg_dbname
+	pg_errormessage
+	pg_options
+	pg_port
+	pg_tty
+	pg_host
+	pg_exec
+	pg_numrows
+	pg_numfields
+	pg_fieldname
+	pg_fieldsize
+	pg_fieldtype
+	pg_fieldnum
+	pg_result
+	pg_fieldprtlen
+	pg_getlastoid
+	pg_freeresult
+	pg_locreate
+	pg_lounlink
+	pg_loopen
+	pg_loclose
+	pg_loread
+	pg_lowrite
+	pg_loreadall
+
+sybase_functions
+	sybase_connect
+	sybase_pconnect
+	sybase_close
+	sybase_select_db
+	sybase_query
+	sybase_free_result
+	sybase_get_last_message
+	sybase_num_rows
+	sybase_num_fields
+	sybase_fetch_row
+	sybase_fetch_array
+	sybase_fetch_object
+	sybase_data_seek
+	sybase_fetch_field
+	sybase_field_seek
+	sybase_result
+
+sybase_old_functions
+	sybsql_seek
+	sybsql_exit
+	sybsql_dbuse
+	sybsql_query
+	sybsql_isrow
+	sybsql_result
+	sybsql_connect
+	sybsql_nextrow
+	sybsql_numrows
+	sybsql_getfield
+	sybsql_numfields
+	sybsql_fieldname
+	sybsql_result_all
+	sybsql_checkconnect
+

INSTALL

@@ -389,7 +389,6 @@ USING PHP 3 AND PHP 4 AS CONCURRENT APACHE MODULES
    - Linux with recent binutils (binutils 2.9.1.0.25 tested)
    - Solaris 2.5 or better
    - FreeBSD (3.2, 4.0 tested)
-   - IRIX64 6.5
    
    To enable it, configure PHP 3 and PHP 4 to use APXS (--with-apxs) and the
    necessary link extensions (--enable-versioning). Otherwise, all standard

Makefile.in

@@ -18,7 +18,7 @@ LTLIBRARY_LIBADD = $(LTLIBRARY_DEPENDENCIES) $(EXTRA_LIBS)
 
 PROGRAM_NAME         = php
 PROGRAM_SOURCES      = stub.c
-PROGRAM_LDADD        = libphp4.la $(EXT_PROGRAM_LDADD)
+PROGRAM_LDADD        = libphp4.la
 PROGRAM_LDFLAGS      = -export-dynamic	
 PROGRAM_DEPENDENCIES = $(PROGRAM_LDADD)
 
@@ -32,7 +32,7 @@ include $(top_srcdir)/build/program.mk
 
 install-sapi:
 	@$(LIBTOOL) --silent --mode=install cp libphp4.la $(phptempdir)/libphp4.la >/dev/null 2>&1
-	-@$(mkinstalldirs) $(INSTALL_ROOT)$(bindir)
+	-@$(mkinstalldirs) $(bindir)
 	-@if test ! -r $(phptempdir)/libphp4.$(SHLIB_SUFFIX_NAME); then \
 		for i in 0.0.0 0.0 0; do \
 			if test -r $(phptempdir)/libphp4.$(SHLIB_SUFFIX_NAME).$$i; then \
@@ -45,18 +45,12 @@ install-sapi:
 
 install-modules:
 	@test -d modules && \
-	$(mkinstalldirs) $(INSTALL_ROOT)$(moduledir) && \
+	$(mkinstalldirs) $(moduledir) && \
 	echo "installing shared modules into $(moduledir)" && \
 	rm -f modules/*.la && \
-	cp modules/* $(INSTALL_ROOT)$(moduledir) >/dev/null 2>&1 || true
+	cp modules/* $(moduledir) >/dev/null 2>&1 || true
 
-install-tester:
-	-$(mkinstalldirs) $(datadir)
-	$(INSTALL) -m 755 $(srcdir)/run-tests.php $(INSTALL_ROOT)$(datadir)
-
-install-pear: install-modules
+install-su: install-modules
 	(cd pear && $(MAKE) install)
 
-install-su: install-pear install-tester
-
 .NOEXPORT:

NEWS

@@ -1,452 +1,7 @@
 PHP 4.0                                                                    NEWS
 |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
-?? ??? 200?, Version 4.1.0
-- Fixed a bug which caused set_time_limit() to affect all requests to an
-  Apache child. (Zeev)
-- Removed the sablotron extension in favor of the new XSLT extension.
-  (Sterling)
-- Fixed a bug in WDDX deserialization that would sometimes corrupt the root
-  element if it was a scalar one. (Andrei)
-- Make ImageColorAt() and ImageColorsForIndex() work with TrueColor images.
-  (Rasmus)
-- Fixed a bug in preg_match_all() that would return results under improper 
-  indices in certain cases. (Andrei)
-- Fixed a crash in str_replace() that would happen if search parameter was an
-  array and one of the replacements resulted in subject string being empty.
-  (Andrei)
-- Fixed MySQL extension to work with MySQL 4.0. (Jani)
-- Fixed a crash bug within Cobalt systems. Patch by tomc@tripac.com. (Jani)
-- Bundled Dan Libby's xmlrpc-epi extension.
-- Introduced extension version numbers. (Stig)
-- Added version_compare() function. (Stig)
-- Fixed pg_last_notice() (could cause random crashes in PostgreSQL
-  applications, even if they didn't use pg_last_notice()). (Zeev)
-- Fixed DOM-XML's error reporting, so E_WARNING errors are given instead of
-  E_ERROR error's, this allows you to trap errors thrown by DOMXML functions.
-  (Sterling)
-- Fixed a bug in the mcrypt extension, where list destructors were not
-  properly being allocated. (Sterling)
-- Better Interbase blob, null and error handling. (Patch by Jeremy Bettis)
-- Fixed a crash bug in array_map() if the input arrays had string or
-  non-sequential keys. Also modified it so that if a single array is passed,
-  its keys are preserved in the resulting array. (Andrei)
-- Fixed a crash in dbase_replace_record. (Patch by robin.marlow@dps-int.com)
-- Fixed a crash in msql_result(). (Zeev)
-- Added support for single dimensional SafeArrays and Enumerations.
-  Added an is_enum() function to check if a component implements an
-  enumeration. (Alan, Harald)
-- Fixed a bug in dbase_get_record() and dbase_get_record_with_names().
-  boolean fields are now returned correctly.
-  Patch by Lawrence E. Widman <widman@cardiothink.com> (Jani)
-- Added --version option to php-config. (Stig)
-- Improved support for thttpd-2.21b by incorporating patches for all known
-  bugs. (Sascha)
-- Added ircg_get_username, a roomkey argument to ircg_join, error fetching
-  infrastructure, a tokenizer to speed up message processing, and fixed
-  a lot of bugs in the IRCG extension. (Sascha)
-- Improved speed of the serializer/deserializer. (Thies, Sascha)
-- Floating point numbers are better detected when converting from strings.
-  (Zeev, Zend Engine)
-- Replaced php.ini-optimized with php.ini-recommended.  As the name implies,
-  it's warmly recommended to use this file as the basis for your PHP
-  configuration, rather than php.ini-dist.  (Zeev)
-- Restore xpath_eval() and php_xpathptr_eval() for 4.0.7. There
-  are still some known leaks. (Joey)
-- Added import_request_variables(), to allow users to safely import form
-  variables to the global scope (Zeev)
-- Introduced a new $_REQUEST array, which includes any GET, POST or COOKIE
-  variables.  Like the other new variables, this variable is also available
-  regardless of the context.  (Andi & Zeev)
-- Introduced $_GET, $_POST, $_COOKIE, $_SERVER and $_ENV variables, which
-  deprecate the old $HTTP_*_VARS arrays.  In addition to be much shorter to
-  type - these variables are also available regardless of the scope, and 
-  there's no need to import them using the 'global' statement.  (Andi & Zeev)
-- Added vprintf() and vsprintf() functions that allow passing all arguments
-  after format as an array. (Andrei)
-- Added support for GD2 image type for ImageCreateFromString() (Jani)
-- Added ImageCreateFromGD(), ImageCreateFromGD2(), ImageCreateFromGD2part(),
-  ImageGD() and ImageGD2() functions (Jani)
-- addcslashes now warns when charlist is invalid. The returned string
-  remained the same (Jeroen)
-- Added optional extra argument to gmp_init(). The extra argument
-  indicates which number base gmp should use when converting a
-  string to the gmp-number. (Troels)
-- Added the Cyrus-IMAP extension, which allows a direct interface to Cyrus' 
-  more advanced capabilities. (Sterling)
-- Enhance read_exif_data() to support multiple comment tags (Rasmus)
-- Fixed a crash bug in array_map() when NULL callback was passed in. (Andrei)
-- Change from E_ERROR to E_WARNING in the exif extension (Rasmus)
-- New pow() implementation, which returns an integer when possible,
-  and warnings on wrong input (jeroen)
-- Added optional second parameter to trim, chop and ltrim. You can
-  now specify which characters to trim (jeroen)
-- Hugely improved the performance of the thread-safe version of PHP, especially
-  under Windows (Andi & Zeev) 
-- Improved request-shutdown performance significantly (Andi & Zeev, Zend
-  Engine)
-- Added a few new math functions. (Jesus)
-- Bump bundled expat to 1.95.2 (Thies)
-- Improved the stability of OCIPlogon() after a database restart. (Thies)
-- Fixed __FILE__ in the CGI & Java servlet modes when used in the main script.
-  It only worked correctly in included files before this fix (Andi)
-- Improved the Zend hash table implementation to be much faster (Andi, Zend
-  Engine)
-- Updated PHP's file open function (used by include()) to check in the calling
-  script's directory in case the file can't be found in the include_path (Andi)
-- Fixed a corruption bug that could cause constants to become corrupted, and
-  possibly prevent resources from properly being cleaned up at the end of
-  a request (Zeev)
-- Added optional use of Boyer-Moore algorithm to str_replace() (Sascha)
-- Fixed and improved shared-memory session storage module (Sascha)
-- Add config option (always_populate_raw_post_data) which when enabled
-  will always populate $HTTP_RAW_POST_DATA regardless of the post mime
-  type (Rasmus)
-- Added support for socket and popen file types to ftp_fput (Jason)
-- Fixed various memory leaks in the LDAP extension (Stig Venaas)
-- Improved interactive mode - it is now available in all builds of PHP, without
-  any significant slowdown (Zeev, Zend Engine)
-- Fixed crash in iptcparse() if the supplied data was bogus. (Thies)
-- Fixed return value for a failed snmpset() - now returns false  (Rasmus)
-- Added hostname:port support to snmp functions (nbougues@axialys.net, Rasmus)
-- Added fdf_set_encoding() function (Masaki YATSU, Rasmus)
-- Reversed the destruction-order of resources.  This fixes the reported OCI8 
-  "failed to rollback outstanding transactions!" message (Thies, Zend Engine)
-- Added option for returning XMLRPC fault packets. (Matt Allen, Sascha
-  Schumann)
-- Improved range() function to support range('a','z') and range(9,0) types of
-  ranges. (Rasmus)
-- Added getmygid() and safe_mode_gid ini directive to allow safe mode to do
-  a gid check instead of a uid check. (James E. Flemer, Rasmus)
-- Made assert() accept the array(&$obj, 'methodname') syntax. (Thies)
-- Made sure that OCI8 outbound variables are always zero-terminated. (Thies)
-- Fixed a bug that allowed users to spawn processes while using the 5th
-  parameter to mail(). (Derick)
-- Added nl_langinfo() (when OS provides it) that returns locale.
-- Fixed a major memory corruption bug in the thread safe version. (Zeev)
-- Fixed a crash when using the CURLOPT_WRITEHEADER option. (Sterling)
-- Added optional suffix removal parameter to basename(). (Hartmut)
-- Added new parameter UDM_PARAM_VARDIR ha in Udm_Set_Agent_Param() function to
-  support alternative search data directory.  This requires mnogoSearch 3.1.13
-  or later.
-- Fixed references in sessions. This doesn't work when using the WDDX
-  session-serializer. Also improved speed of sessions. (Thies)
-- Added new experimental module pcntl (Process Control). (Jason)
-- Fixed a bug when com.allow_dcom is set to false. (phanto)
-- Added a further parameter to the constructor to load typelibs from file when
-  instantiating components (e.g. DCOM Components without local registration).
-  (phanto)
-- Added the possibility to specify typelibs by full name in the typelib file
-  (Alan Brown)
-- Renamed the ZZiplib extension to the Zip extension, function names have also
-  changed accordingly, functionality, has stayed constant. (Sterling)
-- Made the length argument (argument 2) to pg_loread() optional, if not
-  specified data will be read in 1kb chunks. (Sterling)
-- Added a third argument to pg_lowrite() which is the length of the data to
-  write. (Sterling)
-- Added the CONNECTION_ABORTED, CONNECTION_TIMEOUT and CONNECTION_NORMAL
-  constants. (Zak)
-- Assigning to a string offset beyond the end of the string now automatically
-  increases the string length by padding it with spaces, and performs the
-  assignment. (Zeev, Zend Engine)
-- Added warnings in case an uninitialized string offset is read. (Zeev, Zend
-  Engine)
-- Fixed a couple of overflow bugs in case of very large negative integer
-  numbers. (Zeev, Zend Engine)
-- Fixed a crash bug in the string-offsets implementation (Zeev, Zend Engine)
-- Improved the implementation of parent::method_name() for classes which use
-  run-time inheritance. (Zeev, Zend Engine)
-- Added 'W' flag to date() function to return week number of year using ISO
-  8601 standard. (Colin)
-- Made the PostgreSQL driver do internal row counting when iterating through
-  result sets. (gvz@2scale.net)
-- Updated ext/mysql/libmysql to version 3.23.39; Portability fixes, minor
-  bug fixes. (tim@mysql.com)
-- Added get_defined_constants() function to return an associative array of
-  constants mapped to their values. (Sean)
-- New mailparse extension for parsing and manipulating MIME mail. (Wez)
-- Define HAVE_CONFIG_H when building standalone DSO extensions. (Stig)
-- Added the 'u' modifier to printf/sprintf which prints unsigned longs.
-  (Derick)
-- Improved IRIX compatibility. (Sascha)
-- Fixed crash bug in bzopen() when specifying an invalid file. (Andi)
-- Fixed bugs in the mcrypt extension that caused crashes. (Derick)
-- Added the IMG_ARC_ROUNDED option for the ImageFilledArc() function, which
-  specified that the drawn curve should be rounded. (Sterling)
-- Updated the sockets extension to use resources instead of longs for the
-  socket descriptors.  The socket functions have been renamed to conform with
-  the PHP standard instead of their C counterparts.  The sockets extension is 
-  now usable under Win32. (Daniel)
-- Added disk_total_space() to return the total size of a filesystem.
-  (Patch from Steven Bower)
-- Renamed diskfreespace() to disk_free_space() to conform to established
-  naming conventions. (Jon)
-- Fixed #2181. Now zero is returned instead of an unset value for
-  7-bit encoding and plain text body type. (Vlad)
-- Fixed a bug in call_user_*() functions that would not allow calling
-  functions/methods that accepted parameters by reference. (Andrei)
-- Added com_release($obj) and com_addref($obj) functions and the related class
-  members $obj->Release() and $obj->AddRef() to gain more control over the used
-  COM components. (phanto)
-- Added an additional parameter to dotnet_load to specify the codepage (phanto)
-- Added peak memory logging. Use --enable-memory-limit to create a new Apache
-  1.x logging directive "{mod_php_memory_usage}n" which will log the peak
-  amount of memory used by the script. (Thies)
-- Made fstat() and stat() provide identical output by returning a numerical and
-  string indexed array. (Jason)
-- Fixed memory leak upon re-registering constants. (Sascha, Zend Engine)
 
-23 Jun 2001, Version 4.0.6
-- Fixed memory fragmention problem which could lead to web server processes
-  growing much more than they should. (Andi, Zend Engine)
-- Made $HTTP_SESSION_VARS['foo'] and $foo be references to the same value
-  when register_globals is on. (Andrei)
-- Fixed disk_free_space() and disk_total_space() under FreeBSD. (Jon)
-- Fixed readfile/passthru losing resources during connection abort (Sascha)
-- Fixed bug in the mcrypt extension that caused segfaults when using a key
-  that is too large for the used algorithm, and a bug that caused
-  mcrypt_generic() to segfault PHP (Derick)
-- Fixed getopt so that it accepts command line arguments in the form
-  -<opt><arg> and -<opt> <arg>. (Jmoore)
-- Fixed race in writing session files (Sascha)
-- Fixed a possible crash in the PHP CGI when no input file is
-  specified (Zeev)
-- Added is_callable() function that can be used to find out whether
-  its argument is a valid callable construct. (Andrei)
-- Fixed a rare possible crash when generating extended information. (Dmitri
-  Dmitrienko, Zend Engine)
-- Improved virtual() to support PHP-enabled URIs. (Zeev)
-- Fixed undefined behavior when using floating point keys in array()
-  expressions. (Zeev, Zend Engine)
-- Fixed a possible crash in case of parse errors in include files or eval
-  statements. (Zeev, Zend Engine)
-- Added --with-layout configure option. (Stig)
-- Improved interactive mode - supports function calls, and works in
-  multithreaded builds. (Zeev, Zend Engine)
-- Fixed a crash bug in interactive mode. (Zeev, Zend Engine)
-- Added pg_last_notice() function. (Rasmus from suggestion by Dirk@rackspace.com)
-- Fixed a bug in preg_split() that would incorrectly limit the number of
-  results when used along with PREG_SPLIT_NO_EMPTY flag. (Andrei)
-- Added connection error support to mysql_error() and mysql_errno(). (Jason)
-- Added support to getimagesize to return dimensions of BMP and PSD
-  files. (Derick)
-- Added heuristic to kill stale IRC connections, message scanner caching, and
-  nickname escaping to IRCG, suppress option to ircg_msg(), and statistics to
-  IRCG phpinfo() output. (Sascha)
-- Added Japanese multibyte string functions support. (Rui)
-- Added Mac OS X "\r" line ending support. (Andi, Zend Engine)
-- Fixed a bug regarding the $PHP_SELF being incorrectly registered when
-  force-cgi-redirect was not enabled. (Sterling)
-- pfpro extension now supports version 3 of the Verisign SDK. (John Donagher)
-- Udm_Cat_List and Udm_Cat_Path functions has been added.
-- Added key_exists() to check if a given key or index exists in an
-  array or object. (David Croft)
-- Modify the cURL extension to compile only with the latest cURL release.  
-  Backwards compatibility with regards to the extension api has not been 
-  broken. (Sterling)
-- Added the ability to use user-defined callbacks with cURL. (Sterling)
-- Added the SSL_VERIFYPEER, CAINFO, MAXREDIRS, FILETIME, RANDOM_FILE, EGDSOCKET
-  and CONNECTTIMEOUT options to curl_setopt(). (Sterling)
-- Added support for persistent connections with cURL. (Sterling)
-- Fixed a problem in cURL with file descriptors being allocated, but never 
-  closed. (Sterling)
-- Fixed interactive mode (-a). It works again with the same limitations it
-  has always had. (Andi, Zend Engine)
-- Improved memory manager to use less memory and provide better memory overflow
-  detection abilities in debug mode. (Andi, Zend Engine)
-- Fixed resource leaks when resources were being cast to numbers. (Zeev, Zend
-  Engine)
-- Fixed foreach() to not crash when being sent an invalid argument. (Andi, Zend
-  Engine)
-- Fixed a bug in opendir() under Windows when trying to open a non-exisiting
-  directory. (Andi)
-- Fixed popen() and the exec family under Win32 (Unable to fork issue). (Daniel)
-- Make the printf family of functions binary clean. (Rasmus)
-- Fixed WDDX serialization to HTML-escape key/variable names so as not to
-  break the XML packet. (Andrei)
-- Made WDDX extension enabled by default. (Andrei)
-- Added -C command-line option to avoid chdir to the script's directory. (Stig)
-- Fixed a bug with /e modifier in preg_replace(), that would not correctly
-  replace two-digit references if single digit references were present
-  before them. This fixed bug #10218. (Andrei)
-- Added temporary LOB support in OCI8. (Patch by David Benson)
-- Fixed crash in pathinfo()
-- OCI8 now supports binding of collections. (Patch by Andy Sautins
-  <asautins@veripost.net>)
-- Added GD 2.0.1 support for truecolor and alpha channels, plus some other gd
-  functions, both old and new - see docs for more info. (Wez)
-- Added S/MIME sign/verify encrypt/decrypt functions to openssl extension,
-  along with some other certificate manipulation and interrogation functions.
-  See docs for more info. (Wez)
-- printf argnum (parameter swapping) support. (Morten Poulsen, Rasmus)
-- Add DIRECTORY_SEPARATOR constant ('/' on UNIX, '\' on Windows). (Stig)
-- Added small change to php_odbc module, to check for failed SQLDisconnects
-  and to close any outstanding transactions if the call fails, then disconnect
-  again. (lurcher)
-- Modified get_parent_class() and get_class_methods() to accept a class name as
-  well as a class instance. (Andrei, Zend Engine)
-- Added support for UNC style paths. (\\server\share\file,
-  //server/share/file). (Daniel, TSRM)
-- Added dbx module (database abstraction) to the repository. (Marc)
-- Using ITypeInfo instead of IDispatch if possible. This makes DCOM calls
-  and even COM calls much faster.
-  All ini settings are now prefixed by 'com.'.
-  Now you need not provide a path to the file containing the typelib, you can
-  also provide the GUID of the TypeLib - entry or an IID for preloading
-  type - information. (phanto)
-- Rewrite of domxml. It's now mostly DOM Level 2 conform. (Uwe)
-- Added array_map() function that applies a callback to the elements
-  of given arrays and returns the result. It can also be used with a
-  null callback to transpose arrays. (Andrei)
-- Added array_filter(), which allows filtering of array elements via
-  the specified callback. (Andrei)
-- Fixed all relevant array functions to avoid moving the internal array
-  pointer during operations. (Andrei)
-- Added mysql_unbuffered_query(), which is useful for very large result sets.
-  (Zeev)
-
-30 Apr 2001, Version 4.0.5
-- Added new php.ini directive: arg_separator.input which is used to tell
-  PHP which characters are considered as argument separators in URLs. 
-  Renamed php.ini directive: arg_separator -> arg_separator.output (Jani)
-- Added FastCGI SAPI module. (Ben Mansell)
-- Added array_reduce(), which allows iterative reduction of an array
-  to a single value via a callback function. (Andrei)
-- The imageloadfont function of the gd extension should be not platform
-  dependent after this fix. (alex@zend.com)
-- Fixed a compatibility problem in some file functions (fgets, fputs, fread,
-  fwrite). The ANSI standard says that if a file is opened in read/write
-  mode, fseek() should be called before switching from reading to writing
-  and vice versa. (alex@zend.com)
-- Fixed argument checking for call_user_func* functions and allowed
-  specifying array($obj, 'method') syntax for call_user_func_array. (Andrei)
-- Fixed parent::method() to also work with runtime bindings.
-  (Zeev, Zend Engine)
-- Implemented high-performance zlib-based output compression - see
-  zlib.output_compression INI directive. (Zeev)
-- Improved ob_gzhandler() to support chunked output buffering - it's 
-  recommended to use it with 4KB chunks. (Zeev)
-- Fixed chunked output buffering. (Zeev)
-- Forced call_user_method() and call_user_method_array() to take the
-  object argument by reference. (Andrei)
-- Fixed binding of ROWIDs in OCI8. (Thies)
-- Added PEAR/Cache as a generic Caching System. (Sebastian, PEAR/Cache)
-- Added IMAP quota support (imap_set_quota, imap_get_quota), enabled/added via
-  c-client2000. (kalowsky)
-- Upgraded PCRE to version 3.4. (Andrei)
-- Added array_search which works similar to in_array but returns
-  the key instead of a boolean. (jason@php.net)
-- Fixed pgsql transaction support. (Stig, PEAR/DB)
-- Added new object VARIANT() to encapsulate values for use with
-  the COM and DOTNET module. Therefore it is now possible to pass
-  values by reference, convert php values to extended variant types (currency,
-  date, idispatch, iunknown, ...) and define the codepage that should
-  be used for unicode - conversion.
-- Improved overall speed of IRCG, added URL handling to message scanner.
-  (Sascha)
-- Fixed some modules to allow using output-buffering. (Thies)
-- Added the chroot() function. (Derick)
-- PostgreSQL now does a rollback at the end of a request on every
-  persistent connection. This is done by doing an "empty" transaction
-  on the connection. This was advised by someone from the PostgreSQL
-  core-team. (Thies)
-- Fixed PostgeSQL pg_connect() bug. We would sometimes close the default
-  link by accident. (Patch by: aja@nlgroup.ca)
-- Improved OCI8 dead-session detection. (Patch by: George Schlossnagle)
-- Fixed get_meta_tags() multiline bug #4556. (Sean)
-- Prefer random() over *rand48(). (JimJag)
-- Sped up WDDX serialization 2x. (Andrei)
-- Added a new parameter to mail() which appends aditional command line
-  parameters to the mail program. (Derick)
-- Added Udm_Clear_Search_Limits mnoGoSearch extension function. (gluke)
-- Fixed mnogosearch protos. Fixed mnogosearch functions return values.
-  A bug with capital letters break search has been fixed. (gluke)
-- Static methods can now be called via call_user_method_* functions, e.g.
-  call_user_method('method', 'class'), and also array('class', 'method')
-  constructs (for array_walk(), for example). (Andrei, Zend Engine)
-- microtime() under Windows now returns accurate values. (James)
-- Added PREG_SPLIT_DELIM_CAPTURE flag to preg_split() that allows for Perl-like
-  functionality of capturing parenthesized delimiter expression. (Andrei)
-- Fixed strip_tags() to not strip a lone > character. (Rasmus)
-- When using the ob_gzhandler() PHP now automagically also sets the
-  Content-Lengh correctly which enables browsers to use the HTTP
-  Keep-Alive feature. (Thies)
-- Improved handling of preg_replace() /F modifier so that it's possible to
-  specify array($obj, 'method') construct as a replacement function. (Andrei)
-- Added mysql_get_client_info(), mysql_get_server_info(),
-  mysql_get_proto_info(), and mysql_get_host_info() functions. (Sean)
-- Major change of the php pdf api. It could break some functions though
-  backwards compatibility was tried to maintain. Adding some still
-  missing functions as well. (Uwe)
-- Added mnoGoSearch extension - http://search.mnogo.ru. (Sergey K)
-- Allow URL encoding in DB usernames and passwords. (Stig, PEAR)
-- Added raiseError and setErrorHandling methods to PEAR class. (Stig, PEAR)
-- Added support for converting images from JPG/PNG on the fly with the GD
-  extension, which is usefull for creating dynamic WAP-sites. (Derick)
-- Updated ext/mysql/libmysql to version 3.23.32; bug fixes. (tim@mysql.com)
-- Fixed possible crash in all (non-pcre) regex functions. (Thies)
-- Improved str_replace() to accept an array for any parameter - similar
-  to preg_replace(). (Andrei)
-- Fixed extract() to properly prefix numeric keys when EXTR_PREFIX_ALL is
-  used. (Andrei)
-- Added EXTR_PREFIX_INVALID flag to extract() to automatically prefix
-  string keys that do not constitute valid variable names. (Andrei)
-- BeOS patch from svanegmond@bang.dhs.org, modified somewhat by Rasmus.
-- Fixed the Apache module to overwrite PATH_TRANSLATED with SCRIPT_FILENAME,
-  only if PATH_TRANSLATED is not previously set. (Zeev)
-- Fixed crash bug in highlight_string(). (Rasmus)
-- Added URL support for getimagesize() function. (Jani)
-- Added xslt_set_scheme_handler() function. (carmelo@akooe.com)
-- Added the pg_lolseek and pg_lotell functions. (Derick)
-- Fixed wrong breaking with the wordwrap function. (Derick)
-- Fixed 'O' and 'r' flags of date() to have correct sign for timezone
-  offset. (Andrei)
-- Changed 'Z' flag to date() to always return timezone offset with
-  negative sign if it's west of UTC. (Andrei)
-- Added the HTML_Processor class which provides common functions for 
-  processing HTML. (Sterling)
-- Added localeconv() and strcoll() functions for localization. (Sean)
-- Added the xslt_set_base function. (Sterling)
-- Added support for Zeus 3.3.8.
-- Added odbc_error() and odbc_errormsg() functions. (Stig)
-- New extension for vpopmail - http://www.inter7.com/vpopmail,
-  give it a try, but keep in mind that it is not ready for production 
-  environments. (David Croft, Boian Bonev)
-- Added sybase_get_last_message() to the Sybase CT module. (Jan Fedak)
-- Made ldap_list(), ldap_read() and ldap_search() do parallel search when
-  first parameter is an array of link identifiers. (Stig Venaas)
-- Made fopen() of HTTP URL follow redirects, $http_response_header will
-  contain all headers with empty string as delimiter. (Stig Venaas)
-- Added Console_Getopt class for parsing command-line args. (Andrei, PEAR)
-- Added an experimental version of the ZZipLib extension which provides the
-  ability to read zip files. (Sterling)
-- Allow access to uploaded files in safe_mode. Beware that you can only
-  read the file. If you copy it to new location the copy will not have the
-  right UID and you script won't be able to access that copy. (Thies)
-- Changed extract() to check that prefixed name is a valid one. (Andrei)
-- Changed extract() to return the number of variables extracted. (Andrei)
-- Added ldap_rename() function. (Stig Venaas)
-- Made ldap_set_option() support controls. (Stig Venaas)
-- Changed ldap_search() and added functions ldap_parse_result(),
-  ldap_first_reference(), ldap_next_reference() and ldap_parse_reference()
-  to cope with LDAPv3 stuff like referrals and references. (Stig Venaas)
-- Fixed date('r') overflow.
-- Made the php.ini path reported in phpinfo() always point to the absolute
-  path that was opened. (Zeev)
-- Made the INI mechanism thread safe. (Zeev, Zend Engine)
-- Changed setlocale() to use LC_* constants. (Jani)
-- ctype functions now follow the extension naming conventions. (Hartmut)
-- Added iconv() function (using libc or libiconv). (Stig)
-- Added ODBC_TYPE constant. (Stig)
-- Added the call_user_method_array function which allows you to call a method
-  with an arbitrary number of parameters. (Sterling)
-- ext/odbc: IBM DB2 patch by Walter Franzini. <walter@sys-net.it>
-- Added extension for the cracklib library. (Alexander Feldman)
-
-19 Dec. 2000, Version 4.0.4
-- Allow assigning a newly created object by reference. This is needed only if
-  your constructor makes other data structures reference the $this object (for
-  example, $GLOBALS["foobar"] =& $this;)
-  The new syntax is $obj =& new MyClass(); (Andi, Zend Engine)
+?? ??? 2000, Version 4.0.4
 - Allow for three expression types to be sent to functions which are requesting
   the function argument to be passed by reference (only c. was previously
   supported):
@@ -462,7 +17,7 @@ PHP 4.0                                                                    NEWS
 - Made ldap_get_entries() return an array even if there are no entries
   in search result. (Jani)
 - Fixed bad mod_perl interaction which caused segfaults when using LFS (Sascha)
-- const CONSTNAME now gets recognized. Before the patch only @const CONSTNAME
+- const CONSTNAME now gets recognized. Before the patch only @const CONSTNAME 
   description was recognized.
 - Added the is_null() function that will return true if a variable is of
   type null. (Sterling)
@@ -484,7 +39,6 @@ PHP 4.0                                                                    NEWS
   at run-time to provide the replacement string. It is passed an array of
   matched pattern and subpatterns. (Andrei)
 - Put an end to BUG#4615 (kalowsky & Eric Veldhuyzen)
-- Added the IRCG extension (Sascha)
 - Fixed realpath() in Virtual Directory mode (Daniel)
 - Integrated the Phil Nelson's bc math library routines into PHP, now that
   the license allows it (Phil Nelson <phil@cs.wwu.edu>)
@@ -522,7 +76,6 @@ PHP 4.0                                                                    NEWS
   the full path (Jani)
 - Added ImageCreateFromString() which creates an image stream out of 
   e.g. a MySQL blob. (Mathieu)
-- Fixed a crash bug in imagewbmp() (Jani)
 - Changed the sablot configuration file so that if you use any version of
   Sablotron below 0.44 you must use Sablotron's built-in Expat libraries.
   (Sterling)
@@ -852,7 +405,7 @@ PHP 4.0                                                                    NEWS
   and currently run through a system call.  This will speed up the UdmSearch
   php frontend significantly. (Rasmus)
 - Modified in_array() to not touch array pointer. (Andrei)
-- Added restore_error_handler(). (Zeev, Zend Engine)
+- Added restore_error_handler(). (Zeev, Zend engine)
 - Fixed erroneous file names and line numbers in error situations under the
   multithreaded version of PHP - most noticeably Win32 (Zeev, Zend Engine)
 - Fixed problem with CGI crashing on certain servers especially Windows Apache

README.BCMATH

@@ -0,0 +1,6 @@
+As of PHP 4.0.4, the BC math library routines are bundled in the
+standard PHP distribution.  There is no need to install any additional
+files.
+
+Thanks goes to Phil Nelson, for releasing the BC math library routines
+under the LGPL.

README.CVS-RULES

@@ -64,8 +64,7 @@ NEWS file. Everything else goes into the ChangeLog.
 It is important to note that if your comment or news logline spans multiple
 lines, you have to put # or @ at the beginning of _every_ such line. Every 
 entry in NEWS has to have a name after it, so if you did it with someone's 
-help, put both your names there. Your name WILL NOT be automatically put
-at the end of the NEWS entry - so, please provide it yourself.
+help, put both your names there.
 
 Example. Say you modified two files, datetime.c and string.c. In datetime.c
 you added a new format option for date() function, and in string.c you fixed

README.EXTENSIONS

@@ -1,39 +0,0 @@
-Between PHP 4.0.6 and 4.1.0, the Zend module struct changed in a way
-that broke both source and binary compatibility.  If you are
-maintaining a third party extension, here's how to update it:
-
-If this was your old module entry:
-
-zend_module_entry foo_module_entry = {
-    "foo",                /* extension name */
-    foo_functions,        /* extension function list */
-    NULL,                 /* extension-wide startup function */
-    NULL,                 /* extension-wide shutdown function */
-    PHP_RINIT(foo),       /* per-request startup function */
-    PHP_RSHUTDOWN(foo),   /* per-request shutdown function */
-    PHP_MINFO(foo),       /* information function */
-    STANDARD_MODULE_PROPERTIES
-};
-
-Here's how it should look if you want your code to build with PHP
-4.1.0 and up:
-
-zend_module_entry foo_module_entry = {
-#if ZEND_MODULE_API_NO >= 20010901
-    STANDARD_MODULE_HEADER,
-#endif
-    "foo",                /* extension name */
-    foo_functions,        /* extension function list */
-    NULL,                 /* extension-wide startup function */
-    NULL,                 /* extension-wide shutdown function */
-    PHP_RINIT(foo),       /* per-request startup function */
-    PHP_RSHUTDOWN(foo),   /* per-request shutdown function */
-    PHP_MINFO(foo),       /* information function */
-#if ZEND_MODULE_API_NO >= 20010901
-    FOO_VERSION,          /* extension version number (string) */
-#endif
-    STANDARD_MODULE_PROPERTIES
-};
-
-If you don't care about source compatibility with earlier PHP releases
-than 4.1.0, you can drop the #if/#endif lines.

README.EXT_SKEL

@@ -128,8 +128,8 @@ CURRENT LIMITATIONS, BUGS AND OTHER ODDITIES
   It can't handle correctly, and probably never will, variable list of
   of arguments. (void foo(int bar [, ...])
 
-  Don't trust the generated code too much. It tries to be useful in most of
-  the situations you might encounter, but automatic code generation will never
+  Don't trust too much the generated code. It tries to be useful in most of
+  the situations you might encounter, but automatic code generating will never
   beat a programmer who knows the real situation at hand. ext_skel is generally
   best suited for quickly generating a wrapper for c-library functions you
   might want to have available in PHP too.
@@ -154,14 +154,15 @@ PHP_FUNCTION(my_drawtext)
 	int argc;
 	int image_id = -1;
 	int font_id = -1;
+	???LS_FETCH();
 
 	argc = ZEND_NUM_ARGS();
 	if (argc < 5 || argc > 6 || zend_get_parameters_ex(argc, &image, &text, &font, &x, &y, &color) == FAILURE) {
 		WRONG_PARAM_COUNT;
 	}
 
-	ZEND_FETCH_RESOURCE(???, ???, image, image_id, "???", ???_rsrc_id);
-	ZEND_FETCH_RESOURCE(???, ???, font, font_id, "???", ???_rsrc_id);
+	ZEND_FETCH_RESOURCE(???, ???, image, image_id, "???", ???G());
+	ZEND_FETCH_RESOURCE(???, ???, font, font_id, "???", ???G());
 
 	switch (argc) {
 		case 6:

README.STREAMS

@@ -1,243 +0,0 @@
-An Overview of the PHP Streams abstraction
-==========================================
-$Id$
-
-Please send comments to: Wez Furlong <wez@thebrainroom.com>
-
-Note: this doc is preliminary and is intended to give the reader an idea of
-how streams work and should be used.
-
-Why Streams?
-============
-You may have noticed a shed-load of issock parameters flying around the PHP
-code; we don't want them - they are ugly and cumbersome and force you to
-special case sockets and files everytime you need to work with a "user-level"
-PHP file pointer.
-Streams take care of that and present the PHP extension coder with an ANSI
-stdio-alike API that looks much nicer and can be extended to support non file
-based data sources.
-
-Using Streams
-=============
-Streams use a php_stream* parameter just as ANSI stdio (fread etc.) use a
-FILE* parameter.
-
-The main functions are:
-
-PHPAPI size_t php_stream_read(php_stream * stream, char * buf, size_t count);
-PHPAPI size_t php_stream_write(php_stream * stream, const char * buf, size_t
-	  	count);
-PHPAPI int php_stream_eof(php_stream * stream);
-PHPAPI int php_stream_getc(php_stream * stream);
-PHPAPI char *php_stream_gets(php_stream * stream, char *buf, size_t maxlen);
-PHPAPI int php_stream_close(php_stream * stream);
-PHPAPI int php_stream_flush(php_stream * stream);
-PHPAPI int php_stream_seek(php_stream * stream, off_t offset, int whence);
-PHPAPI off_t php_stream_tell(php_stream * stream);
-
-These (should) behave in the same way as the ANSI stdio functions with similar
-names: fread, fwrite, feof, fgetc, fgets, fclose, fflush, fseek, ftell.
-
-Opening Streams
-===============
-Ultimately, I aim to implement an fopen_wrapper-like call to do this with
-minimum fuss.
-Currently, mostly for testing purposes, you can use php_stream_fopen to open a
-stream on a regular file.
-
-PHPAPI php_stream * php_stream_fopen(const char * filename, const char *
-		mode);
-
-This call behaves just like fopen(), except it returns a stream instead of a
-FILE *
-
-Casting Streams
-===============
-What if your extension needs to access the FILE* of a user level file pointer?
-You need to "cast" the stream into a FILE*, and this is how you do it:
-
-FILE * fp;
-php_stream * stream; /* already opened */
-
-if (php_stream_cast(stream, PHP_STREAM_AS_STDIO, &fp, 1) == FAILURE)	{
-	RETURN_FALSE;
-}
-
-The prototype is:
-
-PHPAPI int php_stream_cast(php_stream * stream, int castas, void ** ret, int
-		show_err);
-
-The show_err parameter, if non-zero, will cause the function to display an
-appropriate error message of type E_WARNING if the cast fails.
-
-castas can be one of the following values:
-PHP_STREAM_AS_STDIO - a stdio FILE*
-PHP_STREAM_AS_FD - a generic file descriptor
-PHP_STREAM_AS_SOCKETD - a socket descriptor
-
-If you ask a socket stream for a FILE*, the abstraction will use fdopen to
-create it for you.  Be warned that doing so may cause buffered data to be lost
-if you mix ANSI stdio calls on the FILE* with php stream calls on the stream.
-
-If your system has the fopencookie function, php streams can synthesize a
-FILE* on top of any stream, which is useful for SSL sockets, memory based
-streams, data base streams etc. etc.
-NOTE: There might be situations where this is not desireable, and we need to
-provide a flag to inform the casting routine of this.
-
-You can use:
-
-PHPAPI int php_stream_can_cast(php_stream * stream, int castas)
-
-to find out if a stream can be cast, without actually performing the cast, so
-to check if a stream is a socket you might use:
-
-if (php_stream_can_cast(stream, PHP_STREAM_AS_SOCKETD) == SUCCESS)	{
-	/* it's a socket */
-}
-
-
-Stream Internals
-================
-
-There are two main structures associated with a stream - the php_stream
-itself, which holds some state information (and possibly a buffer) and a
-php_stream_ops structure, which holds the "virtual method table" for the
-underlying implementation.
-
-The php_streams ops struct consists of pointers to methods that implement
-read, write, close, flush, seek, gets and cast operations.  Of these, an
-implementation need only implement write, read, close and flush.  The gets
-method is intended to be used for non-buffered streams if there is an
-underlying method that can efficiently behave as fgets.  The ops struct also
-contains a label for the implementation that will be used when printing error
-messages - the stdio implementation has a label of "STDIO" for example.
-
-The idea is that a stream implementation defines a php_stream_ops struct, and
-associates it with a php_stream using php_stream_alloc.
-
-As an example, the php_stream_fopen() function looks like this:
-
-PHPAPI php_stream * php_stream_fopen(const char * filename, const char * mode)
-{
-	FILE * fp = fopen(filename, mode);
-	php_stream * ret;
-	
-	if (fp)	{
-		ret = php_stream_alloc(&php_stream_stdio_ops, fp, 0, 0, mode);
-		if (ret)
-			return ret;
-
-		fclose(fp);
-	}
-	return NULL;
-}
-
-php_stream_stdio_ops is a php_stream_ops structure that can be used to handle
-FILE* based streams.
-
-A socket based stream would use code similar to that above to create a stream
-to be passed back to fopen_wrapper (or it's yet to be implemented successor).
-
-The prototype for php_stream_alloc is this:
-
-PHPAPI php_stream * php_stream_alloc(php_stream_ops * ops, void * abstract,
-		size_t bufsize, int persistent, const char * mode)
-
-ops is a pointer to the implementation,
-abstract holds implementation specific data that is relevant to this instance
-of the stream,
-bufsize is the size of the buffer to use - if 0, then buffering at the stream
-level will be disabled (recommended for underlying sources that implement
-their own buffering - such a FILE*),
-persistent controls how the memory is to be allocated - persistently so that
-it lasts across requests, or non-persistently so that it is freed at the end
-of a request (it uses pemalloc),
-mode is the stdio-like mode of operation - php streams places no real meaning
-in the mode parameter, except that it checks for a 'w' in the string when
-attempting to write (this may change).
-
-The mode parameter is passed on to fdopen/fopencookie when the stream is cast
-into a FILE*, so it should be compatible with the mode parameter of fopen().
-
-Writing your own stream implementation
-======================================
-
-First, you need to figure out what data you need to associate with the
-php_stream.  For example, you might need a pointer to some memory for memory
-based streams, or if you were making a stream to read data from an RDBMS like
-mysql, you might want to store the connection and rowset handles.
-
-The stream has a field called abstract that you can use to hold this data.
-If you need to store more than a single field of data, define a structure to
-hold it, allocate it (use pemalloc with the persistent flag set
-appropriately), and use the abstract pointer to refer to it.
-
-For structured state you might have this:
-
-struct my_state	{
-	MYSQL conn;
-	MYSQL_RES * result;
-};
-
-struct my_state * state = pemalloc(sizeof(struct my_state), persistent);
-
-/* initialize the connection, and run a query, using the fields in state to
- * hold the results */
-
-state->result = mysql_use_result(&state->conn);
-
-/* now allocate the stream itself */
-stream = php_stream_alloc(&my_ops, state, 0, persistent, "r");
-
-/* now stream->abstract == state */
-
-Once you have that part figured out, you can write your implementation and
-define the your own php_stream_ops struct (we called it my_ops in the above
-example).
-
-For example, for reading from this wierd mysql stream:
-
-static size_t php_mysqlop_read(php_stream * stream, char * buf, size_t count)
-{
-	struct my_state * state = (struct my_state*)stream->abstract;
-
-	if (buf == NULL && count == 0)	{
-		/* in this special case, php_streams is asking if we have reached the
-		 * end of file */
-		if (... at end of file ...)
-			return EOF;
-		else
-			return 0;
-	}
-	
-	/* pull out some data from the stream and put it in buf */
-	... mysql_fetch_row(state->result) ...
-	/* we could do something strange, like format the data as XML here,
-		and place that in the buf, but that brings in some complexities,
-		such as coping with a buffer size too small to hold the data,
-		so I won't even go in to how to do that here */
-}
-
-Implement the other operations - remember that write, read, close and flush
-are all mandatory.  The rest are optional.  Declare your stream ops struct:
-
-php_stream_ops my_ops = {
-	php_mysqlop_write, php_mysqlop_read, php_mysqlop_close,
-	php_mysqlop_flush, NULL, NULL, NULL,
-	"Strange mySQL example"
-}
-
-Thats it!
-
-Take a look at the STDIO implementation in streams.c for more information
-about how these operations work.
-The main thing to remember is that in your close operation you need to release
-and free the resources you allocated for the abstract field.  In the case of
-the example above, you need to use mysql_free_result on the rowset, close the
-connection and then use pefree to dispose of the struct you allocated.
-You may read the stream->persistent field to determine if your struct was
-allocated in persistent mode or not.
-
-vim:tw=78

README.Zeus

@@ -1,126 +1,153 @@
 Using PHP4 with the Zeus Web Server
 -----------------------------------
 
-Zeus fully supports running PHP in combination with our
-webserver. There are three different interfaces that can be used to
-enable PHP:
+Zeus fully supports running PHP in combination with our webserver. A
+significant improvement in PHP 4 is that you can now run PHP as an
+ISAPI module, giving great performance benefits over traditional CGI
+code.
 
-* CGI
-* ISAPI
-* FastCGI
-
-Of the three, we recommend using FastCGI, which has been tested and
-benchmarked as providing the best performance and reliability.
-
-Full details of how to install PHP are available from our
-website, at:
-
-http://support.zeus.com/products/php.html
-
-If you have any problems, please check the support site for more
-up-to-date information and advice.
+Note that you will need to be running at least version 3.3.6 of the
+webserver. If you are running an earlier version, please see our
+website (http://www.zeus.com) for upgrade instructions.
 
 
-Quick guide to installing FastCGI with Zeus
--------------------------------------------
+To build the ISAPI version of PHP, start the configuration with:
 
-Step 1 - obtain and install FastCGI development kit.
+./configure --with-zeus=/usr/local/zeus
 
-Grab the package from:
-http://www.fastcgi.com/dist/devkit_2.2.0.tar.gz
+Obviously, replace /usr/local/zeus with the location of where you have
+installed Zeus on your machine. For PHP to build successfully, you
+need to have 3.3.6 already installed, because the code relies on the
+presence of header files provided with the latest version.
 
-Extract the package and follow the instructions:
-        ./configure
-        make
-        make export
-(run the last as root)
-
-This will install to /usr/local/lib/libfcgi.a
-                and  /usr/local/include/*fcgi*
+You may have to adjust the environment variable LDFLAGS and EXTRA_LIBS
+in order to link in extra libraries. This depends on the platform on
+which you are building and also on the compiler used (see below). A
+standard GNU/Linux install with GCC should build fine with no changes.
 
 
+Configuring the webserver
+-------------------------
 
-Step 2 - Compile PHP as FastCGI.
+After running 'make' and 'make install', you will have a 'libphp4.so'
+file. Copy this file into a directory reserved for ISAPI
+binaries. Now, perform the following steps for each virtual server
+that you wish to run PHP on:
 
-Compile as follows:
-        ./configure --with-fastcgi
-        make
-
-Note that PHP has many options to the configure script -
-e.g. --with-mysql. You will probably want to select your usual options
-before compiling; the above is just a bare minimum, for illustration.
-
-After compilation finishes, you will be left with an executable
-program called 'php'. Copy this into your document root, under a
-dedicated FastCGI directory (e.g. $DOCROOT/fcgi-bin/php)
+1) On the Admin server, go to 'edit server->path mapping'
+2) Add an alias to the directory with libphp4.so in it, mapped to
+   /isapi/ (or a location of your choice). Make sure you set the alias
+   type to ISAPI.
+3) Click 'update'
+4) Add a handler for file extension 'php' to be run by /isapi/libphp4.so
+5) Click 'update', then go back to the previous page.
+6) Click on the 'module configuration' button, ensure that ISAPI
+   support is ticked.
+7) Click on the ISAPI link. At the bottom of the page, click the
+   checkbox for running ISAPI extensions 'out of process'.
+8) Click 'update'. Then restart the virtual server. Done!
 
 
-Step 3 - configure Zeus
+Troubleshooting
+---------------
 
-Four stages:
-        -  enable FastCGI
-        -  configure FastCGI
-        -  setup alias for FastCGI
-        -  setup alias for PHP
+*) Why does the compile fail at Zend/zend-scanner-cc.cc
+                             or Zend/zend-parser.c ?
 
-1) Using the admin server, go to the 'module configuration' page for
-your virtual server, and ensure that 'fastcgi' is enabled (select the
-tickbox to the left).
+These source files are auto-generated from the corresponding .y files.
+The default distribution of PHP contains pre-generated versions of these
+files that have caused problems for some people. The simplest solution is
+to delete the files. They will then be rebuilt correctly. You must have the
+following GNU tools to do this:
 
-2) While we can run FastCGI's locally, there are known problems with
-some OS's (specifically, the communication between web server and
-FastCGI happens over a unix domain socket, and some OS's have trouble
-sustaining high connection rates over these sockets). So instead, we
-are going to set up the PHP FastCGI to run 'remotely' over localhost
-(this uses TCP sockets, which do not suffer this problem). Go to the
-'fastcgi configuration' page, and under 'add remote fastcgi':
-        Add Remote FastCGI
-                Docroot path            /fcgi-bin/php
-                Remote machine          localhost:8002
-The first entry is where you saved PHP, above.
-The second entry is localhost:<any unused port>
-We will start the FastCGI listening on this port shortly.
-Click 'update' to commit these changes.
+       bison  1.28 or later
+       flex  2.5.4 or later
 
-3) Go to the path mapping module and add an alias for FastCGI:
-        Add Alias
-                Docroot path            /fcgi-bin
-                Filesystem directory    /path/to/docroot/fcgi-bin
-                Alias type              fastcgi
-Click 'update' to commit these changes
+*) Why does my PHP library fail to load?
 
-4) Also on the path mapping module, add a handler for PHP:
-        Add handler
-                File extension          php
-                Handler                 /fcgi-bin/php
-Click 'update' to commit these changes
+After configuring Zeus, if you get a '502 Bad Gateway' error when
+accessing a PHP page, there are problems loading the PHP
+library. Check the error log ($ZEUSHOME/web/log/errors) for errors.
 
-Finally restart your virtual server for these changes to take effect.
+Failing to load the PHP ISAPI module is likely to be due to unresolved
+symbols in the module. A way to check for this is to visit our support
+page at http://support.zeus.com/faq/entries/isapi_error.html and run
+the program there on your libphp4.so. It will list any unresolved
+symbols.
+
+*) My libphp4.so has unresolved symbols. How do I fix this?
+
+You must ensure that the PHP build process links in the appropriate
+libraries that contain these symbols! The libraries required will
+depend on the platform you are running PHP on.
+
+You may need to set one or two environment variables before running
+the 'configure' program to set up PHP; LDFLAGS and EXTRA_LIBS. Make
+sure that you also export these variables to the build process.
+(Type 'export LDFLAGS EXTRA_LIBS' in the shell to do this.)
+
+If you are using 3rd party tools and libraries which are installed
+in non-standard locations, you may need to set the environment
+variable LD_LIBRARY_PATH to point to the library's location, prior
+to running the Zeus Web Server. For example, if you have compiled
+external MySQL support, and mysql is installed in /usr/local/mysql,
+you should set LD_LIBRARY_PATH to '/usr/local/mysql/lib/mysql'
+and then 'export LD_LIBRARY_PATH'. For convenience, you should add
+this to the 'start-zeus' script provided.
+
+Yet another method of ensuring the linked libraries are found is to
+set the environment variable LD_RUN_PATH before compiling PHP. This
+works in a similar way to LD_LIBRARY_PATH, but at compile-time.
+Libraries produced with this envrionment variable set will have its
+value 'burned' into the resultant binary, specifying a runtime
+search pth to locate other required libraries such as MySQL.
+
+On Linux, you can also tell the dynamic linker where to find the
+libraries, by adding '/usr/local/mysql/lib/mysql' to the file 
+/etc/ld.so.conf - after editting this file, run 'ldconfig' as root,
+to use the changes.
 
 
-Step 4 - start PHP as a FastCGI runner
+Specific examples:
 
-When you start PHP, it will pre-fork a given number of child processes
-to handle incoming PHP requests. Each process will handle a given
-number of requests before exiting (and being replaced by a newly
-forked process). You can control these two parameters by setting the
-following environment variables BEFORE starting the FastCGI runner:
+Solaris + gcc:
+Ensure you run ./configure with the `--enable-libgcc' parameter. You
+may need to set LDFLAGS to '-L/usr/local/egcs/lib' (path depends on
+your gcc installation)
 
-PHP_FCGI_CHILDREN - the number of child processes to pre-fork. If not
-set, defaults to 8.
+FreeBSD 4:
+Some people may find they need to run ./configure with the
+'--enable-libgcc' compile option too.
 
-PHP_FCGI_MAX_REQUESTS - the number of requests each PHP child process
-handles before exiting. If not set, defaults to 500.
 
-To start the FastCGI runner, execute '$ZEUSHOME/web/bin/fcgirunner
-8002 $DOCROOT/fcgi-bin/php'.  Substitute the appropriate values for
-$ZEUSHOME and $DOCROOT; also substitute for 8002 the port you chose,
-above.
+Performance issues
+==================
 
-To stop the runner (e.g. to experiment with the above environment
-variables) you will need to manually stop and running PHP
-processes. (Use 'ps' and 'kill'). As it is PHP which is forking lots
-of children and not the runner, Zeus unfortunately cannot keep track
-of what processes are running, sorry. A typical command line may look
-like 'ps -efl | grep $DOCROOT/fcgi-bin/php | grep -v grep | awk
-'{print $4}' | xargs kill'
+To make PHP run fast under Zeus, check the following points:
+
+1) Run PHP as an ISAPI module, not a CGI - compile it with the --with-zeus=...
+   flag!
+
+2) Tune the ISAPI runner to your required workload. There are several
+   tuneables that can be given. These are set by adding the appropriate
+   lines to the $ZEUSHOME/web/global.cfg file. Changes to this file will only
+   be picked up after the web server is restarted (run stop-zeus ; start-zeus)
+
+   tuning!modules!isapi!external!maxthreads xxx
+
+   - Sets the maximum number of threads that the ISAPI runner will spawn. If
+     further PHP page requests arrive, they will be queued until a current
+     page is finished. For busy websites, we suggest increasing this value
+     (defaults to 16). Replace the 'xxx' in the above line with the required
+     number of threads. Note that the threads are equally shared between
+     ISAPI extensions and filters, so if you want to handle 100 concurrent
+     PHP page requests, set this tuneable to 200.
+
+   tuning!modules!isapi!external!minthreads xxx
+
+   - Sets the minimum number of threads. Idle threads will be kept in a pool,
+     which avoids costly thread creation/deletion.
+
+
+For more information and help with Zeus, please visit our website:
+http://support.zeus.com

RELEASE_PROCESS

@@ -1,186 +0,0 @@
-	Advisory on the PHP Release Cycle
-
-
-Copyright & Liciencing
-
-  This Document is  (c)  Copyright 2000,2001 by The PHP Group 
-
-  This Document is distributed under the terms of the GNU General
-  Public License as published by the Free Software Foundation; 
-  either version 2 of the License, or (at your option) any later
-  version. 
-
-
-Table of Contents
-
-  1. Introduction
-  2. Dealing with bugs
-  2.1  As a QA Team Member
-  2.2  As a Developer
-  3. Releaseing another RC
-  4. CVS During the Release Process
-  4.1  Useful CVS Commands	  
-  5  The Final Release
-  6  Summary
-
-
-1. Introduction
-
-   This cycle should take place over roughly 10 days.  When it is
-   decided it is time for an Release to occur Andi/Zeev (Or 
-   Whoever) will tarball RC1, Tag & Branch CVS (see section 4)
-   and then announce the RC on PHP-QA and PHP-DEV.  At this 
-   point the build tracker and QA Bug System come into play.
-   If you successfully build PHP then report it in the build
-   tracker, If you then run and complete all the tests you
-   should report this too in the build tracker when
-   these features become avalible.
-
-2. Dealing with Bugs
-
-2.1 As a QA Team member
-
-   If you find a bug in an RC that you think is a showstopper
-   then, even if it is a known bug, you should report it in the
-   QA Bug system.  This marks the bug for discussion at least,
-   and preferably fixing before the actual release.  This system
-   is separate from the main bugs system so that important bugs
-   dont get lost in the midst if lots of feature/change request
-   in the approach to a release.  It is imperitive where 
-   appropraite that as a QA'er a test script, Configure options
-   and PHP.ini files are provided to enable the developer to
-   reproduce the bug, this is an important part of our job.  If
-   you have a serious bug then you should also create a test
-   script to be added to the tests dir of the php source so
-   that at the end of the process to enable us to make sure bug
-   does not return.  It is not difficult to create these test
-   scripts and a readme on it can be found in
-   php4/tests/README.
-
-
-2.2 As a Developer
-
-   What should happen is that when a bug is reported it
-   is send to php-dev and php-qa as with other bugs.  We should
-   have far stricter assignment system in this bug cycle rather
-   than just leaving them. Once again bugs should be able to be
-   marked as To Be Fixed Before release or moved to other bug
-   system. (This is currently the Release Masters responsibility)
-
-   Then before the actual release the qa bugs system can be
-   checked and if there are outstanding To Be Fixed Before
-   release bugs the Developers can see this easyly rather than
-   show stoppers being dismissed and not worried about.
-
-   When a bug is fixed the QAer who reported the bug is emailed
-   and asked to test again and see if the bug is fixed.
-
-3 Releasing another RC
-
-   If it is felt necessary that a 2nd RC is needed then it
-   should be packaged as before and announced to both lists
-   again. The testing process then starts again, the RC2 is 
-   added to the build tracker and QA'ers are asked to build and
-   retest the scripts as appropriate, espectially if you
-   reported a bug, you should test thourghly for your 
-   bug and make sure it no longer occurs. This will normally
-   add anouther 3 days to the cycle, giving QA'ers time to
-   build test and report back, then for developers to 
-   fix any problems.
-
-4 CVS during the release process
-
-   At the point where the first RC is create a branch is
-   formed. This branch is not altered form that point onward
-   other than major bug fixes. Minor non important bug 
-   fixes should not be applied to this branch but to the main
-   tree instead. Any major bug fixes should be applied to both
-   trees. The developer should test and check the RC tree then
-   also test and check the MAIN tree. This is their
-   responsibility to make sure (as far as possible) that the
-   bug fix works on both trees.
-
-4.1 Useful CVS Commands
-
-   To create a Branch <Should only be done by person tarballing
-   the RC (The Release Master)>:
-
-	$ cvs tag -b php_4_0_<Version>RC<NUMBER> 
-   IE:
-	$ cvs tag -b php_4_0_1RC1
-
-   This should be executed in the PHP directory of an up to
-   date checkout. Remember to also tag the Zend and TSRM repositories.
-
-   You can retrieve a branch in one of two ways: by checking it
-   out fresh from the repository, or by switching an existing
-   working copy over to the branch, I would suggest you
-   checkout a new copy.
-
-   To check out a new copy:
-	$ cvs checkout -r php_4_0_<Version>RC<NUMBER> php4
-   IE:
-	$ cvs checkout -r php_4_0_1RC1 php4
-
-
-   To switch a working copy (Not recomended due to possible
-   commiting to wrong branch)
-	$ cvs update -r php_4_0_<Version>RC<NUMBER> php4
-   IE:
-	$ cvs update -r php_4_0_1RC1 php4
-
-   This should be done in the PHP4 directory itself.
-
-   To revert back to normal branch you should use the
-   following:
-	$ cvs update -A
-
-   To Commit to the branch you follow exactly the same
-   procedure as normal
-	$ cvs commit file.c
-
-   MAKE SURE YOU DO NOT COMMIT TO THE WRONG BRANCH.
-
-5 The Final Release
-
-   When it is time to make the final release the following
-   proceedure should be followed. The person who is tarballing
-   the final release should check the QA bugs system and make
-   sure there are no showstoppers left unfixed. If there are
-   then bug the person the bug is assigned to until they fix
-   it. If there are no more qa bugs then they should tag the
-   branch as  php_4_0_<Version> and tarball as usual. An email
-   should be sent to PHP-GEN, PHP_DEV and PHP-QA about the new
-   release and it should be added to php.net. The windows
-   binaries and servelets should be built as soon as possible
-   and added too, as should the windows installer.
-
-6 Summary
-
-   Here is a summary of what a release cycle might look like:
-
-   Thurs: RC is agreed on and packaged, an email is sent to   
-          PHP_QA and PHP-DEV, the CVS is Branched and the     
-          Release Cycle Begins. 
-
-   Mon:   After a weekends testing most show stoppers should  
-          have been found (Hopefully) and the developers get to
-          work on fixing them.
-
-   Thurs: A second RC is released if needed with the new bug  
-          fixes in and the QAers test again.
-
-   Sun:   A review is made of all outstanding bugs and any show
-          stoppers should be fixed. if there are no show      
-          stoppers then the final release is packaged and     
-          released on the monday morning on php.net
-
-   Mon:   Release is made.
-
-
-James
---  
-James Moore
-PHP QA Team
-jmoore@php.net
-

TODO

@@ -5,28 +5,21 @@ Zend
 ----
     * allow foreach ($array as $k => &$val) syntax. right now we cannot 
       traverse an array without copying each element.
-    * allow foreach ($array as $k => list($a, $b)) syntax for multi
-      dimensional arrays.
     * look at replacing c-lib call tolower().
     * make hash API functions work with HASH_OF() to save time.
     * native large number support (probably with GNU GMP)
     * Const'ify APIs. Right now, many functions leave parameters untouched,
       but don't declare those as const. This makes interaction with other
       interfaces difficult which pass const parameters to us. 
-    * add try..catch/throw exception handling
 
 global
 ------
-    * when used in standalone (skell-script like) mode don't urldecode
-      arguments passed to php. right now it's not possible to say
-        /usr/local/bin/php somescript.php dog+cat.txt
-      as "dog+cat.txt" will arrive in php as "dog cat.txt". 
     * make everything on the language-level independent of your locale setings.
     * always build the standalone executable as well as the chosen SAPI 
       target.
     * make sure all source files have the "right" copyright.
     * the following modules still use PHP3_TLS_*() macros (and thereby don't 
-      work in ZTS mode): ext/db/db.c, ext/gd/gd.c
+      work in ZTS mode): ext/dav/dav.c, ext/db/db.c, ext/gd/gd.c, ext/ldap/ldap.c
     * make sure that all ZTS globals get destructed. Most ts_allocate_id()
       calls should have a dtor entry.
     * activate all extensions by default that don't rely on external
@@ -55,16 +48,6 @@ documentation
 -------------
     * add remarks in the documentation which functions are not implemented on win32.
     * add remarks in the documentation which functions are not binary-safe.
-    * improve documentation for the sablotron extension
-    * update curl documentation
-    * write documentation for the bzip2 extension
-    * write documentation for the zziplib extension
-
-ext/curl
---------
-    * Use the cURL write handler to save data for use when returning data or outputting
-      data.
-    * Have a warning scheme for when people use unsupported features.
 
 ext/dav
 --------
@@ -74,43 +57,32 @@ ext/oci8
 --------
     * all OCIFetch*() functions should return 0 for no more data and false on error.
     * have a flag that trims trailing spaces from CHAR fields on retrieval.
-    * make allow_call_time_pass_reference=Off working.
-    * for additional todo information, see oci8.c, in ext/oci8
+	* make allow_call_time_pass_reference=Off working.
 
 ext/pcre
 --------
-    * Allow user to set PCRE_NOTEMPTY, PCRE_ANCHORED at execution time, maybe
-    * add option to preg_grep() to return entries that _don't_ match
-
-ext/sablot
-----------
-    * Re-write the error handling and reporting interface
-    * Cleanup the underlying code a bit
-    * Add proper support for the message handlers
+    * update the online docs from version 3.1 man page
 
 ext/session
 -----------
+    * implement a call to set a session read-only to overcome 
+      the need to serialize frame-loads.
     * maybe implement finer-grained session variables that could be 
       locked individually.
     * write a network-transparent storage back-end with fallover
       facilities
-    * provide a callback facility which is executed upon encountering
-      an unknown classname during deserialization
-
-ext/sockets
------------
-    * Make the extension work on windows (Daniel Beulshausen)
-    * Make the extension work with Solaris and the Sun GCC
 
 ext/standard
 ------------
+    * array_mean()
     * add a version number to data serialized via serialize().
     * array_add(). (Andrei)
     * possibly modify parsing of GPC data to automatically create arrays if
       variable name is seen more than once.
     * implement regex-cache for url-functions.
-    * stri_replace(). (Andrei)
+    * strcase_replace(). (Andrei)
     * move socket related functions to fsock.c.
+    * get_defined_funcs(), get_defined_vars().
     * NOT binary safe:
         strtok()
         basename()
@@ -121,10 +93,6 @@ ext/standard
     * rewrite win32 SMTP code to be useable for *ix to, maybe as a (default)
       module of its own (Hartmut)
 
-ext/zziplib
-------------
-    * more fully support the zziplib api
-
 ext/wddx
 --------
     * See if we can support the remaining datatypes:

TODO-4.2.txt

@@ -1,35 +0,0 @@
-* Change the odbc_fetch_into() function to require ALWAYS the first two
-  parameters ($conn_id and $array), and make the third (row) be optional.
-
-* Remove --with-openlink configure option (--with-iodbc replaces it).
-
-* Always build CGI (--disable-cgi option to disable).
-
-* Move most extensions and PEAR packages out of the PHP CVS tree,
-  include them again during release packaging.
-
-* Renaming functions, so that they all are conform to one standard form.
-
-* Allow foreach($array as $key => &$value).
-
-* Allow foreach($array as list($var1, $var2)).
-
-* Clean up "$instance = &new object" syntax (default to the =& behaviour?).
-
-* Allow to set a default value for call-by-reference-parameters. eg:
-  function hallo (&$pallo = NULL) {}
-
-* Change PHP error messages, so that they point to pages or sections in the
-  PHP Manual.
-
-* Fix Zend shallow copy issues with objects and arrays.
-
-* Make all extensions thread-safe.
-
-* Finish PHP streams abstraction, nuke all that issock stuff, implement SSL
-  socket support. (wez)
-  - ext/ftp/ -> all FILEs to streams
-  - ext/bz2/ -> convert to stream impl.
-
-* Using arg_separator.input to implode args in the CGI sapi extension
-  and arg_separator.input to explode in php_build_argv().

TSRM/TSRM.c

@@ -38,6 +38,9 @@ typedef struct {
 } tsrm_resource_type;
 
 
+#define TSRM_SHUFFLE_RSRC_ID(rsrc_id)		((rsrc_id)+1)
+#define TSRM_UNSHUFFLE_RSRC_ID(rsrc_id)		((rsrc_id)-1)
+
 /* The memory manager table */
 static tsrm_tls_entry	**tsrm_tls_table=NULL;
 static int				tsrm_tls_table_size;
@@ -51,66 +54,26 @@ static int					resource_types_table_size;
 static MUTEX_T tsmm_mutex;	/* thread-safe memory manager mutex */
 
 /* New thread handlers */
-static tsrm_thread_begin_func_t tsrm_new_thread_begin_handler;
-static tsrm_thread_end_func_t tsrm_new_thread_end_handler;
+static void (*tsrm_new_thread_begin_handler)();
+static void (*tsrm_new_thread_end_handler)();
 
 /* Debug support */
 int tsrm_error(int level, const char *format, ...);
-
-/* Read a resource from a thread's resource storage */
 static int tsrm_error_level;
 static FILE *tsrm_error_file;
-
 #if TSRM_DEBUG
-#define TSRM_ERROR(args) tsrm_error args
-#define TSRM_SAFE_RETURN_RSRC(array, offset, range)																		\
-	{																													\
-		int unshuffled_offset = TSRM_UNSHUFFLE_RSRC_ID(offset);															\
-																														\
-		if (offset==0) {																								\
-			return &array;																								\
-		} else if ((unshuffled_offset)>=0 && (unshuffled_offset)<(range)) {												\
-			TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Successfully fetched resource id %d for thread id %ld - 0x%0.8X",		\
-						unshuffled_offset, (long) thread_resources->thread_id, array[unshuffled_offset]));				\
-			return array[unshuffled_offset];																			\
-		} else {																										\
-			TSRM_ERROR((TSRM_ERROR_LEVEL_ERROR, "Resource id %d is out of range (%d..%d)",								\
-						unshuffled_offset, TSRM_SHUFFLE_RSRC_ID(0), TSRM_SHUFFLE_RSRC_ID(thread_resources->count-1)));	\
-			return NULL;																								\
-		}																												\
-	}
+#define TSRM_ERROR tsrm_error
+#define TSRM_SAFE_ARRAY_OFFSET(array, offset, range)	(((offset)>=0 && (offset)<(range)) ? array[offset] : NULL)
 #else
 #define TSRM_ERROR
-#define TSRM_SAFE_RETURN_RSRC(array, offset, range)		\
-	if (offset==0) {									\
-		return &array;									\
-	} else {											\
-		return array[TSRM_UNSHUFFLE_RSRC_ID(offset)];	\
-	}
+#define TSRM_SAFE_ARRAY_OFFSET(array, offset, range)	array[offset]
 #endif
 
-#if defined(PTHREADS)
-/* Thread local storage */
-static pthread_key_t tls_key;
-#elif defined(TSRM_ST)
-static int tls_key;
-#elif defined(TSRM_WIN32)
-static DWORD tls_key;
-#endif
-
-
 /* Startup TSRM (call once for the entire process) */
 TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debug_level, char *debug_filename)
 {
 #if defined(GNUPTH)
 	pth_init();
-#elif defined(PTHREADS)
-	pthread_key_create( &tls_key, 0 );
-#elif defined(TSRM_ST)
-	st_init();
-	st_key_create(&tls_key, 0);
-#elif defined(TSRM_WIN32)
-	tls_key = TlsAlloc();
 #endif
 
 	tsrm_error_file = stderr;
@@ -119,7 +82,7 @@ TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debu
 
 	tsrm_tls_table = (tsrm_tls_entry **) calloc(tsrm_tls_table_size, sizeof(tsrm_tls_entry *));
 	if (!tsrm_tls_table) {
-		TSRM_ERROR((TSRM_ERROR_LEVEL_ERROR, "Unable to allocate TLS table"));
+		TSRM_ERROR(TSRM_ERROR_LEVEL_ERROR, "Unable to allocate TLS table");
 		return 0;
 	}
 	id_count=0;
@@ -127,7 +90,7 @@ TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debu
 	resource_types_table_size = expected_resources;
 	resource_types_table = (tsrm_resource_type *) calloc(resource_types_table_size, sizeof(tsrm_resource_type));
 	if (!resource_types_table) {
-		TSRM_ERROR((TSRM_ERROR_LEVEL_ERROR, "Unable to allocate resource types table"));
+		TSRM_ERROR(TSRM_ERROR_LEVEL_ERROR, "Unable to allocate resource types table");
 		free(tsrm_tls_table);
 		tsrm_tls_table = NULL;
 		return 0;
@@ -137,7 +100,7 @@ TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debu
 
 	tsrm_new_thread_begin_handler = tsrm_new_thread_end_handler = NULL;
 
-	TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Started up TSRM, %d expected threads, %d expected resources", expected_threads, expected_resources));
+	TSRM_ERROR(TSRM_ERROR_LEVEL_CORE, "Started up TSRM, %d expected threads, %d expected resources", expected_threads, expected_resources);
 	return 1;
 }
 
@@ -172,47 +135,43 @@ TSRM_API void tsrm_shutdown(void)
 	}
 	tsrm_mutex_free(tsmm_mutex);
 	tsmm_mutex = NULL;
-	TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Shutdown TSRM"));
+	TSRM_ERROR(TSRM_ERROR_LEVEL_CORE, "Shutdown TSRM");
 	if (tsrm_error_file!=stderr) {
 		fclose(tsrm_error_file);
 	}
 #if defined(GNUPTH)
 	pth_kill();
-#elif defined(PTHREADS)
-	pthread_key_delete(tls_key);
-#elif defined(TSRM_WIN32)
-	TlsFree(tls_key);
 #endif
 }
 
 
 /* allocates a new thread-safe-resource id */
-TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor)
+TSRM_API ts_rsrc_id ts_allocate_id(size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor)
 {
+	ts_rsrc_id new_id;
 	int i;
 
-	TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Obtaining a new resource id, %d bytes", size));
+	TSRM_ERROR(TSRM_ERROR_LEVEL_CORE, "Obtaining a new resource id, %d bytes", size);
 
 	tsrm_mutex_lock(tsmm_mutex);
 
 	/* obtain a resource id */
-	*rsrc_id = TSRM_SHUFFLE_RSRC_ID(id_count++);
-	TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Obtained resource id %d", *rsrc_id));
+	new_id = id_count++;
+	TSRM_ERROR(TSRM_ERROR_LEVEL_CORE, "Obtained resource id %d", TSRM_SHUFFLE_RSRC_ID(new_id));
 
 	/* store the new resource type in the resource sizes table */
 	if (resource_types_table_size < id_count) {
 		resource_types_table = (tsrm_resource_type *) realloc(resource_types_table, sizeof(tsrm_resource_type)*id_count);
 		if (!resource_types_table) {
 			tsrm_mutex_unlock(tsmm_mutex);
-			TSRM_ERROR((TSRM_ERROR_LEVEL_ERROR, "Unable to allocate storage for resource"));
-			*rsrc_id = 0;
+			TSRM_ERROR(TSRM_ERROR_LEVEL_ERROR, "Unable to allocate storage for resource");
 			return 0;
 		}
 		resource_types_table_size = id_count;
 	}
-	resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].size = size;
-	resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].ctor = ctor;
-	resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].dtor = dtor;
+	resource_types_table[new_id].size = size;
+	resource_types_table[new_id].ctor = ctor;
+	resource_types_table[new_id].dtor = dtor;
 
 	/* enlarge the arrays for the already active threads */
 	for (i=0; i<tsrm_tls_table_size; i++) {
@@ -226,7 +185,7 @@ TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, size_t size, ts_allocate
 				for (j=p->count; j<id_count; j++) {
 					p->storage[j] = (void *) malloc(resource_types_table[j].size);
 					if (resource_types_table[j].ctor) {
-						resource_types_table[j].ctor(p->storage[j], &p->storage);
+						resource_types_table[j].ctor(p->storage[j]);
 					}
 				}
 				p->count = id_count;
@@ -236,8 +195,8 @@ TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, size_t size, ts_allocate
 	}
 	tsrm_mutex_unlock(tsmm_mutex);
 
-	TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Successfully allocated new resource id %d", *rsrc_id));
-	return *rsrc_id;
+	TSRM_ERROR(TSRM_ERROR_LEVEL_CORE, "Successfully allocated new resource id %d", TSRM_SHUFFLE_RSRC_ID(new_id));
+	return TSRM_SHUFFLE_RSRC_ID(new_id);
 }
 
 
@@ -245,36 +204,26 @@ static void allocate_new_resource(tsrm_tls_entry **thread_resources_ptr, THREAD_
 {
 	int i;
 
-	TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Creating data structures for thread %x", thread_id));
+	TSRM_ERROR(TSRM_ERROR_LEVEL_CORE, "Creating data structures for thread %x", thread_id);
 	(*thread_resources_ptr) = (tsrm_tls_entry *) malloc(sizeof(tsrm_tls_entry));
 	(*thread_resources_ptr)->storage = (void **) malloc(sizeof(void *)*id_count);
 	(*thread_resources_ptr)->count = id_count;
 	(*thread_resources_ptr)->thread_id = thread_id;
 	(*thread_resources_ptr)->next = NULL;
 
-#if defined(PTHREADS)
-	/* Set thread local storage to this new thread resources structure */
-	pthread_setspecific(tls_key, (void *) *thread_resources_ptr);
-#elif defined(TSRM_ST)
-	st_thread_setspecific(tls_key, (void *) *thread_resources_ptr);
-#elif defined(TSRM_WIN32)
-	TlsSetValue(tls_key, (void *) *thread_resources_ptr);
-#endif
+	tsrm_mutex_unlock(tsmm_mutex);
 
 	if (tsrm_new_thread_begin_handler) {
-		tsrm_new_thread_begin_handler(thread_id, &((*thread_resources_ptr)->storage));
+		tsrm_new_thread_begin_handler(thread_id);
 	}
 	for (i=0; i<id_count; i++) {
 		(*thread_resources_ptr)->storage[i] = (void *) malloc(resource_types_table[i].size);
 		if (resource_types_table[i].ctor) {
-			resource_types_table[i].ctor((*thread_resources_ptr)->storage[i], &(*thread_resources_ptr)->storage);
+			resource_types_table[i].ctor((*thread_resources_ptr)->storage[i]);
 		}
 	}
-
-	tsrm_mutex_unlock(tsmm_mutex);
-
 	if (tsrm_new_thread_end_handler) {
-		tsrm_new_thread_end_handler(thread_id, &((*thread_resources_ptr)->storage));
+		tsrm_new_thread_end_handler(thread_id);
 	}
 }
 
@@ -285,36 +234,14 @@ TSRM_API void *ts_resource_ex(ts_rsrc_id id, THREAD_T *th_id)
 	THREAD_T thread_id;
 	int hash_value;
 	tsrm_tls_entry *thread_resources;
+	void *resource;
 
-	if (!th_id) {
-#if defined(PTHREADS)
-		/* Fast path for looking up the resources for the current
-		 * thread. Its used by just about every call to
-		 * ts_resource_ex(). This avoids the need for a mutex lock
-		 * and our hashtable lookup.
-		 */
-		thread_resources = pthread_getspecific(tls_key);
-#elif defined(TSRM_ST)
-		thread_resources = st_thread_getspecific(tls_key);
-#elif defined(TSRM_WIN32)
-		thread_resources = TlsGetValue(tls_key);
-#else
-		thread_resources = NULL;
-#endif
-		if (thread_resources) {
-			TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Fetching resource id %d for current thread %d", id, (long) thread_resources->thread_id));
-			/* Read a specific resource from the thread's resources.
-			 * This is called outside of a mutex, so have to be aware about external
-			 * changes to the structure as we read it.
-			 */
-			TSRM_SAFE_RETURN_RSRC(thread_resources->storage, id, thread_resources->count);
-		}
-		thread_id = tsrm_thread_id();
-	} else {
+	if (th_id) {
 		thread_id = *th_id;
+	} else {
+		thread_id = tsrm_thread_id();
 	}
-
-	TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Fetching resource id %d for thread %ld", id, (long) thread_id));
+	TSRM_ERROR(TSRM_ERROR_LEVEL_INFO, "Fetching resource id %d for thread %ld", id, (long) thread_id);
 	tsrm_mutex_lock(tsmm_mutex);
 
 	hash_value = THREAD_HASH_OF(thread_id, tsrm_tls_table_size);
@@ -322,7 +249,8 @@ TSRM_API void *ts_resource_ex(ts_rsrc_id id, THREAD_T *th_id)
 
 	if (!thread_resources) {
 		allocate_new_resource(&tsrm_tls_table[hash_value], thread_id);
-		return ts_resource_ex(id, &thread_id);
+		return ts_resource(id);
+		/* thread_resources = tsrm_tls_table[hash_value]; */
 	} else {
 		 do {
 			if (thread_resources->thread_id == thread_id) {
@@ -332,7 +260,7 @@ TSRM_API void *ts_resource_ex(ts_rsrc_id id, THREAD_T *th_id)
 				thread_resources = thread_resources->next;
 			} else {
 				allocate_new_resource(&thread_resources->next, thread_id);
-				return ts_resource_ex(id, &thread_id);
+				return ts_resource(id);
 				/*
 				 * thread_resources = thread_resources->next;
 				 * break;
@@ -340,22 +268,26 @@ TSRM_API void *ts_resource_ex(ts_rsrc_id id, THREAD_T *th_id)
 			}
 		 } while (thread_resources);
 	}
+
+	resource = TSRM_SAFE_ARRAY_OFFSET(thread_resources->storage, TSRM_UNSHUFFLE_RSRC_ID(id), thread_resources->count);
+
 	tsrm_mutex_unlock(tsmm_mutex);
-	/* Read a specific resource from the thread's resources.
-	 * This is called outside of a mutex, so have to be aware about external
-	 * changes to the structure as we read it.
-	 */
-	TSRM_SAFE_RETURN_RSRC(thread_resources->storage, id, thread_resources->count);
+
+	if (resource) {
+		TSRM_ERROR(TSRM_ERROR_LEVEL_INFO, "Successfully fetched resource id %d for thread id %ld - %x", id, (long) thread_id, (long) resource);
+	} else {
+		TSRM_ERROR(TSRM_ERROR_LEVEL_ERROR, "Resource id %d is out of range (%d..%d)", id, TSRM_SHUFFLE_RSRC_ID(0), TSRM_SHUFFLE_RSRC_ID(thread_resources->count-1));
+	}
+	return resource;
 }
 
 
 /* frees all resources allocated for the current thread */
 void ts_free_thread(void)
 {
-	tsrm_tls_entry *thread_resources;
-	int i;
 	THREAD_T thread_id = tsrm_thread_id();
 	int hash_value;
+	tsrm_tls_entry *thread_resources;
 	tsrm_tls_entry *last=NULL;
 
 	tsrm_mutex_lock(tsmm_mutex);
@@ -364,25 +296,20 @@ void ts_free_thread(void)
 
 	while (thread_resources) {
 		if (thread_resources->thread_id == thread_id) {
+			int i;
+
 			for (i=0; i<thread_resources->count; i++) {
 				if (resource_types_table[i].dtor) {
-					resource_types_table[i].dtor(thread_resources->storage[i], &thread_resources->storage);
+					resource_types_table[i].dtor(thread_resources->storage[i]);
 				}
-			}
-			for (i=0; i<thread_resources->count; i++) {
 				free(thread_resources->storage[i]);
 			}
 			free(thread_resources->storage);
 			if (last) {
 				last->next = thread_resources->next;
 			} else {
-				tsrm_tls_table[hash_value] = thread_resources->next;
+				tsrm_tls_table[hash_value]=NULL;
 			}
-#if defined(PTHREADS)
-			pthread_setspecific(tls_key, 0);
-#elif defined(TSRM_WIN32)
-			TlsSetValue(tls_key, 0);
-#endif
 			free(thread_resources);
 			break;
 		}
@@ -420,8 +347,6 @@ TSRM_API THREAD_T tsrm_thread_id(void)
 	return systhread_current();
 #elif defined(PI3WEB)
 	return PIThread_getCurrent();
-#elif defined(TSRM_ST)
-	return st_thread_self();
 #endif
 }
 
@@ -444,8 +369,6 @@ TSRM_API MUTEX_T tsrm_mutex_alloc(void)
 	mutexp = crit_init();
 #elif defined(PI3WEB)
 	mutexp = PIPlatform_allocLocalMutex();
-#elif defined(TSRM_ST)
-	mutexp = st_mutex_new();
 #endif
 #ifdef THR_DEBUG
 		printf("Mutex created thread: %d\n",mythreadid());
@@ -468,9 +391,7 @@ TSRM_API void tsrm_mutex_free(MUTEX_T mutexp)
 #elif defined(NSAPI)
 		crit_terminate(mutexp);
 #elif defined(PI3WEB)
-		PISync_delete(mutexp);
-#elif defined(TSRM_ST)
-		st_mutex_destroy(mutexp);
+		PISync_delete(mutexp) 
 #endif
     }
 #ifdef THR_DEBUG
@@ -482,7 +403,7 @@ TSRM_API void tsrm_mutex_free(MUTEX_T mutexp)
 /* Lock a mutex */
 TSRM_API int tsrm_mutex_lock(MUTEX_T mutexp)
 {
-	TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Mutex locked thread: %ld", tsrm_thread_id()));
+	TSRM_ERROR(TSRM_ERROR_LEVEL_INFO, "Mutex locked thread: %ld", tsrm_thread_id());
 #ifdef TSRM_WIN32
 	EnterCriticalSection(mutexp);
 	return 1;
@@ -494,8 +415,6 @@ TSRM_API int tsrm_mutex_lock(MUTEX_T mutexp)
 	return crit_enter(mutexp);
 #elif defined(PI3WEB)
 	return PISync_lock(mutexp);
-#elif defined(TSRM_ST)
-	return st_mutex_lock(mutexp);
 #endif
 }
 
@@ -503,7 +422,7 @@ TSRM_API int tsrm_mutex_lock(MUTEX_T mutexp)
 /* Unlock a mutex */
 TSRM_API int tsrm_mutex_unlock(MUTEX_T mutexp)
 {
-	TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Mutex unlocked thread: %ld", tsrm_thread_id()));
+	TSRM_ERROR(TSRM_ERROR_LEVEL_INFO, "Mutex unlocked thread: %ld", tsrm_thread_id());
 #ifdef TSRM_WIN32
 	LeaveCriticalSection(mutexp);
 	return 1;
@@ -515,13 +434,11 @@ TSRM_API int tsrm_mutex_unlock(MUTEX_T mutexp)
 	return crit_exit(mutexp);
 #elif defined(PI3WEB)
 	return PISync_unlock(mutexp);
-#elif defined(TSRM_ST)
-	return st_mutex_unlock(mutexp);
 #endif
 }
 
 
-TSRM_API void *tsrm_set_new_thread_begin_handler(tsrm_thread_begin_func_t new_thread_begin_handler)
+TSRM_API void *tsrm_set_new_thread_begin_handler(void (*new_thread_begin_handler)(THREAD_T thread_id))
 {
 	void *retval = (void *) tsrm_new_thread_begin_handler;
 
@@ -530,7 +447,7 @@ TSRM_API void *tsrm_set_new_thread_begin_handler(tsrm_thread_begin_func_t new_th
 }
 
 
-TSRM_API void *tsrm_set_new_thread_end_handler(tsrm_thread_end_func_t new_thread_end_handler)
+TSRM_API void *tsrm_set_new_thread_end_handler(void (*new_thread_end_handler)(THREAD_T thread_id))
 {
 	void *retval = (void *) tsrm_new_thread_end_handler;
 

TSRM/TSRM.dsp

@@ -20,7 +20,6 @@ CFG=TSRM - Win32 Debug_TS
 !MESSAGE "TSRM - Win32 Debug_TS" (based on "Win32 (x86) Static Library")
 !MESSAGE "TSRM - Win32 Release_TS" (based on "Win32 (x86) Static Library")
 !MESSAGE "TSRM - Win32 Release_TS_inline" (based on "Win32 (x86) Static Library")
-!MESSAGE "TSRM - Win32 Release_TSDbg" (based on "Win32 (x86) Static Library")
 !MESSAGE 
 
 # Begin Project
@@ -99,29 +98,6 @@ LIB32=link.exe -lib
 # ADD BASE LIB32 /nologo
 # ADD LIB32 /nologo
 
-!ELSEIF  "$(CFG)" == "TSRM - Win32 Release_TSDbg"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "TSRM___Win32_Release_TSDbg"
-# PROP BASE Intermediate_Dir "TSRM___Win32_Release_TSDbg"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release_TSDbg"
-# PROP Intermediate_Dir "Release_TSDbg"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDEBUG" /D "ZTS" /D "_LIB" /D "TSRM_EXPORTS" /D "WIN32" /D "_MBCS" /D TSRM_DEBUG=0 /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /Zi /Od /I "." /D "NDEBUG" /D "ZTS" /D "_LIB" /D "TSRM_EXPORTS" /D "WIN32" /D "_MBCS" /D TSRM_DEBUG=0 /YX /FD /c
-# ADD BASE RSC /l 0x40d /d "NDEBUG"
-# ADD RSC /l 0x40d /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-
 !ENDIF 
 
 # Begin Target
@@ -129,7 +105,6 @@ LIB32=link.exe -lib
 # Name "TSRM - Win32 Debug_TS"
 # Name "TSRM - Win32 Release_TS"
 # Name "TSRM - Win32 Release_TS_inline"
-# Name "TSRM - Win32 Release_TSDbg"
 # Begin Group "Source Files"
 
 # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
@@ -145,20 +120,12 @@ SOURCE=.\tsrm_strtok_r.c
 
 SOURCE=.\tsrm_virtual_cwd.c
 # End Source File
-# Begin Source File
-
-SOURCE=.\tsrm_win32.c
-# End Source File
 # End Group
 # Begin Group "Header Files"
 
 # PROP Default_Filter "h;hpp;hxx;hm;inl"
 # Begin Source File
 
-SOURCE=.\readdir.h
-# End Source File
-# Begin Source File
-
 SOURCE=.\TSRM.h
 # End Source File
 # Begin Source File
@@ -177,10 +144,6 @@ SOURCE=.\tsrm_strtok_r.h
 
 SOURCE=.\tsrm_virtual_cwd.h
 # End Source File
-# Begin Source File
-
-SOURCE=.\tsrm_win32.h
-# End Source File
 # End Group
 # End Target
 # End Project

TSRM/TSRM.h

@@ -17,10 +17,23 @@
 # include "tsrm_config.h"
 #endif
 
+/* Only compile multi-threading functions if we're in ZTS mode */
+#ifdef ZTS
+
 #ifdef WIN32
 # define TSRM_WIN32
 #endif
 
+#ifdef TSRM_WIN32
+# include <windows.h>
+#elif defined(GNUPTH)
+# include <pth.h>
+#elif defined(PTHREADS)
+# include <pthread.h>
+#endif
+
+typedef int ts_rsrc_id;
+
 #ifdef TSRM_WIN32
 #	ifdef TSRM_EXPORTS
 #	define TSRM_API __declspec(dllexport)
@@ -31,20 +44,6 @@
 #	define TSRM_API
 #endif
 
-/* Only compile multi-threading functions if we're in ZTS mode */
-#ifdef ZTS
-
-#ifdef TSRM_WIN32
-# include <windows.h>
-#elif defined(GNUPTH)
-# include <pth.h>
-#elif defined(PTHREADS)
-# include <pthread.h>
-#elif defined(TSRM_ST)
-# include <st.h>
-#endif
-
-typedef int ts_rsrc_id;
 
 /* Define THREAD_T and MUTEX_T */
 #ifdef TSRM_WIN32
@@ -62,13 +61,10 @@ typedef int ts_rsrc_id;
 #elif defined(PI3WEB)
 # define THREAD_T PIThread *
 # define MUTEX_T PISync *
-#elif defined(TSRM_ST)
-# define THREAD_T st_thread_t
-# define MUTEX_T st_mutex_t
 #endif
 
-typedef void (*ts_allocate_ctor)(void *, void ***);
-typedef void (*ts_allocate_dtor)(void *, void ***);
+typedef void (*ts_allocate_ctor)(void *);
+typedef void (*ts_allocate_dtor)(void *);
 
 #define THREAD_HASH_OF(thr,ts)  (unsigned long)thr%(unsigned long)ts
 
@@ -81,7 +77,7 @@ TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debu
 TSRM_API void tsrm_shutdown(void);
 
 /* allocates a new thread-safe-resource id */
-TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor);
+TSRM_API ts_rsrc_id ts_allocate_id(size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor);
 
 /* fetches the requested resource for the current thread */
 TSRM_API void *ts_resource_ex(ts_rsrc_id id, THREAD_T *th_id);
@@ -98,11 +94,6 @@ TSRM_API void ts_free_id(ts_rsrc_id id);
 #define TSRM_ERROR_LEVEL_ERROR	1
 #define TSRM_ERROR_LEVEL_CORE	2
 #define TSRM_ERROR_LEVEL_INFO	3
-
-typedef void (*tsrm_thread_begin_func_t)(THREAD_T thread_id, void ***tsrm_ls);
-typedef void (*tsrm_thread_end_func_t)(THREAD_T thread_id, void ***tsrm_ls);
-
-
 TSRM_API int tsrm_error(int level, const char *format, ...);
 TSRM_API void tsrm_error_set(int level, char *debug_filename);
 
@@ -113,31 +104,13 @@ TSRM_API void tsrm_mutex_free(MUTEX_T mutexp);
 TSRM_API int tsrm_mutex_lock(MUTEX_T mutexp);
 TSRM_API int tsrm_mutex_unlock(MUTEX_T mutexp);
 
-TSRM_API void *tsrm_set_new_thread_begin_handler(tsrm_thread_begin_func_t new_thread_begin_handler);
-TSRM_API void *tsrm_set_new_thread_end_handler(tsrm_thread_end_func_t new_thread_end_handler);
-
-#define TSRM_SHUFFLE_RSRC_ID(rsrc_id)		((rsrc_id)+1)
-#define TSRM_UNSHUFFLE_RSRC_ID(rsrc_id)		((rsrc_id)-1)
-
-#define TSRMLS_FETCH()			void ***tsrm_ls = (void ***) ts_resource_ex(0, NULL)
-#define TSRMG(id, type, element)	(((type) (*((void ***) tsrm_ls))[TSRM_UNSHUFFLE_RSRC_ID(id)])->element)
-#define TSRMLS_D	void ***tsrm_ls
-#define TSRMLS_DC	, TSRMLS_D
-#define TSRMLS_C	tsrm_ls
-#define TSRMLS_CC	, TSRMLS_C
+TSRM_API void *tsrm_set_new_thread_begin_handler(void (*new_thread_begin_handler)(THREAD_T thread_id));
+TSRM_API void *tsrm_set_new_thread_end_handler(void (*new_thread_end_handler)(THREAD_T thread_id));
 
 #ifdef __cplusplus
 }
 #endif
 
-#else /* non ZTS */
-
-#define TSRMLS_FETCH()
-#define TSRMLS_D	void
-#define TSRMLS_DC
-#define TSRMLS_C
-#define TSRMLS_CC
-
 #endif /* ZTS */
 
 #endif /* TSRM_H */

TSRM/configure.in

@@ -28,4 +28,6 @@ unistd.h \
 limits.h
 )
 
+AC_DEFINE(ZTS,1,[ ])
+
 AC_OUTPUT(Makefile)

TSRM/tsrm.m4

@@ -50,23 +50,6 @@ AC_MSG_RESULT(yes - installed in $PTH_PREFIX)
 
 ])
 
-AC_DEFUN(TSRM_CHECK_ST,[
-  if test -r "$1/include/st.h"; then
-    CPPFLAGS="$CPPFLAGS -I$1/include"
-    LDFLAGS="$LDFLAGS -L$1/lib"
-  elif test -r "$1/st.h"; then
-    CPPFLAGS="$CPPFLAGS -I$1"
-    LDFLAGS="$LDFLAGS -L$1"
-  fi
-  AC_CHECK_HEADERS(st.h,[ ],[
-    AC_MSG_ERROR([Sorry[,] I was unable to locate the State Threads header file.  Please specify the prefix using --with-tsrm-st=/prefix])
-  ])
-  LIBS="$LIBS -lst"
-  AC_MSG_CHECKING(for SGI's State Threads)
-  AC_MSG_RESULT(yes)
-  AC_DEFINE(TSRM_ST, 1, [ ])
-])
-
 sinclude(threads.m4)
 sinclude(TSRM/threads.m4)
 
@@ -97,13 +80,6 @@ AC_ARG_WITH(tsrm-pth,
   TSRM_PTH=no
 ])
 
-AC_ARG_WITH(tsrm-st,
-[  --with-tsrm-st],[
-  TSRM_ST=$withval
-],[
-  TSRM_ST=no
-])
-
 AC_ARG_WITH(tsrm-pthreads,
 [  --with-tsrm-pthreads    Use POSIX threads (default)],[
   TSRM_PTHREADS=$withval
@@ -115,8 +91,6 @@ test "$TSRM_PTH" = "yes" && TSRM_PTH=pth-config
 
 if test "$TSRM_PTH" != "no"; then
   TSRM_CHECK_PTH($TSRM_PTH)
-elif test "$TSRM_ST" != "no"; then
-  TSRM_CHECK_ST($TSRM_ST)
 elif test "$TSRM_PTHREADS" != "no"; then
   TSRM_CHECK_PTHREADS
 fi

TSRM/tsrm_virtual_cwd.c

@@ -33,12 +33,13 @@
 
 #ifdef TSRM_WIN32
 #include <io.h>
-#include "tsrm_win32.h"
 #endif
 
 #define VIRTUAL_CWD_DEBUG 0
 
+#ifdef ZTS
 #include "TSRM.h"
+#endif
 
 /* Only need mutex for popen() in Windows because it doesn't chdir() on UNIX */
 #if defined(TSRM_WIN32) && defined(ZTS)
@@ -138,12 +139,12 @@ static int php_is_file_ok(const cwd_state *state)
 	return (1);
 }
 
-static void cwd_globals_ctor(virtual_cwd_globals *cwd_globals TSRMLS_DC)
+static void cwd_globals_ctor(virtual_cwd_globals *cwd_globals)
 {
 	CWD_STATE_COPY(&cwd_globals->cwd, &main_cwd_state);
 }
 
-static void cwd_globals_dtor(virtual_cwd_globals *cwd_globals TSRMLS_DC)
+static void cwd_globals_dtor(virtual_cwd_globals *cwd_globals)
 {
 	CWD_STATE_FREE(&cwd_globals->cwd);
 }
@@ -176,9 +177,9 @@ CWD_API void virtual_cwd_startup(void)
 	main_cwd_state.cwd_length = strlen(cwd);
 
 #ifdef ZTS
-	ts_allocate_id(&cwd_globals_id, sizeof(virtual_cwd_globals), (ts_allocate_ctor) cwd_globals_ctor, (ts_allocate_dtor) cwd_globals_dtor);
+	cwd_globals_id = ts_allocate_id(sizeof(virtual_cwd_globals), (ts_allocate_ctor) cwd_globals_ctor, (ts_allocate_dtor) cwd_globals_dtor);
 #else
-	cwd_globals_ctor(&cwd_globals TSRMLS_CC);
+	cwd_globals_ctor(&cwd_globals);
 #endif
 
 #if defined(TSRM_WIN32) && defined(ZTS)
@@ -189,7 +190,7 @@ CWD_API void virtual_cwd_startup(void)
 CWD_API void virtual_cwd_shutdown(void)
 {
 #ifndef ZTS
-	cwd_globals_dtor(&cwd_globals TSRMLS_CC);
+	cwd_globals_dtor(&cwd_globals);
 #endif
 #if defined(TSRM_WIN32) && defined(ZTS)
 	tsrm_mutex_free(cwd_mutex);
@@ -198,9 +199,10 @@ CWD_API void virtual_cwd_shutdown(void)
 	free(main_cwd_state.cwd); /* Don't use CWD_STATE_FREE because the non global states will probably use emalloc()/efree() */
 }
 
-CWD_API char *virtual_getcwd_ex(size_t *length TSRMLS_DC)
+CWD_API char *virtual_getcwd_ex(size_t *length)
 {
 	cwd_state *state;
+	CWDLS_FETCH();
 
 	state = &CWDG(cwd);
 
@@ -233,12 +235,12 @@ CWD_API char *virtual_getcwd_ex(size_t *length TSRMLS_DC)
 
 
 /* Same semantics as UNIX getcwd() */
-CWD_API char *virtual_getcwd(char *buf, size_t size TSRMLS_DC)
+CWD_API char *virtual_getcwd(char *buf, size_t size)
 {
 	size_t length;
 	char *cwd;
 
-	cwd = virtual_getcwd_ex(&length TSRMLS_CC);
+	cwd = virtual_getcwd_ex(&length);
 
 	if (buf == NULL) {
 		return cwd;
@@ -273,7 +275,7 @@ CWD_API int virtual_file_ex(cwd_state *state, const char *path, verify_path_func
 	if (path_length == 0) 
 		return (0);
 
-#if !defined(TSRM_WIN32) && !defined(__BEOS__)
+#ifndef TSRM_WIN32
 	if (IS_ABSOLUTE_PATH(path, path_length)) {
 		if (realpath(path, resolved_path)) {
 			path = resolved_path;
@@ -311,10 +313,7 @@ CWD_API int virtual_file_ex(cwd_state *state, const char *path, verify_path_func
 		copy_amount = COPY_WHEN_ABSOLUTE;
 		is_absolute = 1;
 #ifdef TSRM_WIN32
-	} else if (IS_UNC_PATH(path_copy, path_length)) {
-		copy_amount = 2;
-		is_absolute = 1;
-	} else if (IS_SLASH(path_copy[0])) {
+	} else if(IS_SLASH(path_copy[0])) {
 		copy_amount = 2;
 #endif
 	}
@@ -361,16 +360,9 @@ CWD_API int virtual_file_ex(cwd_state *state, const char *path, verify_path_func
 			}
 		} else if (!IS_DIRECTORY_CURRENT(ptr, ptr_length)) {
 			state->cwd = (char *) realloc(state->cwd, state->cwd_length+ptr_length+1+1);
-#ifdef TSRM_WIN32
-			/* Windows 9x will consider C:\\Foo as a network path. Avoid it. */
-			if (state->cwd[state->cwd_length-1]!='\\' && state->cwd[state->cwd_length-1]!='/') {
-				state->cwd[state->cwd_length++] = DEFAULT_SLASH;
-			}
-#else
-			state->cwd[state->cwd_length++] = DEFAULT_SLASH;
-#endif
-			memcpy(&state->cwd[state->cwd_length], ptr, ptr_length+1);
-			state->cwd_length += ptr_length;
+			state->cwd[state->cwd_length] = DEFAULT_SLASH;
+			memcpy(&state->cwd[state->cwd_length+1], ptr, ptr_length+1);
+			state->cwd_length += (ptr_length+1);
 		}
 		ptr = tsrm_strtok_r(NULL, TOKENIZER_STRING, &tok);
 	}
@@ -402,12 +394,14 @@ CWD_API int virtual_file_ex(cwd_state *state, const char *path, verify_path_func
 	return (ret);
 }
 
-CWD_API int virtual_chdir(const char *path TSRMLS_DC)
+CWD_API int virtual_chdir(const char *path)
 {
+	CWDLS_FETCH();
+
 	return virtual_file_ex(&CWDG(cwd), path, php_is_dir_ok)?-1:0;
 }
 
-CWD_API int virtual_chdir_file(const char *path, int (*p_chdir)(const char *path TSRMLS_DC) TSRMLS_DC)
+CWD_API int virtual_chdir_file(const char *path, int (*p_chdir)(const char *path))
 {
 	int length = strlen(path);
 	char *temp;
@@ -434,15 +428,16 @@ CWD_API int virtual_chdir_file(const char *path, int (*p_chdir)(const char *path
 #if VIRTUAL_CWD_DEBUG
 	fprintf (stderr, "Changing directory to %s\n", temp);
 #endif
-	retval = p_chdir(temp TSRMLS_CC);
+	retval = p_chdir(temp);
 	tsrm_free_alloca(temp);
 	return retval;
 }
 
-CWD_API char *virtual_realpath(const char *path, char *real_path TSRMLS_DC)
+CWD_API char *virtual_realpath(const char *path, char *real_path)
 {
 	cwd_state new_state;
 	int retval;
+    CWDLS_FETCH();
 
 	CWD_STATE_COPY(&new_state, &CWDG(cwd));
 	retval = virtual_file_ex(&new_state, path, NULL);
@@ -457,10 +452,11 @@ CWD_API char *virtual_realpath(const char *path, char *real_path TSRMLS_DC)
 	return NULL;
 }
 
-CWD_API int virtual_filepath_ex(const char *path, char **filepath, verify_path_func verify_path TSRMLS_DC)
+CWD_API int virtual_filepath_ex(const char *path, char **filepath, verify_path_func verify_path)
 {
 	cwd_state new_state;
 	int retval;
+	CWDLS_FETCH();
 
 	CWD_STATE_COPY(&new_state, &CWDG(cwd));
 	retval = virtual_file_ex(&new_state, path, verify_path);
@@ -471,15 +467,16 @@ CWD_API int virtual_filepath_ex(const char *path, char **filepath, verify_path_f
 
 }
 
-CWD_API int virtual_filepath(const char *path, char **filepath TSRMLS_DC)
+CWD_API int virtual_filepath(const char *path, char **filepath)
 {
-	return virtual_filepath_ex(path, filepath, php_is_file_ok TSRMLS_CC);
+	return virtual_filepath_ex(path, filepath, php_is_file_ok);
 }
 
-CWD_API FILE *virtual_fopen(const char *path, const char *mode TSRMLS_DC)
+CWD_API FILE *virtual_fopen(const char *path, const char *mode)
 {
 	cwd_state new_state;
 	FILE *f;
+	CWDLS_FETCH();
 
 	if (path[0] == '\0') { /* Fail to open empty path */
 		return NULL;
@@ -495,10 +492,11 @@ CWD_API FILE *virtual_fopen(const char *path, const char *mode TSRMLS_DC)
 }
 
 #if HAVE_UTIME
-CWD_API int virtual_utime(const char *filename, struct utimbuf *buf TSRMLS_DC)
+CWD_API int virtual_utime(const char *filename, struct utimbuf *buf)
 {
 	cwd_state new_state;
 	int ret;
+	CWDLS_FETCH();
 
 	CWD_STATE_COPY(&new_state, &CWDG(cwd));
 	virtual_file_ex(&new_state, filename, NULL);
@@ -510,10 +508,11 @@ CWD_API int virtual_utime(const char *filename, struct utimbuf *buf TSRMLS_DC)
 }
 #endif
 
-CWD_API int virtual_chmod(const char *filename, mode_t mode TSRMLS_DC)
+CWD_API int virtual_chmod(const char *filename, mode_t mode)
 {
 	cwd_state new_state;
 	int ret;
+	CWDLS_FETCH();
 
 	CWD_STATE_COPY(&new_state, &CWDG(cwd));
 	virtual_file_ex(&new_state, filename, NULL);
@@ -525,10 +524,11 @@ CWD_API int virtual_chmod(const char *filename, mode_t mode TSRMLS_DC)
 }
 
 #ifndef TSRM_WIN32
-CWD_API int virtual_chown(const char *filename, uid_t owner, gid_t group TSRMLS_DC)
+CWD_API int virtual_chown(const char *filename, uid_t owner, gid_t group)
 {
 	cwd_state new_state;
 	int ret;
+	CWDLS_FETCH();
 
 	CWD_STATE_COPY(&new_state, &CWDG(cwd));
 	virtual_file_ex(&new_state, filename, NULL);
@@ -540,10 +540,11 @@ CWD_API int virtual_chown(const char *filename, uid_t owner, gid_t group TSRMLS_
 }
 #endif
 
-CWD_API int virtual_open(const char *path TSRMLS_DC, int flags, ...)
+CWD_API int virtual_open(const char *path, int flags, ...)
 {
 	cwd_state new_state;
 	int f;
+	CWDLS_FETCH();
 
 	CWD_STATE_COPY(&new_state, &CWDG(cwd));
 	virtual_file_ex(&new_state, path, NULL);
@@ -553,7 +554,7 @@ CWD_API int virtual_open(const char *path TSRMLS_DC, int flags, ...)
 		va_list arg;
 
 		va_start(arg, flags);
-		mode = (mode_t) va_arg(arg, int);
+		mode = va_arg(arg, mode_t);
 		va_end(arg);
 
 		f = open(new_state.cwd, flags, mode);
@@ -564,10 +565,11 @@ CWD_API int virtual_open(const char *path TSRMLS_DC, int flags, ...)
 	return f;
 }
 
-CWD_API int virtual_creat(const char *path, mode_t mode TSRMLS_DC)
+CWD_API int virtual_creat(const char *path, mode_t mode)
 {
 	cwd_state new_state;
 	int f;
+	CWDLS_FETCH();
 
 	CWD_STATE_COPY(&new_state, &CWDG(cwd));
 	virtual_file_ex(&new_state, path, NULL);
@@ -578,11 +580,12 @@ CWD_API int virtual_creat(const char *path, mode_t mode TSRMLS_DC)
 	return f;
 }
 
-CWD_API int virtual_rename(char *oldname, char *newname TSRMLS_DC)
+CWD_API int virtual_rename(char *oldname, char *newname)
 {
 	cwd_state old_state;
 	cwd_state new_state;
 	int retval;
+	CWDLS_FETCH();
 
 	CWD_STATE_COPY(&old_state, &CWDG(cwd));
 	virtual_file_ex(&old_state, oldname, NULL);
@@ -600,10 +603,11 @@ CWD_API int virtual_rename(char *oldname, char *newname TSRMLS_DC)
 	return retval;
 }
 
-CWD_API int virtual_stat(const char *path, struct stat *buf TSRMLS_DC)
+CWD_API int virtual_stat(const char *path, struct stat *buf)
 {
 	cwd_state new_state;
 	int retval;
+	CWDLS_FETCH();
 
 	CWD_STATE_COPY(&new_state, &CWDG(cwd));
 	virtual_file_ex(&new_state, path, NULL);
@@ -616,10 +620,11 @@ CWD_API int virtual_stat(const char *path, struct stat *buf TSRMLS_DC)
 
 #ifndef TSRM_WIN32
 
-CWD_API int virtual_lstat(const char *path, struct stat *buf TSRMLS_DC)
+CWD_API int virtual_lstat(const char *path, struct stat *buf)
 {
 	cwd_state new_state;
 	int retval;
+	CWDLS_FETCH();
 
 	CWD_STATE_COPY(&new_state, &CWDG(cwd));
 	virtual_file_ex(&new_state, path, NULL);
@@ -632,10 +637,11 @@ CWD_API int virtual_lstat(const char *path, struct stat *buf TSRMLS_DC)
 
 #endif
 
-CWD_API int virtual_unlink(const char *path TSRMLS_DC)
+CWD_API int virtual_unlink(const char *path)
 {
 	cwd_state new_state;
 	int retval;
+	CWDLS_FETCH();
 
 	CWD_STATE_COPY(&new_state, &CWDG(cwd));
 	virtual_file_ex(&new_state, path, NULL);
@@ -646,10 +652,11 @@ CWD_API int virtual_unlink(const char *path TSRMLS_DC)
 	return retval;
 }
 
-CWD_API int virtual_mkdir(const char *pathname, mode_t mode TSRMLS_DC)
+CWD_API int virtual_mkdir(const char *pathname, mode_t mode)
 {
 	cwd_state new_state;
 	int retval;
+	CWDLS_FETCH();
 
 	CWD_STATE_COPY(&new_state, &CWDG(cwd));
 	virtual_file_ex(&new_state, pathname, NULL);
@@ -663,10 +670,11 @@ CWD_API int virtual_mkdir(const char *pathname, mode_t mode TSRMLS_DC)
 	return retval;
 }
 
-CWD_API int virtual_rmdir(const char *pathname TSRMLS_DC)
+CWD_API int virtual_rmdir(const char *pathname)
 {
 	cwd_state new_state;
 	int retval;
+	CWDLS_FETCH();
 
 	CWD_STATE_COPY(&new_state, &CWDG(cwd));
 	virtual_file_ex(&new_state, pathname, NULL);
@@ -681,10 +689,11 @@ CWD_API int virtual_rmdir(const char *pathname TSRMLS_DC)
 DIR *opendir(const char *name);
 #endif
 
-CWD_API DIR *virtual_opendir(const char *pathname TSRMLS_DC)
+CWD_API DIR *virtual_opendir(const char *pathname)
 {
 	cwd_state new_state;
 	DIR *retval;
+	CWDLS_FETCH();
 
 	CWD_STATE_COPY(&new_state, &CWDG(cwd));
 	virtual_file_ex(&new_state, pathname, NULL);
@@ -697,12 +706,13 @@ CWD_API DIR *virtual_opendir(const char *pathname TSRMLS_DC)
 
 #ifndef TSRM_WIN32
 
-CWD_API FILE *virtual_popen(const char *command, const char *type TSRMLS_DC)
+CWD_API FILE *virtual_popen(const char *command, const char *type)
 {
 	int command_length;
 	char *command_line;
 	char *ptr;
 	FILE *retval;
+	CWDLS_FETCH();
 
 	command_length = strlen(command);
 
@@ -725,8 +735,11 @@ CWD_API FILE *virtual_popen(const char *command, const char *type TSRMLS_DC)
 	*ptr++ = ' ';
 
 	memcpy(ptr, command, command_length+1);
+#ifdef TSRM_WIN32
+	retval = _popen(command_line, type);
+#else
 	retval = popen(command_line, type);
-
+#endif
 	free(command_line);
 	return retval;
 }
@@ -736,11 +749,12 @@ CWD_API FILE *virtual_popen(const char *command, const char *type TSRMLS_DC)
 /* On Windows the trick of prepending "cd cwd; " doesn't work so we need to perform
    a real chdir() and mutex it
  */
-CWD_API FILE *virtual_popen(const char *command, const char *type TSRMLS_DC)
+CWD_API FILE *virtual_popen(const char *command, const char *type)
 {
 	char prev_cwd[MAXPATHLEN];
 	char *getcwd_result;
 	FILE *retval;
+	CWDLS_FETCH();
 
 	getcwd_result = getcwd(prev_cwd, MAXPATHLEN);
 	if (!getcwd_result) {
@@ -752,7 +766,7 @@ CWD_API FILE *virtual_popen(const char *command, const char *type TSRMLS_DC)
 #endif
 
 	chdir(CWDG(cwd).cwd);
-	retval = popen(command, type);
+	retval = _popen(command, type);
 	chdir(prev_cwd);
 
 #ifdef ZTS

TSRM/tsrm_virtual_cwd.h

@@ -22,7 +22,6 @@
 #ifndef VIRTUAL_CWD_H
 #define VIRTUAL_CWD_H
 
-#include "TSRM.h"
 #include "tsrm_config_common.h"
 
 #include <sys/types.h>
@@ -48,13 +47,10 @@
 typedef unsigned short mode_t;
 
 #define DEFAULT_SLASH '\\'
-#define DEFAULT_DIR_SEPARATOR	';'
 #define IS_SLASH(c)	((c) == '/' || (c) == '\\')
 #define COPY_WHEN_ABSOLUTE 2
 #define IS_ABSOLUTE_PATH(path, len) \
 	(len >= 2 && isalpha(path[0]) && path[1] == ':')
-#define IS_UNC_PATH(path, len) \
-	(len >= 2 && IS_SLASH(path[0]) && IS_SLASH(path[1]))
 
 #else
 #ifdef HAVE_DIRENT_H
@@ -62,7 +58,6 @@ typedef unsigned short mode_t;
 #endif
 
 #define DEFAULT_SLASH '/'
-#define DEFAULT_DIR_SEPARATOR	':'
 #define IS_SLASH(c)	((c) == '/')
 
 #endif
@@ -100,32 +95,32 @@ typedef int (*verify_path_func)(const cwd_state *);
 
 CWD_API void virtual_cwd_startup(void);
 CWD_API void virtual_cwd_shutdown(void);
-CWD_API char *virtual_getcwd_ex(size_t *length TSRMLS_DC);
-CWD_API char *virtual_getcwd(char *buf, size_t size TSRMLS_DC);
-CWD_API int virtual_chdir(const char *path TSRMLS_DC);
-CWD_API int virtual_chdir_file(const char *path, int (*p_chdir)(const char *path TSRMLS_DC) TSRMLS_DC);
-CWD_API int virtual_filepath(const char *path, char **filepath TSRMLS_DC);
-CWD_API int virtual_filepath_ex(const char *path, char **filepath, verify_path_func verify_path TSRMLS_DC);
-CWD_API char *virtual_realpath(const char *path, char *real_path TSRMLS_DC);
-CWD_API FILE *virtual_fopen(const char *path, const char *mode TSRMLS_DC);
-CWD_API int virtual_open(const char *path TSRMLS_DC, int flags, ...);
-CWD_API int virtual_creat(const char *path, mode_t mode TSRMLS_DC);
-CWD_API int virtual_rename(char *oldname, char *newname TSRMLS_DC);
-CWD_API int virtual_stat(const char *path, struct stat *buf TSRMLS_DC);
+CWD_API char *virtual_getcwd_ex(size_t *length);
+CWD_API char *virtual_getcwd(char *buf, size_t size);
+CWD_API int virtual_chdir(const char *path);
+CWD_API int virtual_chdir_file(const char *path, int (*p_chdir)(const char *path));
+CWD_API int virtual_filepath(const char *path, char **filepath);
+CWD_API int virtual_filepath_ex(const char *path, char **filepath, verify_path_func verify_path);
+CWD_API char *virtual_realpath(const char *path, char *real_path);
+CWD_API FILE *virtual_fopen(const char *path, const char *mode);
+CWD_API int virtual_open(const char *path, int flags, ...);
+CWD_API int virtual_creat(const char *path, mode_t mode);
+CWD_API int virtual_rename(char *oldname, char *newname);
+CWD_API int virtual_stat(const char *path, struct stat *buf);
 #ifndef TSRM_WIN32
-CWD_API int virtual_lstat(const char *path, struct stat *buf TSRMLS_DC);
+CWD_API int virtual_lstat(const char *path, struct stat *buf);
 #endif
-CWD_API int virtual_unlink(const char *path TSRMLS_DC);
-CWD_API int virtual_mkdir(const char *pathname, mode_t mode TSRMLS_DC);
-CWD_API int virtual_rmdir(const char *pathname TSRMLS_DC);
-CWD_API DIR *virtual_opendir(const char *pathname TSRMLS_DC);
-CWD_API FILE *virtual_popen(const char *command, const char *type TSRMLS_DC);
+CWD_API int virtual_unlink(const char *path);
+CWD_API int virtual_mkdir(const char *pathname, mode_t mode);
+CWD_API int virtual_rmdir(const char *pathname);
+CWD_API DIR *virtual_opendir(const char *pathname);
+CWD_API FILE *virtual_popen(const char *command, const char *type);
 #if HAVE_UTIME
-CWD_API int virtual_utime(const char *filename, struct utimbuf *buf TSRMLS_DC);
+CWD_API int virtual_utime(const char *filename, struct utimbuf *buf);
 #endif
-CWD_API int virtual_chmod(const char *filename, mode_t mode TSRMLS_DC);
+CWD_API int virtual_chmod(const char *filename, mode_t mode);
 #ifndef TSRM_WIN32
-CWD_API int virtual_chown(const char *filename, uid_t owner, gid_t group TSRMLS_DC);
+CWD_API int virtual_chown(const char *filename, uid_t owner, gid_t group);
 #endif
 
 CWD_API int virtual_file_ex(cwd_state *state, const char *path, verify_path_func verify_path);
@@ -135,9 +130,19 @@ typedef struct _virtual_cwd_globals {
 } virtual_cwd_globals;
 
 #ifdef ZTS
-# define CWDG(v) TSRMG(cwd_globals_id, virtual_cwd_globals *, v)
+# define CWDLS_D  virtual_cwd_globals *cwd_globals
+# define CWDLS_DC , CWDLS_D
+# define CWDLS_C  cwd_globals
+# define CWDLS_CC , CWDLS_C
+# define CWDG(v) (cwd_globals->v)
+# define CWDLS_FETCH()    virtual_cwd_globals *cwd_globals = ts_resource(cwd_globals_id)
 #else
+# define CWDLS_D  void
+# define CWDLS_DC
+# define CWDLS_C
+# define CWDLS_CC
 # define CWDG(v) (cwd_globals.v)
+# define CWDLS_FETCH()
 #endif
 
 /* The actual macros to be used in programs using TSRM
@@ -147,67 +152,59 @@ typedef struct _virtual_cwd_globals {
 
 #ifdef VIRTUAL_DIR
 
-#define VCWD_GETCWD(buff, size) virtual_getcwd(buff, size TSRMLS_CC)
-#define VCWD_FOPEN(path, mode) virtual_fopen(path, mode TSRMLS_CC)
-/* Because open() has two modes, we have to macros to replace it */
-#define VCWD_OPEN(path, flags) virtual_open(path TSRMLS_CC, flags)
-#define VCWD_OPEN_MODE(path, flags, mode) virtual_open(path TSRMLS_CC, flags, mode)
-#define VCWD_CREAT(path, mode) virtual_creat(path, mode TSRMLS_CC)
-#define VCWD_CHDIR(path) virtual_chdir(path TSRMLS_CC)
-#define VCWD_CHDIR_FILE(path) virtual_chdir_file(path, virtual_chdir TSRMLS_CC)
-#define VCWD_GETWD(buf)
-#define VCWD_REALPATH(path, real_path) virtual_realpath(path, real_path TSRMLS_CC)
-#define VCWD_RENAME(oldname, newname) virtual_rename(oldname, newname TSRMLS_CC)
-#define VCWD_STAT(path, buff) virtual_stat(path, buff TSRMLS_CC)
+#define V_GETCWD(buff, size) virtual_getcwd(buff,size)
+#define V_FOPEN(path, mode) virtual_fopen(path, mode)
+/* The V_OPEN macro will need to be used as V_OPEN((path, flags, ...)) */
+#define V_OPEN(open_args) virtual_open open_args
+#define V_CREAT(path, mode) virtual_creat(path, mode)
+#define V_CHDIR(path) virtual_chdir(path)
+#define V_CHDIR_FILE(path) virtual_chdir_file(path, virtual_chdir)
+#define V_GETWD(buf)
+#define V_REALPATH(path,real_path) virtual_realpath(path,real_path)
+#define V_RENAME(oldname,newname) virtual_rename(oldname,newname)
+#define V_STAT(path, buff) virtual_stat(path, buff)
 #ifdef TSRM_WIN32
-#define VCWD_LSTAT(path, buff) virtual_stat(path, buff TSRMLS_CC)
+#define V_LSTAT(path, buff) virtual_stat(path, buff)
 #else
-#define VCWD_LSTAT(path, buff) virtual_lstat(path, buff TSRMLS_CC)
+#define V_LSTAT(path, buff) virtual_lstat(path, buff)
 #endif
-#define VCWD_UNLINK(path) virtual_unlink(path TSRMLS_CC)
-#define VCWD_MKDIR(pathname, mode) virtual_mkdir(pathname, mode TSRMLS_CC)
-#define VCWD_RMDIR(pathname) virtual_rmdir(pathname TSRMLS_CC)
-#define VCWD_OPENDIR(pathname) virtual_opendir(pathname TSRMLS_CC)
-#define VCWD_POPEN(command, type) virtual_popen(command, type TSRMLS_CC)
+#define V_UNLINK(path) virtual_unlink(path)
+#define V_MKDIR(pathname, mode) virtual_mkdir(pathname, mode)
+#define V_RMDIR(pathname) virtual_rmdir(pathname)
+#define V_OPENDIR(pathname) virtual_opendir(pathname)
+#define V_POPEN(command, type) virtual_popen(command, type)
 #if HAVE_UTIME
-#define VCWD_UTIME(path, time) virtual_utime(path, time TSRMLS_CC)
+#define V_UTIME(path,time) virtual_utime(path,time)
 #endif
-#define VCWD_CHMOD(path, mode) virtual_chmod(path, mode TSRMLS_CC)
+#define V_CHMOD(path,mode) virtual_chmod(path,mode)
 #ifndef TSRM_WIN32
-#define VCWD_CHOWN(path, owner, group) virtual_chown(path, owner, group TSRMLS_CC)
+#define V_CHOWN(path,owner,group) virtual_chown(path,owner,group)
 #endif
 
 #else
 
-#define VCWD_GETCWD(buff, size) getcwd(buff, size)
-#define VCWD_FOPEN(path, mode)  fopen(path, mode)
-#define VCWD_OPEN(path, flags) open(path, flags)
-#define VCWD_OPEN_MODE(path, flags, mode)	open(path, flags, mode)
-#define VCWD_CREAT(path, mode) creat(path, mode)
-#define VCWD_RENAME(oldname, newname) rename(oldname, newname)
-#define VCWD_CHDIR(path) chdir(path)
-#define VCWD_CHDIR_FILE(path) virtual_chdir_file(path, chdir)
-#define VCWD_GETWD(buf) getwd(buf)
-#define VCWD_STAT(path, buff) stat(path, buff)
-#define VCWD_LSTAT(path, buff) lstat(path, buff)
-#define VCWD_UNLINK(path) unlink(path)
-#define VCWD_MKDIR(pathname, mode) mkdir(pathname, mode)
-#define VCWD_RMDIR(pathname) rmdir(pathname)
-#define VCWD_OPENDIR(pathname) opendir(pathname)
-#define VCWD_POPEN(command, type) popen(command, type)
-
-#ifndef TSRM_WIN32
-#define VCWD_REALPATH(path, real_path) realpath(path, real_path)
-#else
-#define VCWD_REALPATH(path, real_path) strcpy(real_path, path)
-#endif
-
+#define V_GETCWD(buff, size) getcwd(buff,size)
+#define V_FOPEN(path, mode)  fopen(path, mode)
+#define V_OPEN(open_args) open open_args
+#define V_CREAT(path, mode) creat(path, mode)
+#define V_RENAME(oldname,newname) rename(oldname,newname)
+#define V_CHDIR(path) chdir(path)
+#define V_CHDIR_FILE(path) virtual_chdir_file(path, chdir)
+#define V_GETWD(buf) getwd(buf)
+#define V_STAT(path, buff) stat(path, buff)
+#define V_LSTAT(path, buff) lstat(path, buff)
+#define V_UNLINK(path) unlink(path)
+#define V_MKDIR(pathname, mode) mkdir(pathname, mode)
+#define V_RMDIR(pathname) rmdir(pathname)
+#define V_OPENDIR(pathname) opendir(pathname)
+#define V_POPEN(command, type) popen(command, type)
+#define V_REALPATH(path,real_path) realpath(path,real_path)
 #if HAVE_UTIME
-#define VCWD_UTIME(path, time) utime(path, time)
+#define V_UTIME(path,time) utime(path,time)
 #endif
-#define VCWD_CHMOD(path, mode) chmod(path, mode)
+#define V_CHMOD(path,mode) chmod(path,mode)
 #ifndef TSRM_WIN32
-#define VCWD_CHOWN(path, owner, group) chown(path, owner, group)
+#define V_CHOWN(path,owner,group) chown(path,owner,group)
 #endif
 
 #endif

TSRM/tsrm_win32.c

@@ -1,359 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP version 4.0                                                      |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1997, 1998, 1999, 2000 The PHP Group                   |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 2.02 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available at through the world-wide-web at                           |
-   | http://www.php.net/license/2_02.txt.                                 |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: Daniel Beulshausen <daniel@php4win.de>                      |
-   +----------------------------------------------------------------------+
-*/
-
-/* $Id$ */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <io.h>
-#include <process.h>
-#include <time.h>
-
-#include "TSRM.h"
-
-#ifdef TSRM_WIN32
-#include <windows.h>
-#include "tsrm_win32.h"
-
-#ifdef ZTS
-static ts_rsrc_id win32_globals_id;
-#else
-static tsrm_win32_globals win32_globals;
-#endif
-
-static void tsrm_win32_ctor(tsrm_win32_globals *globals TSRMLS_DC)
-{
-	globals->process = NULL;
-	globals->shm	 = NULL;
-	globals->process_size = 0;
-	globals->shm_size	  = 0;
-	globals->comspec = _strdup((GetVersion()<0x80000000)?"cmd.exe":"command.com");
-}
-
-static void tsrm_win32_dtor(tsrm_win32_globals *globals TSRMLS_DC)
-{
-	shm_pair *ptr;
-
-	if (globals->process) {
-		free(globals->process);
-	}
-
-	if (globals->shm) {
-		for (ptr = globals->shm; ptr < (globals->shm + globals->shm_size); ptr++) {
-			UnmapViewOfFile(ptr->addr);
-			CloseHandle(ptr->segment);
-			UnmapViewOfFile(ptr->descriptor);
-			CloseHandle(ptr->info);
-		}
-		free(globals->shm);
-	}
-
-	free(globals->comspec);
-}
-
-TSRM_API void tsrm_win32_startup(void)
-{
-#ifdef ZTS
-	ts_allocate_id(&win32_globals_id, sizeof(tsrm_win32_globals), (ts_allocate_ctor)tsrm_win32_ctor, (ts_allocate_ctor)tsrm_win32_dtor);
-#else
-	tsrm_win32_ctor(&win32_globals TSRMLS_CC);
-#endif
-}
-
-TSRM_API void tsrm_win32_shutdown(void)
-{
-#ifndef ZTS
-	tsrm_win32_dtor(&win32_globals TSRMLS_CC);
-#endif
-}
-
-static process_pair *process_get(FILE *stream TSRMLS_DC)
-{
-	process_pair *ptr;
-	process_pair *newptr;
-	
-	for (ptr = TWG(process); ptr < (TWG(process) + TWG(process_size)); ptr++) {
-		if (ptr->stream == stream) {
-			break;
-		}
-	}
-	
-	if (ptr < (TWG(process) + TWG(process_size))) {
-		return ptr;
-	}
-	
-	newptr = (process_pair*)realloc((void*)TWG(process), (TWG(process_size)+1)*sizeof(process_pair));
-	if (newptr == NULL) {
-		return NULL;
-	}
-	
-	TWG(process) = newptr;
-	ptr = newptr + TWG(process_size);
-	TWG(process_size)++;
-	return ptr;
-}
-
-static shm_pair *shm_get(int key, void *addr)
-{
-	shm_pair *ptr;
-	shm_pair *newptr;
-	TSRMLS_FETCH();
-	
-	for (ptr = TWG(shm); ptr < (TWG(shm) + TWG(shm_size)); ptr++) {
-		if (!ptr->descriptor) {
-			continue;
-		}
-		if (!addr && ptr->descriptor->shm_perm.key == key) {
-			break;
-		} else if (ptr->addr == addr) {
-			break;
-		}
-	}
-
-	if (ptr < (TWG(shm) + TWG(shm_size))) {
-		return ptr;
-	}
-	
-	newptr = (shm_pair*)realloc((void*)TWG(shm), (TWG(shm_size)+1)*sizeof(shm_pair));
-	if (newptr == NULL) {
-		return NULL;
-	}
-	
-	TWG(shm) = newptr;
-	ptr = newptr + TWG(shm_size);
-	TWG(shm_size)++;
-	return ptr;
-}
-
-static HANDLE dupHandle(HANDLE fh, BOOL inherit) {
-	HANDLE copy, self = GetCurrentProcess();
-	if (!DuplicateHandle(self, fh, self, &copy, 0, inherit, DUPLICATE_SAME_ACCESS|DUPLICATE_CLOSE_SOURCE)) {
-		return NULL;
-	}
-	return copy;
-}
-
-TSRM_API FILE *popen(const char *command, const char *type)
-{
-	FILE *stream = NULL;
-	int fno, str_len = strlen(type), read, mode;
-	STARTUPINFO startup;
-	PROCESS_INFORMATION process;
-	SECURITY_ATTRIBUTES security;
-	HANDLE in, out;
-	char *cmd;
-	process_pair *proc;
-	TSRMLS_FETCH();
-
-	security.nLength				= sizeof(SECURITY_ATTRIBUTES);
-	security.bInheritHandle			= TRUE;
-	security.lpSecurityDescriptor	= NULL;
-
-	if (!str_len || !CreatePipe(&in, &out, &security, 2048L)) {
-		return NULL;
-	}
-	
-	memset(&startup, 0, sizeof(STARTUPINFO));
-	memset(&process, 0, sizeof(PROCESS_INFORMATION));
-
-	startup.cb			= sizeof(STARTUPINFO);
-	startup.dwFlags		= STARTF_USESTDHANDLES;
-	startup.hStdError	= GetStdHandle(STD_ERROR_HANDLE);
-
-	read = (type[0] == 'r') ? TRUE : FALSE;
-	mode = ((str_len == 2) && (type[1] == 'b')) ? O_BINARY : O_TEXT;
-
-
-	if (read) {
-		in = dupHandle(in, FALSE);
-		startup.hStdInput  = GetStdHandle(STD_INPUT_HANDLE);
-		startup.hStdOutput = out;
-	} else {
-		out = dupHandle(out, FALSE);
-		startup.hStdInput  = in;
-		startup.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
-	}
-
-	cmd = (char*)malloc(strlen(command)+strlen(TWG(comspec))+sizeof(" /c "));
-	sprintf(cmd, "%s /c %s", TWG(comspec), command);
-	if (!CreateProcess(NULL, cmd, &security, &security, security.bInheritHandle, NORMAL_PRIORITY_CLASS, NULL, NULL, &startup, &process)) {
-		return NULL;
-	}
-	free(cmd);
-
-	CloseHandle(process.hThread);
-	proc = process_get(NULL TSRMLS_CC);
-
-	if (read) {
-		fno = _open_osfhandle((long)in, _O_RDONLY | mode);
-		CloseHandle(out);
-	} else {
-		fno = _open_osfhandle((long)out, _O_WRONLY | mode);
-		CloseHandle(in);
-	}
-
-	stream = _fdopen(fno, type);
-	proc->prochnd = process.hProcess;
-	proc->stream = stream;
-	return stream;
-}
-
-TSRM_API int pclose(FILE *stream)
-{
-	DWORD termstat = 0;
-	process_pair *process;
-	TSRMLS_FETCH();
-
-	if ((process = process_get(stream TSRMLS_CC)) == NULL) {
-		return 0;
-	}
-
-	fflush(process->stream);
-    fclose(process->stream);
-
-	WaitForSingleObject(process->prochnd, INFINITE);
-	GetExitCodeProcess(process->prochnd, &termstat);
-	process->stream = NULL;
-	CloseHandle(process->prochnd);
-
-	return termstat;
-}
-
-TSRM_API int shmget(int key, int size, int flags)
-{
-	shm_pair *shm;
-	char shm_segment[26], shm_info[29];
-	HANDLE shm_handle, info_handle;
-	BOOL created = FALSE;
-
-	if (size < 0) {
-		return -1;
-	}
-
-	sprintf(shm_segment, "TSRM_SHM_SEGMENT:%d", key);
-	sprintf(shm_info, "TSRM_SHM_DESCRIPTOR:%d", key);
-
-	shm_handle  = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, shm_segment);
-	info_handle = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, shm_info);
-
-	if ((!shm_handle && !info_handle)) {
-		if (flags & IPC_EXCL) {
-			return -1;
-		}
-		if (flags & IPC_CREAT) {
-			shm_handle	= CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, size, shm_segment);
-			info_handle	= CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, sizeof(shm->descriptor), shm_info);
-			created		= TRUE;
-		}
-		if ((!shm_handle || !info_handle)) {
-			return -1;
-		}
-	}
-
-	shm = shm_get(key, NULL);
-	shm->segment = shm_handle;
-	shm->info	 = info_handle;
-	shm->descriptor = MapViewOfFileEx(shm->info, FILE_MAP_ALL_ACCESS, 0, 0, 0, NULL);
-
-	if (created) {
-		shm->descriptor->shm_perm.key	= key;
-		shm->descriptor->shm_segsz		= size;
-		shm->descriptor->shm_ctime		= time(NULL);
-		shm->descriptor->shm_cpid		= getpid();
-		shm->descriptor->shm_perm.mode	= flags;
-
-		shm->descriptor->shm_perm.cuid	= shm->descriptor->shm_perm.cgid= 0;
-		shm->descriptor->shm_perm.gid	= shm->descriptor->shm_perm.uid = 0;
-		shm->descriptor->shm_atime		= shm->descriptor->shm_dtime	= 0;
-		shm->descriptor->shm_lpid		= shm->descriptor->shm_nattch	= 0;
-		shm->descriptor->shm_perm.mode	= shm->descriptor->shm_perm.seq	= 0;
-	}
-
-	if (shm->descriptor->shm_perm.key != key || size > shm->descriptor->shm_segsz ) {
-		CloseHandle(shm->segment);
-		UnmapViewOfFile(shm->descriptor);
-		CloseHandle(shm->info);
-		return -1;
-	}
-
-	return key;
-}
-
-TSRM_API void *shmat(int key, const void *shmaddr, int flags)
-{
-	shm_pair *shm = shm_get(key, NULL);
-
-	if (!shm->segment) {
-		return (void*)-1;
-	}
-
-	shm->descriptor->shm_atime = time(NULL);
-	shm->descriptor->shm_lpid  = getpid();
-	shm->descriptor->shm_nattch++;
-
-	shm->addr = MapViewOfFileEx(shm->segment, FILE_MAP_ALL_ACCESS, 0, 0, 0, NULL);
-
-	return shm->addr;
-}
-
-TSRM_API int shmdt(const void *shmaddr)
-{
-	shm_pair *shm = shm_get(0, (void*)shmaddr);
-
-	if (!shm->segment) {
-		return -1;
-	}
-
-	shm->descriptor->shm_dtime = time(NULL);
-	shm->descriptor->shm_lpid  = getpid();
-	shm->descriptor->shm_nattch--;
-
-	return UnmapViewOfFile(shm->addr) ? 0 : -1;
-}
-
-TSRM_API int shmctl(int key, int cmd, struct shmid_ds *buf) {
-	shm_pair *shm = shm_get(key, NULL);
-
-	if (!shm->segment) {
-		return -1;
-	}
-
-	switch (cmd) {
-		case IPC_STAT:
-			memcpy(buf, shm->descriptor, sizeof(struct shmid_ds));
-			return 0;
-
-		case IPC_SET:
-			shm->descriptor->shm_ctime		= time(NULL);
-			shm->descriptor->shm_perm.uid	= buf->shm_perm.uid;
-			shm->descriptor->shm_perm.gid	= buf->shm_perm.gid;
-			shm->descriptor->shm_perm.mode	= buf->shm_perm.mode;
-			return 0;
-
-		case IPC_RMID:
-			if (shm->descriptor->shm_nattch < 1) {
-				shm->descriptor->shm_perm.key = -1;
-			}
-			return 0;
-
-		default:
-			return -1;
-	}
-}
-#endif

TSRM/tsrm_win32.h

@@ -1,107 +0,0 @@
-/*
-   +----------------------------------------------------------------------+
-   | PHP version 4.0                                                      |
-   +----------------------------------------------------------------------+
-   | Copyright (c) 1997, 1998, 1999, 2000 The PHP Group                   |
-   +----------------------------------------------------------------------+
-   | This source file is subject to version 2.02 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
-   | available at through the world-wide-web at                           |
-   | http://www.php.net/license/2_02.txt.                                 |
-   | If you did not receive a copy of the PHP license and are unable to   |
-   | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
-   +----------------------------------------------------------------------+
-   | Authors: Daniel Beulshausen <daniel@php4win.de>                      |
-   +----------------------------------------------------------------------+
-*/
-
-/* $Id$ */
-
-#ifndef TSRM_WIN32_H
-#define TSRM_WIN32_H
-
-#include "TSRM.h"
-
-#ifdef TSRM_WIN32
-#include <windows.h>
-
-struct ipc_perm {
-	int			key;
-	unsigned short	uid;
-	unsigned short	gid;
-	unsigned short	cuid;
-	unsigned short	cgid;
-	unsigned short	mode;
-	unsigned short	seq;
-};
-
-struct shmid_ds {
-	struct	ipc_perm	shm_perm;
-	int				shm_segsz;
-	time_t			shm_atime;
-	time_t			shm_dtime;
-	time_t			shm_ctime;
-	unsigned short	shm_cpid;
-	unsigned short	shm_lpid;
-	short			shm_nattch;
-};
-
-typedef struct {
-	FILE	*stream;
-	HANDLE	prochnd;
-} process_pair;
-
-typedef struct {
-	void	*addr;
-	HANDLE	info;
-	HANDLE	segment;
-	struct	shmid_ds	*descriptor;
-} shm_pair;
-
-typedef struct {
-	process_pair	*process;
-	shm_pair		*shm;
-	int				process_size;
-	int				shm_size;
-	char			*comspec;
-} tsrm_win32_globals;
-
-#ifdef ZTS
-# define TWG(v) TSRMG(win32_globals_id, tsrm_win32_globals *, v)
-#else
-# define TWG(v) (win32_globals.v)
-#endif
-
-#endif
-
-#define IPC_PRIVATE	0
-#define IPC_CREAT	00001000
-#define IPC_EXCL	00002000
-#define IPC_NOWAIT	00004000
-
-#define IPC_RMID	0
-#define IPC_SET		1
-#define IPC_STAT	2
-#define IPC_INFO	3
-
-#define SHM_R		PAGE_READONLY
-#define SHM_W		PAGE_READWRITE
-
-#define	SHM_RDONLY	FILE_MAP_READ
-#define	SHM_RND		FILE_MAP_WRITE
-#define	SHM_REMAP	FILE_MAP_COPY
-
-
-TSRM_API void tsrm_win32_startup(void);
-TSRM_API void tsrm_win32_shutdown(void);
-
-TSRM_API FILE *popen(const char *command, const char *type);
-TSRM_API int pclose(FILE *stream);
-
-TSRM_API int shmget(int key, int size, int flags);
-TSRM_API void *shmat(int key, const void *shmaddr, int flags);
-TSRM_API int shmdt(const void *shmaddr);
-TSRM_API int shmctl(int key, int cmd, struct shmid_ds *buf);
-
-#endif

Zend/FlexLexer.h

@@ -0,0 +1,186 @@
+// $Header$
+
+// FlexLexer.h -- define interfaces for lexical analyzer classes generated
+//		  by flex
+
+// Copyright (c) 1993 The Regents of the University of California.
+// All rights reserved.
+//
+// This code is derived from software contributed to Berkeley by
+// Kent Williams and Tom Epperly.
+//
+// Redistribution and use in source and binary forms with or without
+// modification are permitted provided that: (1) source distributions retain
+// this entire copyright notice and comment, and (2) distributions including
+// binaries display the following acknowledgement:  ``This product includes
+// software developed by the University of California, Berkeley and its
+// contributors'' in the documentation or other materials provided with the
+// distribution and in all advertising materials mentioning features or use
+// of this software.  Neither the name of the University nor the names of
+// its contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+// This file defines FlexLexer, an abstract class which specifies the
+// external interface provided to flex C++ lexer objects, and yyFlexLexer,
+// which defines a particular lexer class.
+//
+// If you want to create multiple lexer classes, you use the -P flag
+// to rename each yyFlexLexer to some other xxFlexLexer.  You then
+// include <FlexLexer.h> in your other sources once per lexer class:
+//
+//	#undef yyFlexLexer
+//	#define yyFlexLexer xxFlexLexer
+//	#include <FlexLexer.h>
+//
+//	#undef yyFlexLexer
+//	#define yyFlexLexer zzFlexLexer
+//	#include <FlexLexer.h>
+//	...
+
+#ifndef FLEXLEXER_H
+// Never included before - need to define base class.
+#define FLEXLEXER_H
+#include <iostream.h>
+
+extern "C++" {
+
+struct yy_buffer_state;
+typedef int yy_state_type;
+
+class FlexLexer {
+public:
+	virtual ~FlexLexer()	{ }
+
+	const char* YYText()	{ return yytext; }
+	int YYLeng()		{ return yyleng; }
+
+	virtual void
+		yy_switch_to_buffer( struct yy_buffer_state* new_buffer ) = 0;
+	virtual struct yy_buffer_state*
+		yy_create_buffer( istream* s, int size ) = 0;
+	virtual void yy_delete_buffer( struct yy_buffer_state* b ) = 0;
+	virtual void yyrestart( istream* s ) = 0;
+
+	virtual int yylex() = 0;
+
+	// Call yylex with new input/output sources.
+	int yylex( istream* new_in, ostream* new_out = 0 )
+		{
+		switch_streams( new_in, new_out );
+		return yylex();
+		}
+
+	// Switch to new input/output streams.  A nil stream pointer
+	// indicates "keep the current one".
+	virtual void switch_streams( istream* new_in = 0,
+					ostream* new_out = 0 ) = 0;
+
+	int lineno() const		{ return yylineno; }
+
+	int debug() const		{ return yy_flex_debug; }
+	void set_debug( int flag )	{ yy_flex_debug = flag; }
+
+protected:
+	char* yytext;
+	int yyleng;
+	int yylineno;		// only maintained if you use %option yylineno
+	int yy_flex_debug;	// only has effect with -d or "%option debug"
+};
+
+}
+#endif
+
+#if defined(yyFlexLexer) || ! defined(yyFlexLexerOnce)
+// Either this is the first time through (yyFlexLexerOnce not defined),
+// or this is a repeated include to define a different flavor of
+// yyFlexLexer, as discussed in the flex man page.
+#define yyFlexLexerOnce
+
+class yyFlexLexer : public FlexLexer {
+public:
+	// arg_yyin and arg_yyout default to the cin and cout, but we
+	// only make that assignment when initializing in yylex().
+	yyFlexLexer( istream* arg_yyin = 0, ostream* arg_yyout = 0 );
+
+	virtual ~yyFlexLexer();
+
+	void yy_switch_to_buffer( struct yy_buffer_state* new_buffer );
+	struct yy_buffer_state* yy_create_buffer( istream* s, int size );
+	void yy_delete_buffer( struct yy_buffer_state* b );
+	void yyrestart( istream* s );
+
+	virtual int yylex();
+	virtual void switch_streams( istream* new_in, ostream* new_out );
+
+protected:
+	virtual int LexerInput( char* buf, int max_size );
+	virtual void LexerOutput( const char* buf, int size );
+	virtual void LexerError( const char* msg );
+
+	void yyunput( int c, char* buf_ptr );
+	int yyinput();
+
+	void yy_load_buffer_state();
+	void yy_init_buffer( struct yy_buffer_state* b, istream* s );
+	void yy_flush_buffer( struct yy_buffer_state* b );
+
+	int yy_start_stack_ptr;
+	int yy_start_stack_depth;
+	int* yy_start_stack;
+
+	void yy_push_state( int new_state );
+	void yy_pop_state();
+	int yy_top_state();
+
+	yy_state_type yy_get_previous_state();
+	yy_state_type yy_try_NUL_trans( yy_state_type current_state );
+	int yy_get_next_buffer();
+
+	istream* yyin;	// input source for default LexerInput
+	ostream* yyout;	// output sink for default LexerOutput
+
+	struct yy_buffer_state* yy_current_buffer;
+
+	// yy_hold_char holds the character lost when yytext is formed.
+	char yy_hold_char;
+
+	// Number of characters read into yy_ch_buf.
+	int yy_n_chars;
+
+	// Points to current character in buffer.
+	char* yy_c_buf_p;
+
+	int yy_init;		// whether we need to initialize
+	int yy_start;		// start state number
+
+	// Flag which is used to allow yywrap()'s to do buffer switches
+	// instead of setting up a fresh yyin.  A bit of a hack ...
+	int yy_did_buffer_switch_on_eof;
+
+	// The following are not always needed, but may be depending
+	// on use of certain flex features (like REJECT or yymore()).
+
+	yy_state_type yy_last_accepting_state;
+	char* yy_last_accepting_cpos;
+
+	yy_state_type* yy_state_buf;
+	yy_state_type* yy_state_ptr;
+
+	char* yy_full_match;
+	int* yy_full_state;
+	int yy_full_lp;
+
+	int yy_lp;
+	int yy_looking_for_trail_begin;
+
+	int yy_more_flag;
+	int yy_more_len;
+	int yy_more_offset;
+	int yy_prev_more_offset;
+};
+
+#endif

Zend/LICENSE

@@ -0,0 +1,116 @@
+---------------------------------------------------------------------------
+                    The Zend License, version 0.92
+           Copyright (C) 1999-2000    Zend Technologies Ltd.
+---------------------------------------------------------------------------
+
+The Zend scripting engine library is a product of Zend Technologies Ltd.
+It may be used and/or distributed under the terms of the Q Public
+License (QPL) version 1.0, enclosed below.
+
+For more information about Zend please visit http://www.zend.com/
+For license related questions please mail license@zend.com
+
+===========================================================================
+
+			     THE Q PUBLIC LICENSE
+				  version 1.0
+
+		   Copyright (C) 1999 Troll Tech AS, Norway.
+		       Everyone is permitted to copy and
+		       distribute this license document.
+
+The intent of this license is to establish freedom to share and change the
+software regulated by this license under the open source model.
+
+This license applies to any software containing a notice placed by the
+copyright holder saying that it may be distributed under the terms of
+the Q Public License version 1.0.  Such software is herein referred to as
+the Software.  This license covers modification and distribution of the
+Software, use of third-party application programs based on the Software,
+and development of free software which uses the Software.
+
+				 Granted Rights
+
+1. You are granted the non-exclusive rights set forth in this license
+   provided you agree to and comply with any and all conditions in this
+   license.  Whole or partial distribution of the Software, or software
+   items that link with the Software, in any form signifies acceptance of
+   this license.
+
+2. You may copy and distribute the Software in unmodified form provided
+   that the entire package, including - but not restricted to - copyright,
+   trademark notices and disclaimers, as released by the initial developer
+   of the Software, is distributed.
+
+3. You may make modifications to the Software and distribute your
+   modifications, in a form that is separate from the Software, such as
+   patches. The following restrictions apply to modifications:
+
+     a. Modifications must not alter or remove any copyright notices in
+        the Software.
+
+     b. When modifications to the Software are released under this
+        license, a non-exclusive royalty-free right is granted to the
+        initial developer of the Software to distribute your modification
+        in future versions of the Software provided such versions remain
+        available under these terms in addition to any other license(s) of
+        the initial developer.
+
+4. You may distribute machine-executable forms of the Software or
+   machine-executable forms of modified versions of the Software, provided
+   that you meet these restrictions:
+
+     a. You must include this license document in the distribution.
+
+     b. You must ensure that all recipients of the machine-executable forms
+        are also able to receive the complete machine-readable source code
+        to the distributed Software, including all modifications, without
+        any charge beyond the costs of data transfer, and place prominent
+        notices in the distribution explaining this.
+
+     c. You must ensure that all modifications included in the
+        machine-executable forms are available under the terms of this
+        license.
+
+5. You may use the original or modified versions of the Software to
+   compile, link and run application programs legally developed by you
+   or by others.
+
+6. You may develop application programs, reusable components and other
+   software items that link with the original or modified versions of the
+   Software.  These items, when distributed, are subject to the following
+   requirements:
+
+     a. You must ensure that all recipients of machine-executable forms of
+        these items are also able to receive and use the complete
+        machine-readable source code to the items without any charge
+        beyond the costs of data transfer.
+
+     b. You must explicitly license all recipients of your items to use
+        and re-distribute original and modified versions of the items in
+        both machine-executable and source code forms. The recipients must
+        be able to do so without any charges whatsoever, and they must be
+        able to re-distribute to anyone they choose.
+
+
+     c. If the items are not available to the general public, and the
+        initial developer of the Software requests a copy of the items,
+        then you must supply one.
+
+			    Limitations of Liability
+
+In no event shall the initial developers or copyright holders be liable
+for any damages whatsoever, including - but not restricted to - lost
+revenue or profits or other direct, indirect, special, incidental or
+consequential damages, even if they have been advised of the possibility
+of such damages, except to the extent invariable law, if any, provides
+otherwise.
+
+			          No Warranty
+
+The Software and this license document are provided AS IS with NO WARRANTY
+OF ANY KIND, INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE.
+
+
+===========================================================================

Zend/Makefile.am

@@ -0,0 +1,60 @@
+## Process this file with automake to produce Makefile.in -*- makefile -*-
+
+#CLEANFILES = zend_language_parser.c zend_language_parser.h zend_language_scanner.c zend_language_parser.output zend_ini_parser.c zend_ini_parser.h zend_ini_scanner.c zend_ini_parser.output
+
+AUTOMAKE_OPTIONS=foreign
+EXTRA_LTLIBRARIES=libZend_cc.la libZend_c.la
+noinst_LTLIBRARIES=$(ZEND_SCANNER) libZend.la
+
+libZend_cc_la_SOURCES=zend_language_scanner_cc.cc zend_ini_scanner_cc.cc
+libZend_c_la_SOURCES=zend_language_scanner.c zend_ini_scanner.c
+
+libZend_la_SOURCES=\
+	zend_language_parser.y \
+	zend_ini_parser.y \
+	zend_alloc.c zend_compile.c zend_constants.c zend_dynamic_array.c \
+	zend_execute.c zend_execute_API.c zend_highlight.c zend_llist.c \
+	zend_opcode.c zend_operators.c zend_ptr_stack.c zend_stack.c \
+	zend_variables.c zend.c zend_API.c zend_extensions.c zend_hash.c \
+	zend_list.c zend_indent.c zend_builtin_functions.c zend_sprintf.c \
+	zend_ini.c
+
+libZend_la_LIBADD = $(ZEND_SCANNER)
+libZend_la_LDFLAGS = @EXTRA_LIBS@
+libZend_la_DEPENDENCIES = $(ZEND_SCANNER)
+
+# automake isn't too clever about "non-standard" use of lex and yacc
+
+$(libZend_la_OBJECTS) zend_language_scanner.lo zend_language_scanner_cc.lo: zend_language_parser.h
+
+zend_ini_scanner.lo zend_ini_scanner_cc.lo: zend_ini_parser.h
+
+# Language parser/scanner rules
+
+zend_language_scanner.c: $(srcdir)/zend_language_scanner.l
+	$(LEX) -Pzend -o$@ -i $(srcdir)/zend_language_scanner.l
+
+zend_language_scanner_cc.cc: $(srcdir)/zend_language_scanner.l
+	$(LEX) -+ -B -i -S$(srcdir)/flex.skl -Pzend -o$@ $(srcdir)/zend_language_scanner.l
+
+zend_language_parser.h: zend_language_parser.c
+zend_language_parser.c: $(srcdir)/zend_language_parser.y
+	$(YACC) -p zend -v -d $(srcdir)/zend_language_parser.y -o zend_language_parser.c
+
+# INI parser/scanner rules
+
+zend_ini_parser.c: $(srcdir)/zend_ini_parser.y
+	$(YACC) -p ini_ -v -d $(srcdir)/zend_ini_parser.y -o zend_ini_parser.c
+
+zend_ini_scanner.c: $(srcdir)/zend_ini_scanner.l
+	$(LEX) -Pini_ -o$@ -i $(srcdir)/zend_ini_scanner.l
+
+zend_ini_scanner_cc.cc: $(srcdir)/zend_ini_scanner.l
+	$(LEX) -+ -B -i -S$(srcdir)/flex.skl -Pini_ -o$@ $(srcdir)/zend_ini_scanner.l
+zend_ini_parser.h: zend_ini_parser.c
+
+depend:
+
+zend_execute.lo: $(srcdir)/zend_execute.c
+	$(LIBTOOL) --mode=compile $(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(INLINE_CFLAGS) -c $(srcdir)/zend_execute.c
+

Zend/ZEND_CHANGES

@@ -0,0 +1,112 @@
+Improvements
+------------
+
+Zend was designed from the ground up for increased speed,
+reduced memory consumption and more reliable execution.  We dare
+say it meets all of these goals and does so pretty well.  Beyond
+that, there are several improvements in the language engine
+features:
+
+* References support.  $foo = &$a; would make $foo and $a be two
+  names to the same variable.  This works with arrays as well,
+  on either side;  e.g., $foo = &$a[7]; would make $foo and $a[7]
+  be two names to the same variable.  Changing one would change
+  the other and vice versa.
+* Object overloading support.  This feature allows various OO
+  libraries to use the OO notation of PHP to access their
+  functionality.  Right now, no use is made of that feature,
+  but we'd have a COM module ready by the time PHP 4.0 is released.
+  A CORBA module would probably follow.
+* include() and eval() are now functions, and not statements.
+  That means they return a value.  The default return value from
+  include() and eval() is 1, so that you can do if (include())
+  without further coding.  The return value may be changed by
+  returning a value from the global scope of the included file
+  or the evaluated string.  For example, if 'return 7;' is executed
+  in the global scope of foo.inc, include("foo.inc") would evaluate
+  to 7.
+* Automatic resource deallocation.  Several people have been bitten
+  by the fact that PHP 3.0 had no concept of reference counting.
+  Zend adds full reference counting for every value in the system,
+  including resources.  As soon as a resource is no longer referenced
+  from any variable, it is automatically destroyed to save memory
+  and resources.  The most obvious example for the advantage in this
+  is a loop that has an SQL query inside it, something like
+  '$result = sql_query(...);'.  In PHP 3.0, every iteration resulted
+  in another SQL result-set allocated in the memory, and all of the
+  result sets weren't destroyed until the end of the script's execution.
+  In Zend, as soon as we overwrite an old result set with a new one,
+  the old result set which is no longer referenced, is destroyed.
+* Full support for nesting arrays and objects within each other, in
+  as many levels as you want.
+* Boolean type.  true and false are now constants of type boolean.
+  Comparing any other value to them would convert that value to a
+  boolean first, and conduct the comparison later.  That means, for
+  example, that 5==true would evaluate to true (in PHP 3.0, true
+  was nothing but a constant for the integer value of 1, so 5==true
+  was identical to 5==1, which was false).
+* Runtime binding of function names.  This complex name has a simple
+  explanation - you can now call functions before they're declared!
+* Added here-docs support.
+* Added foreach.  Two syntaxes supported:
+   foreach(array_expr as $val) statement
+   foreach(array_expr as $key => $val) statement
+* A true unset() implementation.  A variable or element that is unset(), is now
+  sent to oblivion in its entirely, no trace remains from it.
+* Output buffering support!  Use ob_start() to begin output buffering, ob_end_flush()
+  to end buffering and send out the buffered contents, ob_end_clean() to end buffering
+  without sending the buffered contents, and ob_get_contents() to retreive the current
+  contents of the output buffer.
+  Header information (header(), content type, cookies) are not buffered.  By turning
+  on output buffering, you can effectively send header information all throughout your
+  file, regardless of whether you've emitted body output or not.
+* Full variable reference within quoted strings:
+  ${expr}		- full indirect reference support for scalar variables
+  {variable}	- full variable support
+  For example:
+  $foo[5]["bar"] = "foobar";
+  print "{$foo[5]["bar"]}";  // would print "foobar"
+* Ability to call member functions of other classes from within member functions or from
+  the global scope. You can now, for example, override a parent function with a child function,
+  and call the parent function from it. 
+* Runtime information for classes (class name, parent, available functions, etc.).
+* Much more efficient syntax highlighter - runs much quicker, performs more reliably, and
+  generates much tighter HTML.
+* A full-featured debugger has been integrated with the language (supports breakpoints,
+  expression evaluation, step-in/over, function call backtrace, and more).
+
+
+Incompatabilities
+-----------------
+
+Zend claims 100% compatability with the engine of PHP 3.0, and is
+shamelessly lying about it.  Here's why:
+
+* static variable initializers only accept scalar values
+  (in PHP 3.0 they accepted any valid expression).  The impact
+  should be somewhere in between void and non existent, since
+  initializing a static variable with anything but a simple
+  static value makes no sense at all.
+
+* The scope of break and continue is local to that of an
+  include()'d file or an eval()'d string.  The impact should
+  be somewhat smaller of the one above.
+
+* return statement from a require()'d file no longer works.  It
+  hardly worked in PHP 3.0, so the impact should be fairly small.
+  If you want this functionality - use include() instead.
+
+* unset() is no longer a function, but a statement.  It was never
+  documented as a function so the impact should be no bigger than
+  nada.
+
+* The following letter combination is not supported within encapsulated
+  strings:  "{$".  If you have a string that includes this letter
+  combination, for example, print "{$somevar"; (which printed the
+  letter { and the contents of the variable $somevar in PHP 3.0),
+  it will result in a parse error under Zend.  In this case, you
+  would have to change the code to print "\{$somevar";
+  This incompatability is due to the full variable reference
+  within quoted strings feature added in Zend.
+  
+

Zend/Zend.dsp

@@ -0,0 +1,498 @@
+# Microsoft Developer Studio Project File - Name="Zend" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=Zend - Win32 Release_inline
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "Zend.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "Zend.mak" CFG="Zend - Win32 Release_inline"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "Zend - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "Zend - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE "Zend - Win32 Release_inline" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "Zend - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDebug" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDebug" /D "_LIB" /D "Zend_EXPORTS" /D ZEND_DEBUG=0 /D "LIBZEND_EXPORTS" /D "TSRM_EXPORTS" /D "WIN32" /D "_MBCS" /D "ZEND_WIN32" /FR /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x40d /d "NDebug"
+# ADD RSC /l 0x40d /d "NDebug"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "Zend - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_Debug" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "." /D "_Debug" /D "_LIB" /D "LIBZEND_EXPORTS" /D "TSRM_EXPORTS" /D ZEND_DEBUG=1 /D "ZEND_WIN32" /D "WIN32" /D "_MBCS" /FR /YX /FD /GZ /c
+# ADD BASE RSC /l 0x40d /d "_Debug"
+# ADD RSC /l 0x40d /d "_Debug"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "Zend - Win32 Release_inline"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Output_Dir "Zend___Win32_Release_inline"
+# PROP BASE Intermediate_Dir "Zend___Win32_Release_inline"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Output_Dir "Release_inline"
+# PROP Intermediate_Dir "Release_inline"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDebug" /D "_LIB" /D "Zend_EXPORTS" /D ZEND_DEBUG=0 /D "LIBZEND_EXPORTS" /D "TSRM_EXPORTS" /D "WIN32" /D "_MBCS" /FR /FD /c
+# SUBTRACT BASE CPP /YX
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDebug" /D "_LIB" /D "Zend_EXPORTS" /D "LIBZEND_EXPORTS" /D "TSRM_EXPORTS" /D ZEND_DEBUG=0 /D "ZEND_WIN32_FORCE_INLINE" /D "WIN32" /D "_MBCS" /D "ZEND_WIN32" /FR /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x40d /d "NDebug"
+# ADD RSC /l 0x40d /d "NDebug"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ENDIF 
+
+# Begin Target
+
+# Name "Zend - Win32 Release"
+# Name "Zend - Win32 Debug"
+# Name "Zend - Win32 Release_inline"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\zend.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_alloc.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_API.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_builtin_functions.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_compile.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_constants.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_execute.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_execute_API.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_extensions.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_hash.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_highlight.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_indent.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ini.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ini_parser.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ini_scanner.c
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend_language_parser.c"
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend_language_scanner.c"
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_list.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_llist.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_opcode.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_operators.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ptr_stack.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_sprintf.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_stack.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_variables.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\FlexLexer.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\modules.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_API.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_builtin_functions.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_compile.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_config.w32.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_constants.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_errors.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_execute.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_extensions.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_fast_cache.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_globals.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_hash.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_highlight.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_indent.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ini.h
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend_language_parser.h"
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend_language_scanner.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_list.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_llist.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_operators.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ptr_stack.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_stack.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_variables.h
+# End Source File
+# End Group
+# Begin Group "Parsers"
+
+# PROP Default_Filter "y"
+# Begin Source File
+
+SOURCE=.\zend_ini_parser.y
+
+!IF  "$(CFG)" == "Zend - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "Zend - Win32 Debug"
+
+# Begin Custom Build
+InputDir=.
+InputPath=.\zend_ini_parser.y
+
+BuildCmds= \
+	if not "X%CYGWIN%"=="X" bison --output=zend_ini_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p ini_ zend_ini_parser.y \
+	if "X%CYGWIN%"=="X" bison --output=zend_ini_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p ini_ zend_ini_parser.y \
+	
+
+"$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+
+"$(InputDir)\zend_ini_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "Zend - Win32 Release_inline"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend_language_parser.y"
+
+!IF  "$(CFG)" == "Zend - Win32 Release"
+
+# Begin Custom Build
+InputDir=.
+InputPath=".\zend_language_parser.y"
+
+BuildCmds= \
+	if not "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend_language_parser.y \
+	if "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend_language_parser.y \
+	
+
+"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+
+"$(InputDir)\zend_language_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "Zend - Win32 Debug"
+
+# Begin Custom Build
+InputDir=.
+InputPath=".\zend_language_parser.y"
+
+BuildCmds= \
+	if not "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend_language_parser.y \
+	if "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend_language_parser.y \
+	
+
+"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+
+"$(InputDir)\zend_language_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "Zend - Win32 Release_inline"
+
+# Begin Custom Build
+InputDir=.
+InputPath=".\zend_language_parser.y"
+
+BuildCmds= \
+	if not "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend_language_parser.y \
+	if "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend_language_parser.y \
+	
+
+"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+
+"$(InputDir)\zend_language_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Scanners"
+
+# PROP Default_Filter "l"
+# Begin Source File
+
+SOURCE=.\zend_ini_scanner.l
+
+!IF  "$(CFG)" == "Zend - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "Zend - Win32 Debug"
+
+# Begin Custom Build
+InputPath=.\zend_ini_scanner.l
+
+"zend_ini_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -B -i -Sflex.skl -Pini_ -ozend_ini_scanner.c zend_ini_scanner.l
+
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "Zend - Win32 Release_inline"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend_language_scanner.l"
+
+!IF  "$(CFG)" == "Zend - Win32 Release"
+
+# Begin Custom Build
+InputPath=".\zend_language_scanner.l"
+
+"zend_language_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -i -Pzend -ozend_language_scanner.c zend_language_scanner.l
+
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "Zend - Win32 Debug"
+
+# Begin Custom Build
+InputPath=".\zend_language_scanner.l"
+
+"zend_language_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -i -Pzend -ozend_language_scanner.c zend_language_scanner.l
+
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "Zend - Win32 Release_inline"
+
+# Begin Custom Build
+InputPath=".\zend_language_scanner.l"
+
+"zend_language_scanner.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -i -Pzend -ozend_language_scanner.c zend_language_scanner.l
+
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Text Files"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\ZEND_BUGS
+# End Source File
+# Begin Source File
+
+SOURCE=.\ZEND_CHANGES
+# End Source File
+# Begin Source File
+
+SOURCE=.\ZEND_TODO
+# End Source File
+# End Group
+# Begin Group "Resources"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\zend.ico
+# End Source File
+# End Group
+# End Target
+# End Project

Zend/Zend.m4

@@ -0,0 +1,222 @@
+
+AC_DEFUN(LIBZEND_BISON_CHECK,[
+
+if test "$YACC" != "bison -y"; then
+    AC_MSG_WARN(You will need bison if you want to regenerate the Zend parser.)
+else
+    AC_MSG_CHECKING(bison version)
+    set `bison --version| sed -e 's/^GNU Bison version //' -e 's/\./ /'`
+    if test "${1}" = "1" -a "${2}" -lt "28"; then
+        AC_MSG_WARN(You will need bison 1.28 if you want to regenerate the Zend parser (found ${1}.${2}).)
+    fi
+    AC_MSG_RESULT(${1}.${2} (ok))
+fi
+
+])
+
+AC_DEFUN(LIBZEND_BASIC_CHECKS,[
+
+AC_REQUIRE([AC_PROG_YACC])
+AC_REQUIRE([AC_PROG_CC])
+AC_REQUIRE([AC_PROG_CC_C_O])
+AC_REQUIRE([AM_PROG_LEX])
+AC_REQUIRE([AC_HEADER_STDC])
+
+LIBZEND_BISON_CHECK
+
+dnl Ugly hack to get around a problem with gcc on AIX.
+if test "$CC" = "gcc" -a "$ac_cv_prog_cc_g" = "yes" -a \
+   "`uname -sv`" = "AIX 4"; then
+	CFLAGS=`echo $CFLAGS | sed -e 's/-g//'`
+fi
+
+dnl Hack to work around a Mac OS X cpp problem
+dnl Known versions needing this workaround are 5.3 and 5.4
+if test "$ac_cv_prog_gcc" = "yes" -a "`uname -s`" = "Rhapsody"; then
+        CPPFLAGS="$CPPFLAGS -traditional-cpp"
+fi
+
+AC_CHECK_HEADERS(
+limits.h \
+malloc.h \
+string.h \
+unistd.h \
+stdarg.h \
+sys/types.h \
+signal.h \
+unix.h \
+dlfcn.h)
+
+AC_TYPE_SIZE_T
+AC_TYPE_SIGNAL
+
+AC_CHECK_LIB(dl, dlopen, [LIBS="-ldl $LIBS"])
+AC_CHECK_FUNC(dlopen,[AC_DEFINE(HAVE_LIBDL, 1,[ ])])
+
+dnl This is required for QNX and may be some BSD derived systems
+AC_CHECK_TYPE( uint, unsigned int )
+AC_CHECK_TYPE( ulong, unsigned long )
+
+
+dnl Checks for library functions.
+AC_FUNC_VPRINTF
+AC_FUNC_MEMCMP
+AC_FUNC_ALLOCA
+AC_CHECK_FUNCS(memcpy strdup getpid kill strtod strtol finite)
+AC_ZEND_BROKEN_SPRINTF
+
+AC_CHECK_FUNCS(finite isfinite isinf isnan)
+
+ZEND_FP_EXCEPT
+	
+AC_SUBST(ZEND_SCANNER)
+
+])
+
+
+
+
+
+AC_DEFUN(LIBZEND_ENABLE_DEBUG,[
+
+AC_ARG_ENABLE(debug,
+[  --enable-debug         Compile with debugging symbols],[
+  ZEND_DEBUG=$enableval
+],[
+  ZEND_DEBUG=no
+])  
+
+])
+
+
+
+
+
+
+
+
+
+
+
+
+AC_DEFUN(LIBZEND_OTHER_CHECKS,[
+
+AC_ARG_ENABLE(experimental-zts,
+[  --enable-experimental-zts   This will most likely break your build],[
+  ZEND_EXPERIMENTAL_ZTS=$enableval
+],[
+  ZEND_EXPERIMENTAL_ZTS=no
+])  
+
+AC_ARG_ENABLE(inline-optimization,
+[  --enable-inline-optimization   If you have much memory and are using
+                                 gcc, you might try this.],[
+  ZEND_INLINE_OPTIMIZATION=$enableval
+],[
+  ZEND_INLINE_OPTIMIZATION=no
+])
+
+AC_ARG_ENABLE(memory-limit,
+[  --enable-memory-limit   Compile with memory limit support. ], [
+  ZEND_MEMORY_LIMIT=$enableval
+],[
+  ZEND_MEMORY_LIMIT=no
+])
+
+AC_MSG_CHECKING(whether to enable experimental ZTS)
+AC_MSG_RESULT($ZEND_EXPERIMENTAL_ZTS)
+
+AC_MSG_CHECKING(whether to enable inline optimization for GCC)
+AC_MSG_RESULT($ZEND_INLINE_OPTIMIZATION)
+
+AC_MSG_CHECKING(whether to enable a memory limit)
+AC_MSG_RESULT($ZEND_MEMORY_LIMIT)
+
+AC_MSG_CHECKING(whether to enable Zend debugging)
+AC_MSG_RESULT($ZEND_DEBUG)
+	
+if test "$ZEND_DEBUG" = "yes"; then
+  AC_DEFINE(ZEND_DEBUG,1,[ ])
+  echo " $CFLAGS" | grep ' -g' >/dev/null || DEBUG_CFLAGS="-g"
+  if test "$CFLAGS" = "-g -O2"; then
+  	CFLAGS=-g
+  fi
+  test -n "$GCC" && DEBUG_CFLAGS="$DEBUG_CFLAGS -Wall"
+  test -n "$GCC" && test "$USE_MAINTAINER_MODE" = "yes" && \
+    DEBUG_CFLAGS="$DEBUG_CFLAGS -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations"
+else
+  AC_DEFINE(ZEND_DEBUG,0,[ ])
+fi
+
+test -n "$DEBUG_CFLAGS" && CFLAGS="$CFLAGS $DEBUG_CFLAGS"
+
+if test "$ZEND_EXPERIMENTAL_ZTS" = "yes"; then
+  AC_DEFINE(ZTS,1,[ ])
+  ZEND_SCANNER_TYPE=cc
+  CPPFLAGS="$CPPFLAGS -I../TSRM"
+  LIBZEND_CPLUSPLUS_CHECKS
+else
+  ZEND_SCANNER_TYPE=c
+fi  
+
+ZEND_SCANNER="libZend_${ZEND_SCANNER_TYPE}.la"
+
+if test "$ZEND_MEMORY_LIMIT" = "yes"; then
+  AC_DEFINE(MEMORY_LIMIT, 1, [Memory limit])
+else
+  AC_DEFINE(MEMORY_LIMIT, 0, [Memory limit])
+fi
+
+changequote({,})
+if test -n "$GCC" && test "$ZEND_INLINE_OPTIMIZATION" != "yes"; then
+  INLINE_CFLAGS=`echo $ac_n "$CFLAGS $ac_c" | sed s/-O[0-9]*//`
+else
+  INLINE_CFLAGS="$CFLAGS"
+fi
+changequote([,])
+
+AC_C_INLINE
+
+AC_SUBST(INLINE_CFLAGS)
+
+])
+
+
+AC_DEFUN(LIBZEND_CPLUSPLUS_CHECKS,[
+
+dnl extra check to avoid C++ preprocessor testing if in non-ZTS mode
+		
+if test "$ZEND_EXPERIMENTAL_ZTS" = "yes"; then
+AC_PROG_CXX		
+AC_PROG_CXXCPP
+AC_LANG_CPLUSPLUS
+AC_CHECK_HEADER(stdiostream.h, [ AC_DEFINE(HAVE_STDIOSTREAM_H, [], Whether you have stdiostream.h) ])
+
+AC_CHECK_LIB(C, cin)
+AC_CHECK_LIB(g++, cin)
+AC_CHECK_LIB(stdc++, cin)
+dnl Digital Unix 4.0
+AC_CHECK_LIB(cxx, cin)
+AC_CHECK_LIB(cxxstd, __array_delete)
+
+AC_CACHE_CHECK(for class istdiostream,ac_cv_class_istdiostream,[
+AC_TRY_COMPILE([
+#include <sys/types.h>
+#include <unistd.h>
+#include <fstream.h>
+#include <stdiostream.h>
+],[
+istdiostream *foo = new istdiostream((FILE *) 0);
+],[
+  ac_cv_class_istdiostream=yes
+],[
+  ac_cv_class_istdiostream=no
+])
+])
+  if test "$ac_cv_class_istdiostream" = "yes"; then
+    AC_DEFINE(HAVE_CLASS_ISTDIOSTREAM, 1, [Whether you have class istdiostream])
+  fi
+AC_LANG_C
+fi
+])
+

Zend/ZendCore.dep

@@ -0,0 +1,258 @@
+# Microsoft Developer Studio Generated Dependency File, included by ZendCore.mak
+
+.\zend_alloc.c : \
+	"..\..\..\program files\microsoft visual studio\vc98\include\basetsd.h"\
+	".\zend_alloc.h"\
+	".\zend_compile.h"\
+	".\zend_config.w32.h"\
+	".\zend_execute.h"\
+	".\zend_llist.h"\
+	".\zend_ptr_stack.h"\
+	".\zend_stack.h"\
+	".\zend.h"\
+	".\zend_errors.h"\
+	".\zend_globals.h"\
+	".\zend_hash.h"\
+	
+
+.\alloca.c : \
+	"..\..\..\program files\microsoft visual studio\vc98\include\basetsd.h"\
+	".\zend_config.w32.h"\
+	".\zend.h"\
+	".\zend_errors.h"\
+	".\zend_hash.h"\
+	
+
+.\zend_compile.c : \
+	"..\..\..\program files\microsoft visual studio\vc98\include\basetsd.h"\
+	".\zend_alloc.h"\
+	".\zend_compile.h"\
+	".\zend_config.w32.h"\
+	".\zend_execute.h"\
+	".\zend_llist.h"\
+	".\modules.h"\
+	".\zend_operators.h"\
+	".\zend_ptr_stack.h"\
+	".\zend_stack.h"\
+	".\zend_variables.h"\
+	".\zend.h"\
+	".\zend_API.h"\
+	".\zend_errors.h"\
+	".\zend_globals.h"\
+	".\zend_hash.h"\
+	".\zend_ini.h"\
+	
+
+.\zend_constants.c : \
+	"..\..\..\program files\microsoft visual studio\vc98\include\basetsd.h"\
+	".\zend_alloc.h"\
+	".\zend_config.w32.h"\
+	".\zend_constants.h"\
+	".\zend_operators.h"\
+	".\zend_variables.h"\
+	".\zend.h"\
+	".\zend_errors.h"\
+	".\zend_hash.h"\
+	
+
+.\zend_execute.c : \
+	"..\..\..\program files\microsoft visual studio\vc98\include\basetsd.h"\
+	".\zend_alloc.h"\
+	".\zend_compile.h"\
+	".\zend_config.w32.h"\
+	".\zend_constants.h"\
+	".\zend_execute.h"\
+	".\zend_llist.h"\
+	".\modules.h"\
+	".\zend_operators.h"\
+	".\zend_ptr_stack.h"\
+	".\zend_stack.h"\
+	".\zend_variables.h"\
+	".\zend.h"\
+	".\zend_API.h"\
+	".\zend_errors.h"\
+	".\zend_globals.h"\
+	".\zend_hash.h"\
+	".\zend_ini.h"\
+	
+
+.\zend_highlight.c : \
+	"..\..\..\program files\microsoft visual studio\vc98\include\basetsd.h"\
+	".\zend_alloc.h"\
+	".\zend_compile.h"\
+	".\zend_config.w32.h"\
+	".\zend_execute.h"\
+	".\zend_highlight.h"\
+	".\zend_llist.h"\
+	".\zend_ptr_stack.h"\
+	".\zend_stack.h"\
+	".\zend_language_parser.tab.h"\
+	".\zend.h"\
+	".\zend_errors.h"\
+	".\zend_globals.h"\
+	".\zend_hash.h"\
+	
+
+.\zend_llist.c : \
+	"..\..\..\program files\microsoft visual studio\vc98\include\basetsd.h"\
+	".\zend_alloc.h"\
+	".\zend_config.w32.h"\
+	".\zend_llist.h"\
+	".\zend.h"\
+	".\zend_errors.h"\
+	".\zend_hash.h"\
+	
+
+.\zend_opcode.c : \
+	"..\..\..\program files\microsoft visual studio\vc98\include\basetsd.h"\
+	".\zend_alloc.h"\
+	".\zend_compile.h"\
+	".\zend_config.w32.h"\
+	".\zend_execute.h"\
+	".\zend_llist.h"\
+	".\modules.h"\
+	".\zend_operators.h"\
+	".\zend_ptr_stack.h"\
+	".\zend_stack.h"\
+	".\zend_variables.h"\
+	".\zend.h"\
+	".\zend_API.h"\
+	".\zend_errors.h"\
+	".\zend_globals.h"\
+	".\zend_hash.h"\
+	".\zend_ini.h"\
+	
+
+.\zend_operators.c : \
+	"..\..\..\program files\microsoft visual studio\vc98\include\basetsd.h"\
+	".\zend_alloc.h"\
+	".\zend_compile.h"\
+	".\zend_config.w32.h"\
+	".\zend_execute.h"\
+	".\zend_llist.h"\
+	".\zend_operators.h"\
+	".\zend_ptr_stack.h"\
+	".\zend_stack.h"\
+	".\zend_variables.h"\
+	".\zend.h"\
+	".\zend_errors.h"\
+	".\zend_globals.h"\
+	".\zend_hash.h"\
+	
+
+.\zend_ptr_stack.c : \
+	"..\..\..\program files\microsoft visual studio\vc98\include\basetsd.h"\
+	".\zend_alloc.h"\
+	".\zend_config.w32.h"\
+	".\zend_ptr_stack.h"\
+	".\zend.h"\
+	".\zend_errors.h"\
+	".\zend_hash.h"\
+	
+
+.\zend_stack.c : \
+	"..\..\..\program files\microsoft visual studio\vc98\include\basetsd.h"\
+	".\zend_alloc.h"\
+	".\zend_config.w32.h"\
+	".\zend_stack.h"\
+	".\zend.h"\
+	".\zend_errors.h"\
+	".\zend_hash.h"\
+	
+
+.\zend_variables.c : \
+	"..\..\..\program files\microsoft visual studio\vc98\include\basetsd.h"\
+	".\zend_alloc.h"\
+	".\zend_compile.h"\
+	".\zend_config.w32.h"\
+	".\zend_constants.h"\
+	".\zend_execute.h"\
+	".\zend_llist.h"\
+	".\modules.h"\
+	".\zend_ptr_stack.h"\
+	".\zend_stack.h"\
+	".\zend_variables.h"\
+	".\zend.h"\
+	".\zend_API.h"\
+	".\zend_errors.h"\
+	".\zend_globals.h"\
+	".\zend_hash.h"\
+	".\zend_ini.h"\
+	".\zend_list.h"\
+	
+
+.\zend.c : \
+	"..\..\..\program files\microsoft visual studio\vc98\include\basetsd.h"\
+	".\zend_alloc.h"\
+	".\zend_config.w32.h"\
+	".\zend_operators.h"\
+	".\zend_variables.h"\
+	".\zend.h"\
+	".\zend_errors.h"\
+	".\zend_hash.h"\
+	
+
+.\zend_API.c : \
+	"..\..\..\program files\microsoft visual studio\vc98\include\basetsd.h"\
+	".\zend_alloc.h"\
+	".\zend_compile.h"\
+	".\zend_config.w32.h"\
+	".\zend_constants.h"\
+	".\zend_execute.h"\
+	".\zend_llist.h"\
+	".\modules.h"\
+	".\zend_operators.h"\
+	".\zend_ptr_stack.h"\
+	".\zend_stack.h"\
+	".\zend_variables.h"\
+	".\zend.h"\
+	".\zend_API.h"\
+	".\zend_errors.h"\
+	".\zend_globals.h"\
+	".\zend_hash.h"\
+	".\zend_ini.h"\
+	".\zend_list.h"\
+	
+
+.\zend_hash.c : \
+	"..\..\..\program files\microsoft visual studio\vc98\include\basetsd.h"\
+	".\zend_config.w32.h"\
+	".\zend.h"\
+	".\zend_errors.h"\
+	".\zend_hash.h"\
+	
+
+.\zend_ini.c : \
+	"..\..\..\program files\microsoft visual studio\vc98\include\basetsd.h"\
+	".\zend_alloc.h"\
+	".\zend_config.w32.h"\
+	".\zend.h"\
+	".\zend_errors.h"\
+	".\zend_hash.h"\
+	".\zend_ini.h"\
+	
+
+!IF  "$(CFG)" == "ZendCore - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "ZendCore - Win32 Debug"
+
+!ENDIF 
+
+!IF  "$(CFG)" == "ZendCore - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "ZendCore - Win32 Debug"
+
+!ENDIF 
+
+!IF  "$(CFG)" == "ZendCore - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "ZendCore - Win32 Debug"
+
+!ENDIF 
+
+!IF  "$(CFG)" == "ZendCore - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "ZendCore - Win32 Debug"
+
+!ENDIF 
+

Zend/ZendTS.dsp

@@ -0,0 +1,570 @@
+# Microsoft Developer Studio Project File - Name="ZendTS" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=ZendTS - Win32 Release_TS_inline
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "ZendTS.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "ZendTS.mak" CFG="ZendTS - Win32 Release_TS_inline"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "ZendTS - Win32 Release_TS" (based on "Win32 (x86) Static Library")
+!MESSAGE "ZendTS - Win32 Debug_TS" (based on "Win32 (x86) Static Library")
+!MESSAGE "ZendTS - Win32 Release_TS_inline" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "ZendTS - Win32 Release_TS"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Output_Dir "Release_TS"
+# PROP BASE Intermediate_Dir "Release_TS"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Output_Dir "Release_TS"
+# PROP Intermediate_Dir "Release_TS"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDebug_TS" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDebug_TS" /D ZEND_DEBUG=0 /D _WIN32_WINNT=0x400 /D "_LIB" /D "TSRM_EXPORTS" /D "LIBZEND_EXPORTS" /D "ZTS" /D "ZEND_WIN32" /D "WIN32" /D "_MBCS" /FR /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x40d /d "NDebug_TS"
+# ADD RSC /l 0x40d /d "NDebug_TS"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "ZendTS - Win32 Debug_TS"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Output_Dir "Debug_TS"
+# PROP BASE Intermediate_Dir "Debug_TS"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Output_Dir "Debug_TS"
+# PROP Intermediate_Dir "Debug_TS"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_Debug_TS" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "." /D "_Debug_TS" /D ZEND_DEBUG=1 /D "_LIB" /D "TSRM_EXPORTS" /D "LIBZEND_EXPORTS" /D "ZTS" /D "ZEND_WIN32" /D "WIN32" /D "_MBCS" /FR /YX /FD /GZ /c
+# ADD BASE RSC /l 0x40d /d "_Debug_TS"
+# ADD RSC /l 0x40d /d "_Debug_TS"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "ZendTS - Win32 Release_TS_inline"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Output_Dir "ZendTS___Win32_Release_TS_inline"
+# PROP BASE Intermediate_Dir "ZendTS___Win32_Release_TS_inline"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Output_Dir "Release_TS_inline"
+# PROP Intermediate_Dir "Release_TS_inline"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDebug_TS" /D "_LIB" /D "TSRM_EXPORTS" /D "LIBZEND_EXPORTS" /D "ZTS" /D "WIN32" /D "_MBCS" /D ZEND_DEBUG=0 /FR /FD /c
+# SUBTRACT BASE CPP /YX
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "." /D "NDebug_TS" /D ZEND_DEBUG=0 /D "ZEND_WIN32_FORCE_INLINE" /D _WIN32_WINNT=0x400 /D "_LIB" /D "TSRM_EXPORTS" /D "LIBZEND_EXPORTS" /D "ZTS" /D "ZEND_WIN32" /D "WIN32" /D "_MBCS" /FR /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x40d /d "NDebug_TS"
+# ADD RSC /l 0x40d /d "NDebug_TS"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ENDIF 
+
+# Begin Target
+
+# Name "ZendTS - Win32 Release_TS"
+# Name "ZendTS - Win32 Debug_TS"
+# Name "ZendTS - Win32 Release_TS_inline"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\zend.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_alloc.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_API.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_builtin_functions.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_compile.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_constants.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_dynamic_array.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_execute.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_execute_API.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_extensions.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_hash.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_highlight.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_indent.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ini.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ini_parser.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ini_scanner.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend_language_parser.c"
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend_language_scanner.cpp"
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_list.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_llist.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_opcode.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_operators.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ptr_stack.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_sprintf.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_stack.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_variables.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\FlexLexer.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\modules.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_API.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_builtin_functions.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_compile.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_config.w32.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_constants.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_dynamic_array.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_errors.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_execute.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_execute_locks.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_extensions.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_fast_cache.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_globals.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_globals_macros.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_hash.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_highlight.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_indent.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ini.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ini_parser.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ini_scanner.h
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend_language_parser.h"
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend_language_scanner.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_list.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_llist.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_operators.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_ptr_stack.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_stack.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zend_variables.h
+# End Source File
+# End Group
+# Begin Group "Parsers"
+
+# PROP Default_Filter "y"
+# Begin Source File
+
+SOURCE=.\zend_ini_parser.y
+
+!IF  "$(CFG)" == "ZendTS - Win32 Release_TS"
+
+# Begin Custom Build
+InputDir=.
+InputPath=.\zend_ini_parser.y
+
+BuildCmds= \
+	if not "X%CYGWIN%"=="X" bison --output=zend_ini_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p ini_ zend_ini_parser.y \
+	if "X%CYGWIN%"=="X" bison --output=zend_ini_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p ini_ zend_ini_parser.y \
+	
+
+"$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+
+"$(InputDir)\zend_ini_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "ZendTS - Win32 Debug_TS"
+
+# Begin Custom Build
+InputDir=.
+InputPath=.\zend_ini_parser.y
+
+BuildCmds= \
+	if not "X%CYGWIN%"=="X" bison --output=zend_ini_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p ini_ zend_ini_parser.y \
+	if "X%CYGWIN%"=="X" bison --output=zend_ini_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p ini_ zend_ini_parser.y \
+	
+
+"$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+
+"$(InputDir)\zend_ini_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "ZendTS - Win32 Release_TS_inline"
+
+# Begin Custom Build
+InputDir=.
+InputPath=.\zend_ini_parser.y
+
+BuildCmds= \
+	if not "X%CYGWIN%"=="X" bison --output=zend_ini_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p ini_ zend_ini_parser.y \
+	if "X%CYGWIN%"=="X" bison --output=zend_ini_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p ini_ zend_ini_parser.y \
+	
+
+"$(InputDir)\zend_ini_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+
+"$(InputDir)\zend_ini_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend_language_parser.y"
+
+!IF  "$(CFG)" == "ZendTS - Win32 Release_TS"
+
+# Begin Custom Build
+InputDir=.
+InputPath=".\zend_language_parser.y"
+
+BuildCmds= \
+	if not "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend_language_parser.y \
+	if "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend_language_parser.y \
+	
+
+"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+
+"$(InputDir)\zend_language_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "ZendTS - Win32 Debug_TS"
+
+# Begin Custom Build
+InputDir=.
+InputPath=".\zend_language_parser.y"
+
+BuildCmds= \
+	if not "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend_language_parser.y \
+	if "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend_language_parser.y \
+	
+
+"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+
+"$(InputDir)\zend_language_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "ZendTS - Win32 Release_TS_inline"
+
+# Begin Custom Build
+InputDir=.
+InputPath=".\zend_language_parser.y"
+
+BuildCmds= \
+	if not "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "%CYGWIN%\share\bison.simple" -p zend zend_language_parser.y \
+	if "X%CYGWIN%"=="X" bison --output=zend_language_parser.c -v -d -S "C:\Program Files\Cygnus\share\bison.simple" -p zend zend_language_parser.y \
+	
+
+"$(InputDir)\zend_language_parser.c" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+
+"$(InputDir)\zend_language_parser.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   $(BuildCmds)
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Scanners"
+
+# PROP Default_Filter "l"
+# Begin Source File
+
+SOURCE=.\zend_ini_scanner.l
+
+!IF  "$(CFG)" == "ZendTS - Win32 Release_TS"
+
+# Begin Custom Build
+InputPath=.\zend_ini_scanner.l
+
+"zend_ini_scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -+ -B -i -Sflex.skl -Pini_ -ozend_ini_scanner.cpp zend_ini_scanner.l
+
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "ZendTS - Win32 Debug_TS"
+
+# Begin Custom Build
+InputPath=.\zend_ini_scanner.l
+
+"zend_ini_scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -+ -B -i -Sflex.skl -Pini_ -ozend_ini_scanner.cpp zend_ini_scanner.l
+
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "ZendTS - Win32 Release_TS_inline"
+
+# Begin Custom Build
+InputPath=.\zend_ini_scanner.l
+
+"zend_ini_scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -+ -B -i -Sflex.skl -Pini_ -ozend_ini_scanner.cpp zend_ini_scanner.l
+
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=".\zend_language_scanner.l"
+
+!IF  "$(CFG)" == "ZendTS - Win32 Release_TS"
+
+# Begin Custom Build
+InputPath=".\zend_language_scanner.l"
+
+"zend_language_scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -+ -B -i -Sflex.skl -Pzend -ozend_language_scanner.cpp zend_language_scanner.l
+
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "ZendTS - Win32 Debug_TS"
+
+# Begin Custom Build
+InputPath=".\zend_language_scanner.l"
+
+"zend_language_scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -+ -B -i -Sflex.skl -Pzend -ozend_language_scanner.cpp zend_language_scanner.l
+
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "ZendTS - Win32 Release_TS_inline"
+
+# Begin Custom Build
+InputPath=".\zend_language_scanner.l"
+
+"zend_language_scanner.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	flex -+ -B -i -Sflex.skl -Pzend -ozend_language_scanner.cpp zend_language_scanner.l
+
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Text Files"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\LICENSE
+# End Source File
+# Begin Source File
+
+SOURCE=.\ZEND_BUGS
+# End Source File
+# Begin Source File
+
+SOURCE=.\ZEND_CHANGES
+# End Source File
+# End Group
+# Begin Group "Resources"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\zend.ico
+# End Source File
+# End Group
+# End Target
+# End Project

Zend/acconfig.h

@@ -0,0 +1,68 @@
+#define ZEND_API
+#define ZEND_DLEXPORT
+
+@TOP@
+
+#undef uint
+#undef ulong
+
+/* Define if you want to enable memory limit support */
+#define MEMORY_LIMIT 0
+
+@BOTTOM@
+
+#ifdef HAVE_STDLIB_H
+# include <stdlib.h>
+#endif
+
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#ifdef HAVE_STRING_H
+# include <string.h>
+#else
+# include <strings.h>
+#endif
+
+#if ZEND_BROKEN_SPRINTF
+int zend_sprintf(char *buffer, const char *format, ...);
+#else
+# define zend_sprintf sprintf
+#endif
+
+#include <math.h>
+
+#ifdef HAVE_ISNAN
+#define zend_isnan(a) isnan(a)
+#elif defined(NAN)
+#define zend_isnan(a) (((a)==NAN)?1:0)
+#else
+#define zend_isnan(a) 0
+#endif
+
+#ifdef HAVE_ISINF
+#define zend_isinf(a) isinf(a)
+#elif defined(INFINITY)
+/* Might not work, but is required by ISO C99 */
+#define zend_isinf(a) (((a)==INFINITY)?1:0)
+#else
+#define zend_isinf(a) 0
+#endif
+
+#ifdef HAVE_FINITE
+#define zend_finite(a) finite(a)
+#elif defined(HAVE_ISFINITE) || defined(isfinite)
+#define zend_finite(a) isfinite(a)
+#elif defined(fpclassify)
+#define zend_finite(a) ((fpclassify((a))!=FP_INFINITE&&fpclassify((a))!=FP_NAN)?1:0)
+#else
+#define zend_finite(a) (zend_isnan(a) ? 0 : zend_isinf(a) ? 0 : 1)
+#endif
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */

Zend/acinclude.m4

@@ -0,0 +1,47 @@
+dnl $Id$
+dnl
+dnl This file contains local autoconf functions.
+
+AC_DEFUN(ZEND_FP_EXCEPT,[
+  AC_CACHE_CHECK(whether fp_except is defined, ac_cv_type_fp_except,[
+    AC_TRY_COMPILE([
+#include <floatingpoint.h>
+],[
+fp_except x = (fp_except) 0;
+],[
+     ac_cv_type_fp_except=yes
+],[
+     ac_cv_type_fp_except=no
+],[
+     ac_cv_type_fp_except=no
+])])
+  if test "$ac_cv_type_fp_except" = "yes"; then
+    AC_DEFINE(HAVE_FP_EXCEPT, 1, [whether floatingpoint.h defines fp_except])
+  fi
+])
+
+dnl
+dnl Check for broken sprintf()
+dnl
+AC_DEFUN(AC_ZEND_BROKEN_SPRINTF,[
+  AC_CACHE_CHECK(whether sprintf is broken, ac_cv_broken_sprintf,[
+    AC_TRY_RUN([main() {char buf[20];exit(sprintf(buf,"testing 123")!=11); }],[
+      ac_cv_broken_sprintf=no
+    ],[
+      ac_cv_broken_sprintf=yes
+    ],[
+      ac_cv_broken_sprintf=no
+    ])
+  ])
+  if test "$ac_cv_broken_sprintf" = "yes"; then
+    ac_result=1
+  else
+    ac_result=0
+  fi
+  AC_DEFINE_UNQUOTED(ZEND_BROKEN_SPRINTF, $ac_result, [Whether sprintf is broken])
+])
+
+AC_DEFUN(AM_SET_LIBTOOL_VARIABLE,[
+  LIBTOOL='$(SHELL) $(top_builddir)/libtool $1'
+])
+

Zend/build.mk

@@ -0,0 +1,43 @@
+# Makefile to generate build tools
+#
+# Standard usage:
+#        make -f build.mk
+#
+# Written by Sascha Schumann
+#
+# $Id$ 
+
+
+LT_TARGETS = ltmain.sh ltconfig
+
+config_h_in = zend_config.h.in
+
+makefile_am_files = Makefile.am
+makefile_in_files = $(makefile_am_files:.am=.in)
+makefile_files    = $(makefile_am_files:e.am=e)
+
+targets = $(makefile_in_files) $(LT_TARGETS) configure $(config_h_in)
+
+all: $(targets)
+
+clean:
+	rm -f $(targets)
+
+$(LT_TARGETS):
+	rm -f $(LT_TARGETS)
+	libtoolize --automake $(AMFLAGS) -f
+
+$(makefile_in_files): $(makefile_am_files)
+	automake -a -i $(AMFLAGS) $(makefile_files)
+
+aclocal.m4: configure.in acinclude.m4
+	aclocal
+
+$(config_h_in): configure.in acconfig.h
+# explicitly remove target since autoheader does not seem to work 
+# correctly otherwise (timestamps are not updated)
+	@rm -f $@
+	autoheader
+
+configure: aclocal.m4 configure.in
+	autoconf

Zend/buildconf

@@ -0,0 +1,33 @@
+#!/bin/sh
+
+case "$1" in
+--copy)
+	automake_flags=--copy
+	shift
+;;
+esac
+
+libtoolize --force --automake $automake_flags
+
+mv aclocal.m4 aclocal.m4.old 2>/dev/null
+aclocal
+if cmp aclocal.m4.old aclocal.m4 > /dev/null 2>&1; then
+    echo "buildconf: keeping ${1}aclocal.m4"
+    mv aclocal.m4.old aclocal.m4
+else
+    echo "buildconf: created or modified ${1}aclocal.m4"
+fi
+
+autoheader
+
+automake --add-missing --include-deps $automake_flags
+
+mv configure configure.old 2>/dev/null
+autoconf
+if cmp configure.old configure > /dev/null 2>&1; then
+    echo "buildconf: keeping ${1}configure"
+    mv configure.old configure
+else
+    echo "buildconf: created or modified ${1}configure"
+fi
+

Zend/configure.in

@@ -0,0 +1,45 @@
+dnl $Id$
+dnl Process this file with autoconf to produce a configure script.
+
+AC_INIT(zend.c)
+AM_INIT_AUTOMAKE(zend, 0.80A, nodefine)
+AM_CONFIG_HEADER(zend_config.h)
+AM_SANITY_CHECK
+AM_MAINTAINER_MODE
+AC_PROG_CC
+AM_PROG_LEX
+AM_PROG_CC_STDC
+ZEND_VERSION=$VERSION
+
+dnl We want this one before the checks, so the checks can modify CFLAGS.
+test -z "$CFLAGS" && auto_cflags=1
+
+sinclude(Zend.m4)
+
+LIBZEND_BASIC_CHECKS
+
+AM_PROG_LIBTOOL
+if test "$enable_debug" != "yes"; then
+  AM_SET_LIBTOOL_VARIABLE([--silent])
+fi
+
+dnl
+dnl Check for /usr/pkg/{lib,include} which is where NetBSD puts binary
+dnl and source packages.  This should be harmless on other OSs.
+dnl
+if test -d /usr/pkg/include -a -d /usr/pkg/lib ; then
+       CFLAGS="$CFLAGS -I/usr/pkg/include"
+       LDFLAGS="$LDFLAGS -L/usr/pkg/lib"
+fi
+
+LIBZEND_ENABLE_DEBUG
+LIBZEND_OTHER_CHECKS
+
+EXTRA_LIBS="$LIBS"
+LIBS=""
+AC_SUBST(EXTRA_LIBS)
+AC_OUTPUT(Makefile)
+
+# Local Variables:
+# tab-width: 4
+# End:

Zend/zend.c

@@ -0,0 +1,770 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#include "zend.h"
+#include "zend_extensions.h"
+#include "modules.h"
+#include "zend_constants.h"
+#include "zend_list.h"
+#include "zend_API.h"
+#include "zend_builtin_functions.h"
+
+#ifdef ZTS
+#	define GLOBAL_FUNCTION_TABLE	global_function_table
+#	define GLOBAL_CLASS_TABLE		global_class_table
+#	define GLOBAL_CONSTANTS_TABLE	global_constants_table
+#else
+#	define GLOBAL_FUNCTION_TABLE	CG(function_table)
+#	define GLOBAL_CLASS_TABLE		CG(class_table)
+#	define GLOBAL_CONSTANTS_TABLE	CG(zend_constants)
+#endif
+
+#if defined(ZEND_WIN32) && ZEND_DEBUG
+BOOL WINAPI IsDebuggerPresent(VOID);
+#endif
+
+/* true multithread-shared globals */
+ZEND_API zend_class_entry zend_standard_class_def;
+ZEND_API int (*zend_printf)(const char *format, ...);
+ZEND_API zend_write_func_t zend_write;
+ZEND_API FILE *(*zend_fopen)(const char *filename, char **opened_path);
+ZEND_API void (*zend_block_interruptions)(void);
+ZEND_API void (*zend_unblock_interruptions)(void);
+ZEND_API void (*zend_ticks_function)(int ticks);
+ZEND_API void (*zend_error_cb)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args);
+
+static void (*zend_message_dispatcher_p)(long message, void *data);
+static int (*zend_get_ini_entry_p)(char *name, uint name_length, zval *contents);
+
+
+#ifdef ZTS
+ZEND_API int compiler_globals_id;
+ZEND_API int executor_globals_id;
+ZEND_API int alloc_globals_id;
+HashTable *global_function_table;
+HashTable *global_class_table;
+HashTable *global_constants_table;
+#endif
+
+zend_utility_values zend_uv;
+
+ZEND_API zval zval_used_for_init; /* True global variable */
+
+/* version information */
+static char *zend_version_info;
+static uint zend_version_info_length;
+#define ZEND_CORE_VERSION_INFO	"Zend Engine v" ZEND_VERSION ", Copyright (c) 1998-2000 Zend Technologies\n"
+
+
+#define PRINT_ZVAL_INDENT 4
+
+static void print_hash(HashTable *ht, int indent)
+{
+	zval **tmp;
+	char *string_key;
+	unsigned long num_key;
+	int i;
+
+	for (i=0; i<indent; i++) {
+		ZEND_PUTS(" ");
+	}
+	ZEND_PUTS("(\n");
+	indent += PRINT_ZVAL_INDENT;
+	zend_hash_internal_pointer_reset(ht);
+	while (zend_hash_get_current_data(ht, (void **) &tmp) == SUCCESS) {
+		for (i=0; i<indent; i++) {
+			ZEND_PUTS(" ");
+		}
+		ZEND_PUTS("[");
+		switch (zend_hash_get_current_key(ht, &string_key, &num_key)) {
+			case HASH_KEY_IS_STRING:
+				ZEND_PUTS(string_key);
+				efree(string_key);
+				break;
+			case HASH_KEY_IS_LONG:
+				zend_printf("%ld",num_key);
+				break;
+		}
+		ZEND_PUTS("] => ");
+		zend_print_zval_r(*tmp, indent+PRINT_ZVAL_INDENT);
+		ZEND_PUTS("\n");
+		zend_hash_move_forward(ht);
+	}
+	indent -= PRINT_ZVAL_INDENT;
+	for (i=0; i<indent; i++) {
+		ZEND_PUTS(" ");
+	}
+	ZEND_PUTS(")\n");
+}
+
+
+ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_copy)
+{
+	if (expr->type==IS_STRING) {
+		*use_copy = 0;
+		return;
+	}
+	switch (expr->type) {
+		case IS_NULL:
+			expr_copy->value.str.len = 0;
+			expr_copy->value.str.val = empty_string;
+			break;
+		case IS_BOOL:
+			if (expr->value.lval) {
+				expr_copy->value.str.len = 1;
+				expr_copy->value.str.val = estrndup("1", 1);
+			} else {
+				expr_copy->value.str.len = 0;
+				expr_copy->value.str.val = empty_string;
+			}
+			break;
+		case IS_RESOURCE:
+			expr_copy->value.str.val = (char *) emalloc(sizeof("Resource id #")-1 + MAX_LENGTH_OF_LONG);
+			expr_copy->value.str.len = sprintf(expr_copy->value.str.val, "Resource id #%ld", expr->value.lval);
+			break;
+		case IS_ARRAY:
+			expr_copy->value.str.len = sizeof("Array")-1;
+			expr_copy->value.str.val = estrndup("Array", expr_copy->value.str.len);
+			break;
+		case IS_OBJECT:
+			expr_copy->value.str.len = sizeof("Object")-1;
+			expr_copy->value.str.val = estrndup("Object", expr_copy->value.str.len);
+			break;
+		default:
+			*expr_copy = *expr;
+			zval_copy_ctor(expr_copy);
+			convert_to_string(expr_copy);
+			break;
+	}
+	expr_copy->type = IS_STRING;
+	*use_copy = 1;
+}
+
+
+ZEND_API int zend_print_zval(zval *expr, int indent)
+{
+	return zend_print_zval_ex(zend_write, expr, indent);
+}
+
+
+ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent)
+{
+	zval expr_copy;
+	int use_copy;
+
+	zend_make_printable_zval(expr, &expr_copy, &use_copy);
+	if (use_copy) {
+		expr = &expr_copy;
+	}
+	if (expr->value.str.len==0) { /* optimize away empty strings */
+		if (use_copy) {
+			zval_dtor(expr);
+		}
+		return 0;
+	}
+	write_func(expr->value.str.val,expr->value.str.len);
+	if (use_copy) {
+		zval_dtor(expr);
+	}
+	return expr->value.str.len;
+}
+
+
+ZEND_API void zend_print_zval_r(zval *expr, int indent)
+{
+	zend_print_zval_r_ex(zend_write, expr, indent);
+}
+
+
+ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int indent) 
+{
+	switch(expr->type) {
+		case IS_ARRAY:
+			ZEND_PUTS("Array\n");
+			if (++expr->value.ht->nApplyCount>1) {
+				ZEND_PUTS(" *RECURSION*");
+				expr->value.ht->nApplyCount=0;
+				return;
+			}
+			print_hash(expr->value.ht,indent);
+			expr->value.ht->nApplyCount--;
+			break;
+		case IS_OBJECT:
+			if (++expr->value.obj.properties->nApplyCount>1) {
+				ZEND_PUTS(" *RECURSION*");
+				expr->value.obj.properties->nApplyCount=0;
+				return;
+			}
+			zend_printf("%s Object\n", expr->value.obj.ce->name);
+			print_hash(expr->value.obj.properties, indent);
+			expr->value.obj.properties->nApplyCount--;
+			break;
+		default:
+			zend_print_variable(expr);
+			break;
+	}
+}
+
+
+static FILE *zend_fopen_wrapper(const char *filename, char **opened_path)
+{
+	if (opened_path) {
+		*opened_path = estrdup(filename);
+	}
+	return fopen(filename, "rb");
+}
+
+
+static void register_standard_class(void)
+{
+	zend_standard_class_def.type = ZEND_INTERNAL_CLASS;
+	zend_standard_class_def.name_length = sizeof("stdClass") - 1;
+	zend_standard_class_def.name = zend_strndup("stdClass", zend_standard_class_def.name_length);
+	zend_standard_class_def.parent = NULL;
+	zend_hash_init_ex(&zend_standard_class_def.default_properties, 0, NULL, ZVAL_PTR_DTOR, 1, 0);
+	zend_hash_init_ex(&zend_standard_class_def.function_table, 0, NULL, ZEND_FUNCTION_DTOR, 1, 0);
+	zend_standard_class_def.handle_function_call = NULL;
+	zend_standard_class_def.handle_property_get = NULL;
+	zend_standard_class_def.handle_property_set = NULL;
+	zend_standard_class_def.refcount = (int *) malloc(sizeof(int));
+	*zend_standard_class_def.refcount = 1;
+	zend_hash_add(GLOBAL_CLASS_TABLE, "stdclass", sizeof("stdclass"), &zend_standard_class_def, sizeof(zend_class_entry), NULL);
+}
+
+
+static void zend_set_default_compile_time_values(CLS_D)
+{
+	/* default compile-time values */
+	CG(asp_tags) = 0;
+	CG(short_tags) = 1;
+	CG(allow_call_time_pass_reference) = 1;
+	CG(extended_info) = 0;
+}
+
+
+#ifdef ZTS
+static void compiler_globals_ctor(zend_compiler_globals *compiler_globals)
+{
+	zend_function tmp_func;
+	zend_class_entry tmp_class;
+
+	compiler_globals->compiled_filename = NULL;
+
+	compiler_globals->function_table = (HashTable *) malloc(sizeof(HashTable));
+	zend_hash_init_ex(compiler_globals->function_table, 100, NULL, ZEND_FUNCTION_DTOR, 1, 0);
+	zend_hash_copy(compiler_globals->function_table, global_function_table, NULL, &tmp_func, sizeof(zend_function));
+
+	compiler_globals->class_table = (HashTable *) malloc(sizeof(HashTable));
+	zend_hash_init_ex(compiler_globals->class_table, 10, NULL, ZEND_CLASS_DTOR, 1, 0);
+	zend_hash_copy(compiler_globals->class_table, global_class_table, (copy_ctor_func_t) zend_class_add_ref, &tmp_class, sizeof(zend_class_entry));
+
+	zend_set_default_compile_time_values(CLS_C);
+}
+
+
+static void compiler_globals_dtor(zend_compiler_globals *compiler_globals)
+{
+	if (compiler_globals->function_table != global_function_table) {
+		zend_hash_destroy(compiler_globals->function_table);
+		free(compiler_globals->function_table);
+	}
+	if (compiler_globals->class_table != global_class_table) {
+		zend_hash_destroy(compiler_globals->class_table);
+		free(compiler_globals->class_table);
+	}
+}
+
+
+static void executor_globals_ctor(zend_executor_globals *executor_globals)
+{
+	if (global_constants_table) {
+		zend_startup_constants(ELS_C);
+		zend_copy_constants(executor_globals->zend_constants, global_constants_table);
+	}
+	zend_init_rsrc_plist(ELS_C);
+	EG(lambda_count)=0;
+}
+
+
+static void executor_globals_dtor(zend_executor_globals *executor_globals)
+{
+	zend_shutdown_constants(ELS_C);
+	zend_destroy_rsrc_plist(ELS_C);
+}
+
+
+static void alloc_globals_ctor(zend_alloc_globals *alloc_globals)
+{
+	start_memory_manager(ALS_C);
+}
+
+#endif
+
+#ifdef __FreeBSD__
+/* FreeBSD floating point precision fix */
+#include <floatingpoint.h>
+#endif
+
+int zend_startup(zend_utility_functions *utility_functions, char **extensions, int start_builtin_functions)
+{
+#ifdef ZTS
+	zend_compiler_globals *compiler_globals;
+	zend_executor_globals *executor_globals;
+
+	alloc_globals_id = ts_allocate_id(sizeof(zend_alloc_globals), (ts_allocate_ctor) alloc_globals_ctor, NULL);
+#else
+	start_memory_manager(ALS_C);
+#endif
+
+#ifdef __FreeBSD__
+	{
+		/* FreeBSD floating point precision fix */
+#ifdef HAVE_FP_EXCEPT
+		fp_except
+#else
+		fp_except_t
+#endif
+		mask;
+
+		mask = fpgetmask();
+		fpsetmask(mask & ~FP_X_IMP);
+	} 
+#endif
+
+	zend_startup_extensions_mechanism();
+
+	/* Set up utility functions and values */
+	zend_error_cb = utility_functions->error_function;
+	zend_printf = utility_functions->printf_function;
+	zend_write = (zend_write_func_t) utility_functions->write_function;
+	zend_fopen = utility_functions->fopen_function;
+	if (!zend_fopen) {
+		zend_fopen = zend_fopen_wrapper;
+	}
+	zend_message_dispatcher_p = utility_functions->message_handler;
+	zend_block_interruptions = utility_functions->block_interruptions;
+	zend_unblock_interruptions = utility_functions->unblock_interruptions;
+	zend_get_ini_entry_p = utility_functions->get_ini_entry;
+	zend_ticks_function = utility_functions->ticks_function;
+
+	zend_compile_file = compile_file;
+	zend_execute = execute;
+
+	/* set up version */
+	zend_version_info = strdup(ZEND_CORE_VERSION_INFO);
+	zend_version_info_length = sizeof(ZEND_CORE_VERSION_INFO)-1;
+
+	GLOBAL_FUNCTION_TABLE = (HashTable *) malloc(sizeof(HashTable));
+	GLOBAL_CLASS_TABLE = (HashTable *) malloc(sizeof(HashTable));
+	zend_hash_init_ex(GLOBAL_FUNCTION_TABLE, 100, NULL, ZEND_FUNCTION_DTOR, 1, 0);
+	zend_hash_init_ex(GLOBAL_CLASS_TABLE, 10, NULL, ZEND_CLASS_DTOR, 1, 0);
+	register_standard_class();
+	zend_hash_init_ex(&module_registry, 50, NULL, ZEND_MODULE_DTOR, 1, 0);
+	zend_init_rsrc_list_dtors();
+
+	/* This zval can be used to initialize allocate zval's to an uninit'ed value */
+	zval_used_for_init.is_ref = 0;
+	zval_used_for_init.refcount = 1;
+	zval_used_for_init.type = IS_NULL;
+
+#ifdef ZTS
+	global_constants_table = NULL;
+	compiler_globals_id = ts_allocate_id(sizeof(zend_compiler_globals), (void (*)(void *)) compiler_globals_ctor, (void (*)(void *)) compiler_globals_dtor);
+	executor_globals_id = ts_allocate_id(sizeof(zend_executor_globals), (void (*)(void *)) executor_globals_ctor, (void (*)(void *)) executor_globals_dtor);
+	compiler_globals = ts_resource(compiler_globals_id);
+	executor_globals = ts_resource(executor_globals_id);
+	compiler_globals_dtor(compiler_globals);
+	compiler_globals->function_table = GLOBAL_FUNCTION_TABLE;
+	compiler_globals->class_table = GLOBAL_CLASS_TABLE;
+	zend_startup_constants(executor_globals);
+	GLOBAL_CONSTANTS_TABLE = EG(zend_constants);
+#else
+	zend_startup_constants();
+	zend_set_default_compile_time_values(CLS_C);
+#endif
+	zend_register_standard_constants(ELS_C);
+
+#ifndef ZTS
+	zend_init_rsrc_plist(ELS_C);
+#endif
+
+	if (start_builtin_functions) {
+		zend_startup_builtin_functions();
+	}
+
+	return SUCCESS;
+}
+
+
+void zend_shutdown()
+{
+#ifdef ZEND_WIN32
+	zend_shutdown_timeout_thread();
+#endif
+#ifndef ZTS
+	zend_destroy_rsrc_plist();
+#endif
+	zend_destroy_rsrc_list_dtors();
+	zend_hash_destroy(&module_registry);
+	zend_hash_destroy(GLOBAL_FUNCTION_TABLE);
+	free(GLOBAL_FUNCTION_TABLE);
+	zend_hash_destroy(GLOBAL_CLASS_TABLE);
+	free(GLOBAL_CLASS_TABLE);
+	zend_shutdown_extensions();
+	free(zend_version_info);
+#ifndef ZTS
+	zend_shutdown_constants();
+#endif
+}
+
+
+void zend_set_utility_values(zend_utility_values *utility_values)
+{
+	zend_uv = *utility_values;
+	zend_uv.import_use_extension_length = strlen(zend_uv.import_use_extension);
+}
+
+
+/* this should be compatible with the standard zenderror */
+void zenderror(char *error)
+{
+	zend_error(E_PARSE, error);
+}
+
+
+BEGIN_EXTERN_C()
+ZEND_API void zend_bailout()
+{
+	CLS_FETCH();
+	ELS_FETCH();
+
+	CG(unclean_shutdown) = 1;
+	longjmp(EG(bailout), FAILURE);
+}
+END_EXTERN_C()
+
+
+void zend_append_version_info(zend_extension *extension)
+{
+	char *new_info;
+	uint new_info_length;
+
+	new_info_length = sizeof("    with  v,  by \n")
+						+ strlen(extension->name)
+						+ strlen(extension->version)
+						+ strlen(extension->copyright)
+						+ strlen(extension->author);
+
+	new_info = (char *) malloc(new_info_length+1);
+
+	sprintf(new_info, "    with %s v%s, %s, by %s\n", extension->name, extension->version, extension->copyright, extension->author);
+
+	zend_version_info = (char *) realloc(zend_version_info, zend_version_info_length+new_info_length+1);
+	strcat(zend_version_info, new_info);
+	zend_version_info_length += new_info_length;
+	free(new_info);
+}
+
+
+ZEND_API char *get_zend_version()
+{
+	return zend_version_info;
+}
+
+
+void zend_activate(CLS_D ELS_DC)
+{
+	init_compiler(CLS_C ELS_CC);
+	init_executor(CLS_C ELS_CC);
+	startup_scanner(CLS_C);
+}
+
+
+void zend_activate_modules()
+{
+	zend_hash_apply(&module_registry, (int (*)(void *)) module_registry_request_startup);
+}
+
+void zend_deactivate_modules()
+{
+	ELS_FETCH();
+	EG(opline_ptr) = NULL; /* we're no longer executing anything */
+
+	if (setjmp(EG(bailout))==0) {
+		zend_hash_apply(&module_registry, (int (*)(void *)) module_registry_cleanup);
+	}
+}
+
+void zend_deactivate(CLS_D ELS_DC)
+{
+	/* we're no longer executing anything */
+	EG(opline_ptr) = NULL; 
+	EG(active_symbol_table) = NULL;
+
+	if (setjmp(EG(bailout))==0) {
+		shutdown_scanner(CLS_C);
+	}
+	if (setjmp(EG(bailout))==0) {
+		shutdown_executor(ELS_C);
+	}
+	if (setjmp(EG(bailout))==0) {
+		shutdown_compiler(CLS_C);
+	}
+}
+
+
+BEGIN_EXTERN_C()
+ZEND_API void zend_message_dispatcher(long message, void *data)
+{
+	if (zend_message_dispatcher_p) {
+		zend_message_dispatcher_p(message, data);
+	}
+}
+END_EXTERN_C()
+
+
+ZEND_API int zend_get_ini_entry(char *name, uint name_length, zval *contents)
+{
+	if (zend_get_ini_entry_p) {
+		return zend_get_ini_entry_p(name, name_length, contents);
+	} else {
+		return FAILURE;
+	}
+}
+
+
+#define ZEND_ERROR_BUFFER_SIZE 1024
+
+ZEND_API void zend_error(int type, const char *format, ...)
+{
+	va_list args;
+	zval ***params;
+	zval *retval;
+	zval *z_error_type, *z_error_message, *z_error_filename, *z_error_lineno, *z_context;
+	char *error_filename;
+	uint error_lineno;
+	zval *orig_user_error_handler;
+	ELS_FETCH();
+	CLS_FETCH();
+
+	/* Obtain relevant filename and lineno */
+	switch (type) {
+		case E_CORE_ERROR:
+		case E_CORE_WARNING:
+			error_filename = NULL;
+			error_lineno = 0;
+			break;
+		case E_PARSE:
+		case E_COMPILE_ERROR:
+		case E_COMPILE_WARNING:
+		case E_ERROR:
+		case E_NOTICE:
+		case E_WARNING:
+		case E_USER_ERROR:
+		case E_USER_WARNING:
+		case E_USER_NOTICE:
+			if (zend_is_compiling()) {
+				error_filename = zend_get_compiled_filename(CLS_C);
+				error_lineno = zend_get_compiled_lineno(CLS_C);
+			} else if (zend_is_executing()) {
+				error_filename = zend_get_executed_filename(ELS_C);
+				error_lineno = zend_get_executed_lineno(ELS_C);
+			} else {
+				error_filename = NULL;
+				error_lineno = 0;
+			}
+			break;
+		default:
+			error_filename = NULL;
+			error_lineno = 0;
+			break;
+	}
+	if (!error_filename) {
+		error_filename = "Unknown";
+	}
+
+
+	va_start(args, format);
+
+	/* if we don't have a user defined error handler */
+	if (!EG(user_error_handler)) {
+		zend_error_cb(type, error_filename, error_lineno, format, args);
+	} else switch (type) {
+		case E_ERROR:
+		case E_PARSE:
+		case E_CORE_ERROR:
+		case E_CORE_WARNING:
+		case E_COMPILE_ERROR:
+		case E_COMPILE_WARNING:
+			/* The error may not be safe to handle in user-space */
+			zend_error_cb(type, error_filename, error_lineno, format, args);
+			break;
+		default:
+			/* Handle the error in user space */
+			ALLOC_INIT_ZVAL(z_error_message);
+			ALLOC_INIT_ZVAL(z_error_type);
+			ALLOC_INIT_ZVAL(z_error_filename);
+			ALLOC_INIT_ZVAL(z_error_lineno);
+			ALLOC_INIT_ZVAL(z_context);
+			z_error_message->value.str.val = (char *) emalloc(ZEND_ERROR_BUFFER_SIZE);
+
+#ifdef HAVE_VSNPRINTF
+			z_error_message->value.str.len = vsnprintf(z_error_message->value.str.val, ZEND_ERROR_BUFFER_SIZE, format, args);
+			if (z_error_message->value.str.len > ZEND_ERROR_BUFFER_SIZE-1) {
+				z_error_message->value.str.len = ZEND_ERROR_BUFFER_SIZE-1;
+			}
+#else
+			strncpy(z_error_message->value.str.val, format, ZEND_ERROR_BUFFER_SIZE);
+			/* This is risky... */
+			/* z_error_message->value.str.len = vsprintf(z_error_message->value.str.val, format, args); */
+#endif
+			z_error_message->type = IS_STRING;
+
+			z_error_type->value.lval = type;
+			z_error_type->type = IS_LONG;
+
+			if (error_filename) {
+				z_error_filename->value.str.len = strlen(error_filename);
+				z_error_filename->value.str.val = estrndup(error_filename, z_error_filename->value.str.len);
+				z_error_filename->type = IS_STRING;
+			}
+				
+			z_error_lineno->value.lval = error_lineno;
+			z_error_lineno->type = IS_LONG;
+
+			z_context->value.ht = EG(active_symbol_table);
+			z_context->type = IS_ARRAY;
+			ZVAL_ADDREF(z_context);  /* we don't want this one to be freed */
+
+			params = (zval ***) emalloc(sizeof(zval **)*5);
+			params[0] = &z_error_type;
+			params[1] = &z_error_message;
+			params[2] = &z_error_filename;
+			params[3] = &z_error_lineno;
+			params[4] = &z_context;
+
+			orig_user_error_handler = EG(user_error_handler);
+			EG(user_error_handler) = NULL;
+			if (call_user_function_ex(CG(function_table), NULL, orig_user_error_handler, &retval, 5, params, 1, NULL)==SUCCESS) {
+				zval_ptr_dtor(&retval);
+			} else {
+				/* The user error handler failed, use built-in error handler */
+				zend_error_cb(type, error_filename, error_lineno, format, args);
+			}
+			EG(user_error_handler) = orig_user_error_handler;
+
+			efree(params);
+			zval_ptr_dtor(&z_error_message);
+			zval_ptr_dtor(&z_error_type);
+			zval_ptr_dtor(&z_error_filename);
+			zval_ptr_dtor(&z_error_lineno);
+			if (ZVAL_REFCOUNT(z_context)==2) {
+				FREE_ZVAL(z_context);
+			}
+			break;
+	}
+
+	va_end(args);
+}
+
+
+ZEND_API void zend_output_debug_string(zend_bool trigger_break, char *format, ...)
+{
+#if ZEND_DEBUG
+	va_list args;
+
+	va_start(args, format);
+#	ifdef ZEND_WIN32
+	{
+		char output_buf[1024];
+
+		vsnprintf(output_buf, 1024, format, args);
+		OutputDebugString(output_buf);
+		OutputDebugString("\n");
+		if (trigger_break && IsDebuggerPresent()) {
+			DebugBreak();
+		}
+	}
+#	else
+	vfprintf(stderr, format, args);
+	fprintf(stderr, "\n");
+#	endif
+	va_end(args);
+#endif
+}
+
+
+ZEND_API int zend_execute_scripts(int type CLS_DC ELS_DC, int file_count, ...)
+{
+	va_list files;
+	int i;
+	zend_file_handle *file_handle;
+
+	va_start(files, file_count);
+	for (i=0; i<file_count; i++) {
+		file_handle = va_arg(files, zend_file_handle *);
+		if (!file_handle) {
+			continue;
+		}
+		EG(active_op_array) = zend_compile_file(file_handle, ZEND_INCLUDE CLS_CC);
+		zend_destroy_file_handle(file_handle CLS_CC);
+		if (EG(active_op_array)) {
+			zend_execute(EG(active_op_array) ELS_CC);
+			zval_ptr_dtor(EG(return_value_ptr_ptr));
+			EG(return_value_ptr_ptr) = &EG(global_return_value_ptr);
+			EG(global_return_value_ptr) = NULL;
+			destroy_op_array(EG(active_op_array));
+			efree(EG(active_op_array));
+		} else if (type==ZEND_REQUIRE) {
+			va_end(files);
+			return FAILURE;
+		}
+	}
+	va_end(files);
+
+	return SUCCESS;
+}
+
+#define COMPILED_STRING_DESCRIPTION_FORMAT "%s(%d) : %s"
+
+ZEND_API char *zend_make_compiled_string_description(char *name)
+{
+	char *cur_filename;
+	int cur_lineno;
+	char *compiled_string_description;
+	CLS_FETCH();
+	ELS_FETCH();
+
+	if (zend_is_compiling()) {
+		cur_filename = zend_get_compiled_filename(CLS_C);
+		cur_lineno = zend_get_compiled_lineno(CLS_C);
+	} else if (zend_is_executing()) {
+		cur_filename = zend_get_executed_filename(ELS_C);
+		cur_lineno = zend_get_executed_lineno(ELS_C);
+	} else {
+		cur_filename = "Unknown";
+		cur_lineno = 0;
+	}
+
+	compiled_string_description = emalloc(sizeof(COMPILED_STRING_DESCRIPTION_FORMAT)+strlen(name)+strlen(cur_filename)+MAX_LENGTH_OF_LONG);
+	sprintf(compiled_string_description, COMPILED_STRING_DESCRIPTION_FORMAT, cur_filename, cur_lineno, name);
+	return compiled_string_description;
+}
+

Zend/zend.h

@@ -0,0 +1,459 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_H
+#define ZEND_H
+
+#define ZEND_VERSION "1.0.3"
+
+#ifdef __cplusplus
+#define BEGIN_EXTERN_C() extern "C" {
+#define END_EXTERN_C() }
+#else
+#define BEGIN_EXTERN_C()
+#define END_EXTERN_C()
+#endif
+
+#include <stdio.h>
+
+/*
+ * general definitions
+ */
+
+#ifdef ZEND_WIN32
+# include "zend_config.w32.h"
+#else
+# include "zend_config.h"
+#endif
+
+/* all HAVE_XXX test have to be after the include of zend_config above */
+
+#ifdef HAVE_UNIX_H
+# include <unix.h>
+#endif
+
+#ifdef HAVE_STDARG_H
+# include <stdarg.h>
+#endif
+
+#ifdef HAVE_DLFCN_H
+# include <dlfcn.h>
+#endif
+
+#if defined(HAVE_LIBDL)
+
+# ifndef RTLD_LAZY
+#  define RTLD_LAZY 1    /* Solaris 1, FreeBSD's (2.1.7.1 and older) */
+# endif
+
+# ifndef RTLD_GLOBAL
+#  define RTLD_GLOBAL 0
+# endif
+
+# define DL_LOAD(libname)			dlopen(libname, RTLD_LAZY | RTLD_GLOBAL)
+# define DL_UNLOAD					dlclose
+# define DL_FETCH_SYMBOL			dlsym
+# define DL_HANDLE					void *
+# define ZEND_EXTENSIONS_SUPPORT	1
+#elif defined(ZEND_WIN32)
+# define DL_LOAD(libname)			LoadLibrary(libname)
+# define DL_FETCH_SYMBOL			GetProcAddress
+# define DL_UNLOAD					FreeLibrary
+# define DL_HANDLE					HMODULE
+# define ZEND_EXTENSIONS_SUPPORT	1
+#else
+# define DL_HANDLE					void *
+# define ZEND_EXTENSIONS_SUPPORT	0
+#endif
+
+#if HAVE_ALLOCA_H
+# include <alloca.h>
+#endif
+
+#if (HAVE_ALLOCA || (defined (__GNUC__) && __GNUC__ >= 2)) && !(defined(ZTS) && defined(ZEND_WIN32))
+# define do_alloca(p) alloca(p)
+# define free_alloca(p)
+#else
+# define do_alloca(p)		emalloc(p)
+# define free_alloca(p)	efree(p)
+#endif
+
+#if ZEND_DEBUG
+#define ZEND_FILE_LINE_D				char *__zend_filename, uint __zend_lineno
+#define ZEND_FILE_LINE_DC				, ZEND_FILE_LINE_D
+#define ZEND_FILE_LINE_ORIG_D			char *__zend_orig_filename, uint __zend_orig_lineno
+#define ZEND_FILE_LINE_ORIG_DC			, ZEND_FILE_LINE_ORIG_D
+#define ZEND_FILE_LINE_RELAY_C			__zend_filename, __zend_lineno
+#define ZEND_FILE_LINE_RELAY_CC			, ZEND_FILE_LINE_RELAY_C
+#define ZEND_FILE_LINE_C				__FILE__, __LINE__
+#define ZEND_FILE_LINE_CC				, ZEND_FILE_LINE_C
+#define ZEND_FILE_LINE_EMPTY_C			NULL, 0
+#define ZEND_FILE_LINE_EMPTY_CC			, ZEND_FILE_LINE_EMPTY_C
+#define ZEND_FILE_LINE_ORIG_RELAY_C		__zend_orig_filename, __zend_orig_lineno
+#define ZEND_FILE_LINE_ORIG_RELAY_CC	, ZEND_FILE_LINE_ORIG_RELAY_C
+#else
+#define ZEND_FILE_LINE_D
+#define ZEND_FILE_LINE_DC
+#define ZEND_FILE_LINE_ORIG_D
+#define ZEND_FILE_LINE_ORIG_DC
+#define ZEND_FILE_LINE_RELAY_C
+#define ZEND_FILE_LINE_RELAY_CC
+#define ZEND_FILE_LINE_C
+#define ZEND_FILE_LINE_CC
+#define ZEND_FILE_LINE_EMPTY_C
+#define ZEND_FILE_LINE_EMPTY_CC
+#define ZEND_FILE_LINE_ORIG_RELAY_C
+#define ZEND_FILE_LINE_ORIG_RELAY_CC
+#endif	/* ZEND_DEBUG */
+
+#ifdef ZTS
+#define ZTS_V 1
+#else
+#define ZTS_V 0
+#endif
+
+#include "zend_errors.h"
+#include "zend_alloc.h"
+
+typedef unsigned char zend_bool;
+typedef unsigned char zend_uchar;
+typedef unsigned int zend_uint;
+typedef unsigned long zend_ulong;
+typedef unsigned short zend_ushort;
+
+#undef SUCCESS
+#undef FAILURE
+#define SUCCESS 0
+#define FAILURE -1				/* this MUST stay a negative number, or it may affect functions! */
+
+
+#include "zend_hash.h"
+#include "zend_llist.h"
+
+#define INTERNAL_FUNCTION_PARAMETERS int ht, zval *return_value, zval *this_ptr, int return_value_used ELS_DC
+#define INTERNAL_FUNCTION_PARAM_PASSTHRU ht, return_value, this_ptr, return_value_used ELS_CC
+
+/*
+ * zval
+ */
+typedef struct _zval_struct zval;
+typedef struct _zend_class_entry zend_class_entry;
+
+typedef union _zvalue_value {
+	long lval;					/* long value */
+	double dval;				/* double value */
+	struct {
+		char *val;
+		int len;
+	} str;
+	HashTable *ht;				/* hash table value */
+	struct {
+		zend_class_entry *ce;
+		HashTable *properties;
+	} obj;
+} zvalue_value;
+
+
+struct _zval_struct {
+	/* Variable information */
+	zvalue_value value;		/* value */
+	zend_uchar type;	/* active type */
+	zend_uchar is_ref;
+	zend_ushort refcount;
+};
+
+
+
+typedef struct _zend_function_entry {
+	char *fname;
+	void (*handler)(INTERNAL_FUNCTION_PARAMETERS);
+	unsigned char *func_arg_types;
+} zend_function_entry;
+
+
+typedef struct _zend_property_reference {
+	int type;  /* read, write or r/w */
+	zval *object;
+	zend_llist *elements_list;
+} zend_property_reference;
+
+
+
+typedef struct _zend_overloaded_element {
+	int type;		/* array offset or object proprety */
+	zval element;
+} zend_overloaded_element;
+
+/* excpt.h on Digital Unix 4.0 defines function_table */
+#undef function_table
+
+struct _zend_class_entry {
+	char type;
+	char *name;
+	uint name_length;
+	struct _zend_class_entry *parent; 
+	int *refcount;
+	zend_bool constants_updated;
+
+	HashTable function_table;
+	HashTable default_properties;
+	zend_function_entry *builtin_functions;
+
+	/* handlers */
+	void (*handle_function_call)(INTERNAL_FUNCTION_PARAMETERS, zend_property_reference *property_reference);
+	zval (*handle_property_get)(zend_property_reference *property_reference);
+	int (*handle_property_set)(zend_property_reference *property_reference, zval *value);
+};
+
+
+
+typedef struct _zend_utility_functions {
+	void (*error_function)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args);
+	int (*printf_function)(const char *format, ...);
+	int (*write_function)(const char *str, uint str_length);
+	FILE *(*fopen_function)(const char *filename, char **opened_path);
+	void (*message_handler)(long message, void *data);
+	void (*block_interruptions)(void);
+	void (*unblock_interruptions)(void);
+	int (*get_ini_entry)(char *name, uint name_length, zval *contents);
+	void (*ticks_function)(int ticks);
+} zend_utility_functions;
+
+		
+typedef struct _zend_utility_values {
+	char *import_use_extension;
+	uint import_use_extension_length;
+} zend_utility_values;
+
+
+typedef int (*zend_write_func_t)(const char *str, uint str_length);
+
+
+#undef MIN
+#undef MAX
+#define MAX(a,b)  (((a)>(b))?(a):(b))
+#define MIN(a,b)  (((a)<(b))?(a):(b))
+#define ZEND_STRL(str)		(str), (sizeof(str)-1)
+#define ZEND_STRS(str)		(str), (sizeof(str)
+#define ZEND_NORMALIZE_BOOL(n)			\
+	((n) ? (((n)>0) ? 1 : -1) : 0)
+
+
+/* data types */
+#define IS_NULL		0
+#define IS_LONG		1
+#define IS_DOUBLE	2
+#define IS_STRING	3
+#define IS_ARRAY	4
+#define IS_OBJECT	5
+#define IS_BOOL		6
+#define IS_RESOURCE	7
+#define IS_CONSTANT	8
+#define IS_CONSTANT_ARRAY	9
+
+/* Special data type to temporarily mark large numbers */
+#define FLAG_IS_BC	10 /* for parser internal use only */
+
+/* overloaded elements data types */
+#define OE_IS_ARRAY	(1<<0)
+#define OE_IS_OBJECT	(1<<1)
+#define OE_IS_METHOD	(1<<2)
+
+
+/* Argument passing types */
+#define BYREF_NONE 0
+#define BYREF_FORCE 1
+#define BYREF_ALLOW 2
+#define BYREF_FORCE_REST 3
+
+int zend_startup(zend_utility_functions *utility_functions, char **extensions, int start_builtin_functions);
+void zend_shutdown(void);
+
+void zend_set_utility_values(zend_utility_values *utility_values);
+BEGIN_EXTERN_C()
+ZEND_API void zend_bailout(void);
+END_EXTERN_C()
+ZEND_API char *get_zend_version(void);
+
+ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_copy);
+ZEND_API int zend_print_zval(zval *expr, int indent);
+ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent);
+ZEND_API void zend_print_zval_r(zval *expr, int indent);
+ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int indent);
+
+ZEND_API void zend_output_debug_string(zend_bool trigger_break, char *format, ...);
+#if ZEND_DEBUG
+#define Z_DBG(expr)		(expr)
+#else
+#define	Z_DBG(expr)
+#endif
+
+ZEND_API extern char *empty_string;
+
+#define STR_FREE(ptr) if (ptr && ptr!=empty_string) { efree(ptr); }
+#define STR_FREE_REL(ptr) if (ptr && ptr!=empty_string) { efree_rel(ptr); }
+
+#define STR_REALLOC(ptr, size)										\
+	if (ptr!=empty_string) {										\
+		ptr = (char *) erealloc(ptr, size);							\
+	} else {														\
+		ptr = (char *) emalloc(size);								\
+		memset(ptr, 0, size);										\
+	}
+
+/* output support */
+#define ZEND_WRITE(str, str_len)		zend_write((str), (str_len))
+#define ZEND_PUTS(str)					zend_write((str), strlen((str)))
+#define ZEND_PUTC(c)					zend_write(&(c), 1), (c)
+
+
+BEGIN_EXTERN_C()
+extern ZEND_API int (*zend_printf)(const char *format, ...);
+extern ZEND_API zend_write_func_t zend_write;
+extern ZEND_API FILE *(*zend_fopen)(const char *filename, char **opened_path);
+extern ZEND_API void (*zend_block_interruptions)(void);
+extern ZEND_API void (*zend_unblock_interruptions)(void);
+extern ZEND_API void (*zend_ticks_function)(int ticks);
+extern ZEND_API void (*zend_error_cb)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args);
+
+
+ZEND_API void zend_error(int type, const char *format, ...);
+
+void zenderror(char *error);
+
+extern ZEND_API zend_class_entry zend_standard_class_def;
+extern zend_utility_values zend_uv;
+extern ZEND_API zval zval_used_for_init;
+
+END_EXTERN_C()
+
+#define ZEND_UV(name) (zend_uv.name)
+
+
+#define HANDLE_BLOCK_INTERRUPTIONS()		if (zend_block_interruptions) { zend_block_interruptions(); }
+#define HANDLE_UNBLOCK_INTERRUPTIONS()		if (zend_unblock_interruptions) { zend_unblock_interruptions(); }
+
+BEGIN_EXTERN_C()
+ZEND_API void zend_message_dispatcher(long message, void *data);
+END_EXTERN_C()
+
+ZEND_API int zend_get_ini_entry(char *name, uint name_length, zval *contents);
+
+
+/* Messages for applications of Zend */
+#define ZMSG_FAILED_INCLUDE_FOPEN		1L
+#define ZMSG_FAILED_REQUIRE_FOPEN		2L
+#define ZMSG_FAILED_HIGHLIGHT_FOPEN		3L
+#define ZMSG_MEMORY_LEAK_DETECTED		4L
+#define ZMSG_MEMORY_LEAK_REPEATED		5L
+#define ZMSG_LOG_SCRIPT_NAME			6L
+
+
+#define ZVAL_ADDREF(pz)		(++(pz)->refcount)
+#define ZVAL_DELREF(pz)		(--(pz)->refcount)
+#define ZVAL_REFCOUNT(pz)	((pz)->refcount)
+
+#define INIT_PZVAL(z)		\
+	(z)->refcount = 1;		\
+	(z)->is_ref = 0;	
+
+#define INIT_ZVAL(z) z = zval_used_for_init;
+
+#define ALLOC_INIT_ZVAL(zp)						\
+	ALLOC_ZVAL(zp);		\
+	INIT_ZVAL(*zp);
+
+#define MAKE_STD_ZVAL(zv)				 \
+	ALLOC_ZVAL(zv); \
+	INIT_PZVAL(zv);
+
+#define PZVAL_IS_REF(z)		((z)->is_ref)
+
+#define SEPARATE_ZVAL(ppzv)									\
+	{														\
+		zval *orig_ptr = *(ppzv);							\
+															\
+		if (orig_ptr->refcount>1) {							\
+			orig_ptr->refcount--;							\
+			ALLOC_ZVAL(*(ppzv));							\
+			**(ppzv) = *orig_ptr;							\
+			zval_copy_ctor(*(ppzv));						\
+			(*(ppzv))->refcount=1;							\
+			(*(ppzv))->is_ref = 0;							\
+		}													\
+	}
+
+#define SEPARATE_ZVAL_IF_NOT_REF(ppzv)		\
+	if (!PZVAL_IS_REF(*ppzv)) {				\
+		SEPARATE_ZVAL(ppzv);				\
+	}
+
+#define SEPARATE_ZVAL_TO_MAKE_IS_REF(ppzv)	\
+	if (!PZVAL_IS_REF(*ppzv)) {				\
+		SEPARATE_ZVAL(ppzv);				\
+		(*(ppzv))->is_ref = 1;				\
+	}
+
+#define COPY_PZVAL_TO_ZVAL(zv, pzv)			\
+	(zv) = *(pzv);							\
+	if ((pzv)->refcount>1) {				\
+		zval_copy_ctor(&(zv));				\
+		(pzv)->refcount--;					\
+	} else {								\
+		FREE_ZVAL(pzv);						\
+	}										\
+	INIT_PZVAL(&(zv));
+
+#define REPLACE_ZVAL_VALUE(ppzv_dest,pzv_src,copy) {	\
+	int is_ref,refcount;						\
+												\
+	SEPARATE_ZVAL_IF_NOT_REF(ppzv_dest);		\
+	is_ref = (*ppzv_dest)->is_ref;				\
+	refcount = (*ppzv_dest)->refcount;			\
+	zval_dtor(*ppzv_dest);						\
+	**ppzv_dest = *pzv_src;						\
+	if(copy) {                                  \
+		zval_copy_ctor(*ppzv_dest);				\
+    }		                                    \
+	(*ppzv_dest)->is_ref = is_ref;				\
+	(*ppzv_dest)->refcount = refcount;			\
+}
+
+#define ZEND_MAX_RESERVED_RESOURCES	2
+
+#ifdef ZEND_WIN32
+/* Only use this macro if you know for sure that all of the switches values
+   are covered by its case statements */
+#define EMPTY_SWITCH_DEFAULT_CASE() \
+			default:				\
+				__assume(0);		\
+				break;
+#else
+#define EMPTY_SWITCH_DEFAULT_CASE()
+#endif
+
+#endif /* ZEND_H */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */

Zend/zend_API.c

@@ -0,0 +1,984 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#include "zend.h"
+#include "zend_execute.h"
+#include "zend_API.h"
+#include "modules.h"
+#include "zend_constants.h"
+
+#ifdef HAVE_STDARG_H
+#include <stdarg.h>
+#endif
+
+/* these variables are true statics/globals, and have to be mutex'ed on every access */
+static int module_count=0;
+ZEND_API HashTable module_registry;
+
+/* this function doesn't check for too many parameters */
+ZEND_API int zend_get_parameters(int ht, int param_count, ...)
+{
+	void **p;
+	int arg_count;
+	va_list ptr;
+	zval **param, *param_ptr;
+	ELS_FETCH();
+
+	p = EG(argument_stack).top_element-2;
+	arg_count = (ulong) *p;
+
+	if (param_count>arg_count) {
+		return FAILURE;
+	}
+
+	va_start(ptr, param_count);
+
+	while (param_count-->0) {
+		param = va_arg(ptr, zval **);
+		param_ptr = *(p-arg_count);
+		if (!PZVAL_IS_REF(param_ptr) && param_ptr->refcount>1) {
+			zval *new_tmp;
+
+			ALLOC_ZVAL(new_tmp);
+			*new_tmp = *param_ptr;
+			zval_copy_ctor(new_tmp);
+			INIT_PZVAL(new_tmp);
+			param_ptr = new_tmp;
+			((zval *) *(p-arg_count))->refcount--;
+			*(p-arg_count) = param_ptr;
+		}
+		*param = param_ptr;
+		arg_count--;
+	}
+	va_end(ptr);
+
+	return SUCCESS;
+}
+
+
+ZEND_API int zend_get_parameters_array(int ht, int param_count, zval **argument_array)
+{
+	void **p;
+	int arg_count;
+	zval *param_ptr;
+	ELS_FETCH();
+
+	p = EG(argument_stack).top_element-2;
+	arg_count = (ulong) *p;
+
+	if (param_count>arg_count) {
+		return FAILURE;
+	}
+
+	while (param_count-->0) {
+		param_ptr = *(p-arg_count);
+		if (!PZVAL_IS_REF(param_ptr) && param_ptr->refcount>1) {
+			zval *new_tmp;
+
+			ALLOC_ZVAL(new_tmp);
+			*new_tmp = *param_ptr;
+			zval_copy_ctor(new_tmp);
+			INIT_PZVAL(new_tmp);
+			param_ptr = new_tmp;
+			((zval *) *(p-arg_count))->refcount--;
+			*(p-arg_count) = param_ptr;
+		}
+		*(argument_array++) = param_ptr;
+		arg_count--;
+	}
+
+	return SUCCESS;
+}
+
+
+
+
+/* Zend-optimized Extended functions */
+/* this function doesn't check for too many parameters */
+ZEND_API int zend_get_parameters_ex(int param_count, ...)
+{
+	void **p;
+	int arg_count;
+	va_list ptr;
+	zval ***param;
+	ELS_FETCH();
+
+	p = EG(argument_stack).top_element-2;
+	arg_count = (ulong) *p;
+
+	if (param_count>arg_count) {
+		return FAILURE;
+	}
+
+	va_start(ptr, param_count);
+	while (param_count-->0) {
+		param = va_arg(ptr, zval ***);
+		*param = (zval **) p-(arg_count--);
+	}
+	va_end(ptr);
+
+	return SUCCESS;
+}
+
+
+ZEND_API int zend_get_parameters_array_ex(int param_count, zval ***argument_array)
+{
+	void **p;
+	int arg_count;
+	ELS_FETCH();
+
+	p = EG(argument_stack).top_element-2;
+	arg_count = (ulong) *p;
+
+	if (param_count>arg_count) {
+		return FAILURE;
+	}
+
+	while (param_count-->0) {
+		*(argument_array++) = (zval **) p-(arg_count--);
+	}
+
+	return SUCCESS;
+}
+
+
+ZEND_API int ParameterPassedByReference(int ht, uint n)
+{
+	void **p;
+	ulong arg_count;
+	zval *arg;
+	ELS_FETCH();
+
+	p = EG(argument_stack).elements+EG(argument_stack).top-2;
+	arg_count = (ulong) *p;
+
+	if (n>arg_count) {
+		return FAILURE;
+	}
+	arg = (zval *) *(p-arg_count+n-1);
+	return PZVAL_IS_REF(arg);
+}
+
+
+ZEND_API void wrong_param_count()
+{
+	zend_error(E_WARNING,"Wrong parameter count for %s()",get_active_function_name());
+}
+
+	
+ZEND_API inline int _array_init(zval *arg ZEND_FILE_LINE_DC)
+{
+	ALLOC_HASHTABLE_REL(arg->value.ht);
+
+	if (!arg->value.ht || zend_hash_init(arg->value.ht, 0, NULL, ZVAL_PTR_DTOR, 0)) {
+		zend_error(E_ERROR, "Cannot allocate memory for array");
+		return FAILURE;
+	}
+	arg->type = IS_ARRAY;
+	return SUCCESS;
+}
+
+
+ZEND_API inline int _object_init_ex(zval *arg, zend_class_entry *class_type ZEND_FILE_LINE_DC)
+{
+	zval *tmp;
+
+	if (!class_type->constants_updated) {
+		zend_hash_apply_with_argument(&class_type->default_properties, (int (*)(void *,void *)) zval_update_constant, (void *) 1);
+		class_type->constants_updated = 1;
+	}
+	
+	ALLOC_HASHTABLE_REL(arg->value.obj.properties);
+	zend_hash_init(arg->value.obj.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
+	zend_hash_copy(arg->value.obj.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
+	arg->type = IS_OBJECT;
+	arg->value.obj.ce = class_type;
+	return SUCCESS;
+}
+
+
+ZEND_API inline int _object_init(zval *arg ZEND_FILE_LINE_DC)
+{
+	return _object_init_ex(arg, &zend_standard_class_def ZEND_FILE_LINE_CC);
+}
+
+
+ZEND_API inline int add_assoc_function(zval *arg, char *key,void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS))
+{
+	zend_error(E_WARNING, "add_assoc_function() is no longer supported");
+	return FAILURE;
+}
+
+
+ZEND_API inline int add_assoc_long(zval *arg, char *key, long n)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_LONG;
+	tmp->value.lval = n;
+	INIT_PZVAL(tmp);
+	return zend_hash_update(arg->value.ht, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API inline int add_assoc_unset(zval *arg, char *key)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_NULL;
+	INIT_PZVAL(tmp);
+	return zend_hash_update(arg->value.ht, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+ZEND_API inline int add_assoc_bool(zval *arg, char *key, int b)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_BOOL;
+	tmp->value.lval = b;
+	INIT_PZVAL(tmp);
+	return zend_hash_update(arg->value.ht, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API inline int add_assoc_resource(zval *arg, char *key, int r)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_RESOURCE;
+	tmp->value.lval = r;
+	INIT_PZVAL(tmp);
+	return zend_hash_update(arg->value.ht, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API inline int add_assoc_double(zval *arg, char *key, double d)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_DOUBLE;
+	tmp->value.dval = d;
+	INIT_PZVAL(tmp);
+	return zend_hash_update(arg->value.ht, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API inline int add_assoc_string(zval *arg, char *key, char *str, int duplicate)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_STRING;
+	tmp->value.str.len = strlen(str);
+	if (duplicate) {
+		tmp->value.str.val = estrndup(str,tmp->value.str.len);
+	} else {
+		tmp->value.str.val = str;
+	}
+	INIT_PZVAL(tmp);
+	return zend_hash_update(arg->value.ht, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API inline int add_assoc_stringl(zval *arg, char *key, char *str, uint length, int duplicate)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_STRING;
+	tmp->value.str.len = length;
+	if (duplicate) {
+		tmp->value.str.val = estrndup(str,tmp->value.str.len);
+	} else {
+		tmp->value.str.val = str;
+	}
+	INIT_PZVAL(tmp);
+	return zend_hash_update(arg->value.ht, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API inline int add_index_long(zval *arg, uint index, long n)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_LONG;
+	tmp->value.lval = n;
+	INIT_PZVAL(tmp);
+	return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *),NULL);
+}
+
+
+ZEND_API inline int add_index_unset(zval *arg, uint index)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_NULL;
+	INIT_PZVAL(tmp);
+	return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API inline int add_index_bool(zval *arg, uint index, int b)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_BOOL;
+	tmp->value.lval = b;
+	INIT_PZVAL(tmp);
+	return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *),NULL);
+}
+
+
+ZEND_API inline int add_index_resource(zval *arg, uint index, int r)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_RESOURCE;
+	tmp->value.lval = r;
+	INIT_PZVAL(tmp);
+	return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *),NULL);
+}
+
+
+ZEND_API inline int add_index_double(zval *arg, uint index, double d)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_DOUBLE;
+	tmp->value.dval = d;
+	INIT_PZVAL(tmp);
+	return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *),NULL);
+}
+
+
+ZEND_API inline int add_index_string(zval *arg, uint index, char *str, int duplicate)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_STRING;
+	tmp->value.str.len = strlen(str);
+	if (duplicate) {
+		tmp->value.str.val = estrndup(str,tmp->value.str.len);
+	} else {
+		tmp->value.str.val = str;
+	}
+	INIT_PZVAL(tmp);
+	return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API inline int add_index_stringl(zval *arg, uint index, char *str, uint length, int duplicate)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_STRING;
+	tmp->value.str.len = length;
+	if (duplicate) {
+		tmp->value.str.val = estrndup(str,tmp->value.str.len);
+	} else {
+		tmp->value.str.val = str;
+	}
+	INIT_PZVAL(tmp);
+	return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *),NULL);
+}
+
+
+ZEND_API inline int add_next_index_long(zval *arg, long n)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_LONG;
+	tmp->value.lval = n;
+	INIT_PZVAL(tmp);
+	return zend_hash_next_index_insert(arg->value.ht, &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API inline int add_next_index_unset(zval *arg)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_NULL;
+	INIT_PZVAL(tmp);
+	return zend_hash_next_index_insert(arg->value.ht, &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API inline int add_next_index_bool(zval *arg, int b)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_BOOL;
+	tmp->value.lval = b;
+	INIT_PZVAL(tmp);
+	return zend_hash_next_index_insert(arg->value.ht, &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API inline int add_next_index_resource(zval *arg, int r)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_RESOURCE;
+	tmp->value.lval = r;
+	INIT_PZVAL(tmp);
+	return zend_hash_next_index_insert(arg->value.ht, &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API inline int add_next_index_double(zval *arg, double d)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_DOUBLE;
+	tmp->value.dval = d;
+	INIT_PZVAL(tmp);
+	return zend_hash_next_index_insert(arg->value.ht, &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API inline int add_next_index_string(zval *arg, char *str, int duplicate)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_STRING;
+	tmp->value.str.len = strlen(str);
+	if (duplicate) {
+		tmp->value.str.val = estrndup(str,tmp->value.str.len);
+	} else {
+		tmp->value.str.val = str;
+	}
+	INIT_PZVAL(tmp);
+	return zend_hash_next_index_insert(arg->value.ht, &tmp, sizeof(zval *),NULL);
+}
+
+
+ZEND_API inline int add_next_index_stringl(zval *arg, char *str, uint length, int duplicate)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_STRING;
+	tmp->value.str.len = length;
+	if (duplicate) {
+		tmp->value.str.val = estrndup(str,tmp->value.str.len);
+	} else {
+		tmp->value.str.val = str;
+	}
+	INIT_PZVAL(tmp);
+	return zend_hash_next_index_insert(arg->value.ht, &tmp, sizeof(zval *),NULL);
+}
+
+
+ZEND_API inline int add_get_assoc_string(zval *arg, char *key, char *str, void **dest, int duplicate)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_STRING;
+	tmp->value.str.len = strlen(str);
+	if (duplicate) {
+		tmp->value.str.val = estrndup(str,tmp->value.str.len);
+	} else {
+		tmp->value.str.val = str;
+	}
+	INIT_PZVAL(tmp);
+	return zend_hash_update(arg->value.ht, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), dest);
+}
+
+
+ZEND_API inline int add_get_assoc_stringl(zval *arg, char *key, char *str, uint length, void **dest, int duplicate)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_STRING;
+	tmp->value.str.len = length;
+	if (duplicate) {
+		tmp->value.str.val = estrndup(str,tmp->value.str.len);
+	} else {
+		tmp->value.str.val = str;
+	}
+	INIT_PZVAL(tmp);
+	return zend_hash_update(arg->value.ht, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), dest);
+}
+
+
+ZEND_API inline int add_get_index_long(zval *arg, uint index, long l, void **dest)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_LONG;
+	tmp->value.lval = l;
+	INIT_PZVAL(tmp);
+	return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *),dest);
+}
+
+
+ZEND_API inline int add_get_index_double(zval *arg, uint index, double d, void **dest)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_DOUBLE;
+	tmp->value.dval= d;
+	INIT_PZVAL(tmp);
+	return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *),dest);
+}
+
+
+ZEND_API inline int add_get_index_string(zval *arg, uint index, char *str, void **dest, int duplicate)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_STRING;
+	tmp->value.str.len = strlen(str);
+	if (duplicate) {
+		tmp->value.str.val = estrndup(str,tmp->value.str.len);
+	} else {
+		tmp->value.str.val = str;
+	}
+	INIT_PZVAL(tmp);
+	return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *),dest);
+}
+
+
+ZEND_API inline int add_get_index_stringl(zval *arg, uint index, char *str, uint length, void **dest, int duplicate)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_STRING;
+	tmp->value.str.len = length;
+	if (duplicate) {
+		tmp->value.str.val = estrndup(str,tmp->value.str.len);
+	} else {
+		tmp->value.str.val = str;
+	}
+	INIT_PZVAL(tmp);
+	return zend_hash_index_update(arg->value.ht, index, (void *) &tmp, sizeof(zval *),dest);
+}
+
+
+ZEND_API inline int add_property_long(zval *arg, char *key, long n)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_LONG;
+	tmp->value.lval = n;
+	INIT_PZVAL(tmp);
+	return zend_hash_update(arg->value.obj.properties, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+ZEND_API inline int add_property_bool(zval *arg, char *key, int b)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_BOOL;
+	tmp->value.lval = b;
+	INIT_PZVAL(tmp);
+	return zend_hash_update(arg->value.obj.properties, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+ZEND_API inline int add_property_unset(zval *arg, char *key)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_NULL;
+	INIT_PZVAL(tmp);
+	return zend_hash_update(arg->value.obj.properties, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+ZEND_API inline int add_property_resource(zval *arg, char *key, long n)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_RESOURCE;
+	tmp->value.lval = n;
+	INIT_PZVAL(tmp);
+	return zend_hash_update(arg->value.obj.properties, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API inline int add_property_double(zval *arg, char *key, double d)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_DOUBLE;
+	tmp->value.dval = d;
+	INIT_PZVAL(tmp);
+	return zend_hash_update(arg->value.obj.properties, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API inline int add_property_string(zval *arg, char *key, char *str, int duplicate)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_STRING;
+	tmp->value.str.len = strlen(str);
+	if (duplicate) {
+		tmp->value.str.val = estrndup(str,tmp->value.str.len);
+	} else {
+		tmp->value.str.val = str;
+	}
+	INIT_PZVAL(tmp);
+	return zend_hash_update(arg->value.obj.properties, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API inline int add_property_stringl(zval *arg, char *key, char *str, uint length, int duplicate)
+{
+	zval *tmp;
+
+	ALLOC_ZVAL(tmp);
+	tmp->type = IS_STRING;
+	tmp->value.str.len = length;
+	if (duplicate) {
+		tmp->value.str.val = estrndup(str,tmp->value.str.len);
+	} else {
+		tmp->value.str.val = str;
+	}
+	INIT_PZVAL(tmp);
+	return zend_hash_update(arg->value.obj.properties, key, strlen(key)+1, (void *) &tmp, sizeof(zval *), NULL);
+}
+
+
+ZEND_API int zend_startup_module(zend_module_entry *module)
+{
+	if (module) {
+		module->module_number = zend_next_free_module();
+		if (module->module_startup_func) {
+			ELS_FETCH();
+
+			if (module->module_startup_func(MODULE_PERSISTENT, module->module_number ELS_CC)==FAILURE) {
+				zend_error(E_CORE_ERROR,"Unable to start %s module",module->name);
+				return FAILURE;
+			}
+		}
+		module->type = MODULE_PERSISTENT;
+		zend_register_module(module);
+	}
+	return SUCCESS;
+}
+
+
+/* registers all functions in *library_functions in the function hash */
+int zend_register_functions(zend_function_entry *functions, HashTable *function_table, int type)
+{
+	zend_function_entry *ptr = functions;
+	zend_function function;
+	zend_internal_function *internal_function = (zend_internal_function *)&function;
+	int count=0,unload=0;
+	HashTable *target_function_table = function_table;
+	int error_type;
+	CLS_FETCH();
+
+	if (type==MODULE_PERSISTENT) {
+		error_type = E_CORE_WARNING;
+	} else {
+		error_type = E_WARNING;
+	}
+
+	if (!target_function_table) {
+		target_function_table = CG(function_table);
+	}
+	internal_function->type = ZEND_INTERNAL_FUNCTION;
+	
+	while (ptr->fname) {
+		internal_function->handler = ptr->handler;
+		internal_function->arg_types = ptr->func_arg_types;
+		internal_function->function_name = ptr->fname;
+		if (!internal_function->handler) {
+			zend_error(error_type, "Null function defined as active function");
+			zend_unregister_functions(functions, count, target_function_table);
+			return FAILURE;
+		}
+		if (zend_hash_add(target_function_table, ptr->fname, strlen(ptr->fname)+1, &function, sizeof(zend_function), NULL) == FAILURE) {
+			unload=1;
+			break;
+		}
+		ptr++;
+		count++;
+	}
+	if (unload) { /* before unloading, display all remaining bad function in the module */
+		while (ptr->fname) {
+			if (zend_hash_exists(target_function_table, ptr->fname, strlen(ptr->fname)+1)) {
+				zend_error(error_type, "Function registration failed - duplicate name - %s",ptr->fname);
+			}
+			ptr++;
+		}
+		zend_unregister_functions(functions, count, target_function_table);
+		return FAILURE;
+	}
+	return SUCCESS;
+}
+
+/* count=-1 means erase all functions, otherwise, 
+ * erase the first count functions
+ */
+void zend_unregister_functions(zend_function_entry *functions, int count, HashTable *function_table)
+{
+	zend_function_entry *ptr = functions;
+	int i=0;
+	HashTable *target_function_table = function_table;
+	CLS_FETCH();
+
+	if (!target_function_table) {
+		target_function_table = CG(function_table);
+	}
+	while (ptr->fname) {
+		if (count!=-1 && i>=count) {
+			break;
+		}
+#if 0
+		zend_printf("Unregistering %s()\n", ptr->fname);
+#endif
+		zend_hash_del(target_function_table, ptr->fname, strlen(ptr->fname)+1);
+		ptr++;
+		i++;
+	}
+}
+
+
+ZEND_API int zend_register_module(zend_module_entry *module)
+{
+#if 0
+	zend_printf("%s:  Registering module %d\n",module->name, module->module_number);
+#endif
+	if (module->functions && zend_register_functions(module->functions, NULL, module->type)==FAILURE) {
+		zend_error(E_CORE_WARNING,"%s:  Unable to register functions, unable to load",module->name);
+		return FAILURE;
+	}
+	module->module_started=1;
+	return zend_hash_add(&module_registry, module->name,strlen(module->name)+1,(void *)module,sizeof(zend_module_entry),NULL);
+}
+
+
+void module_destructor(zend_module_entry *module)
+{
+	if (module->type == MODULE_TEMPORARY) {
+		zend_clean_module_rsrc_dtors(module->module_number);
+		clean_module_constants(module->module_number);
+		if (module->request_shutdown_func)
+			module->request_shutdown_func(module->type, module->module_number);
+	}
+
+	if (module->module_started && module->module_shutdown_func) {
+#if 0
+		zend_printf("%s:  Module shutdown\n",module->name);
+#endif
+		module->module_shutdown_func(module->type, module->module_number);
+	}
+	module->module_started=0;
+	if (module->functions) {
+		zend_unregister_functions(module->functions, -1, NULL);
+	}
+
+#if HAVE_LIBDL
+	if (module->handle) {
+		dlclose(module->handle);
+	}
+#endif
+}
+
+
+/* call request startup for all modules */
+int module_registry_request_startup(zend_module_entry *module)
+{
+	if (module->request_startup_func) {
+		ELS_FETCH();
+
+#if 0
+		zend_printf("%s:  Request startup\n",module->name);
+#endif
+		if (module->request_startup_func(module->type, module->module_number ELS_CC)==FAILURE) {
+			zend_error(E_WARNING, "request_startup() for %s module failed", module->name);
+			exit(1);
+		}
+	}
+	return 0;
+}
+
+
+/* for persistent modules - call request shutdown and flag NOT to erase
+ * for temporary modules - do nothing, and flag to erase
+ */
+int module_registry_cleanup(zend_module_entry *module)
+{
+	switch(module->type) {
+		case MODULE_PERSISTENT:
+			if (module->request_shutdown_func) {
+#if 0
+				zend_printf("%s:  Request shutdown\n",module->name);
+#endif
+				module->request_shutdown_func(module->type, module->module_number);
+			}
+			return 0;
+			break;
+		case MODULE_TEMPORARY:
+			return 1;
+			break;
+	}
+	return 0;
+}
+
+
+/* return the next free module number */
+int zend_next_free_module(void)
+{
+	return ++module_count;
+}
+
+/* If parent_ce is not NULL then it inherits from parent_ce
+ * If parent_ce is NULL and parent_name isn't then it looks for the parent and inherits from it
+ * If both parent_ce and parent_name are NULL it does a regular class registration
+ * If parent_name is specified but not found NULL is returned
+ */
+ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce, char *parent_name)
+{
+	zend_class_entry *register_class;
+	CLS_FETCH();
+
+	if (!parent_ce && parent_name) {
+			if (zend_hash_find(CG(class_table), parent_name, strlen(parent_name)+1, (void **) &parent_ce)==FAILURE) {
+				return NULL;
+			}
+	}
+
+	register_class = zend_register_internal_class(class_entry);
+
+	if (parent_ce) {
+		zend_do_inheritance(register_class, parent_ce);
+	}
+	return register_class;
+}
+
+ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *class_entry)
+{
+	zend_class_entry *register_class;
+	char *lowercase_name = zend_strndup(class_entry->name, class_entry->name_length);
+	CLS_FETCH();
+
+	zend_str_tolower(lowercase_name, class_entry->name_length);
+
+	class_entry->type = ZEND_INTERNAL_CLASS;
+	class_entry->parent = NULL;
+	class_entry->refcount = (int *) malloc(sizeof(int));
+	*class_entry->refcount = 1;
+	class_entry->constants_updated = 0;
+	zend_hash_init(&class_entry->default_properties, 0, NULL, ZVAL_PTR_DTOR, 1);
+	zend_hash_init(&class_entry->function_table, 0, NULL, ZEND_FUNCTION_DTOR, 1);
+
+
+	if (class_entry->builtin_functions) {
+		zend_register_functions(class_entry->builtin_functions, &class_entry->function_table, MODULE_PERSISTENT);
+	}
+
+	zend_hash_update(CG(class_table), lowercase_name, class_entry->name_length+1, class_entry, sizeof(zend_class_entry), (void **) &register_class);
+	free(lowercase_name);
+	return register_class;
+}
+
+
+ZEND_API zend_module_entry *zend_get_module(int module_number)
+{
+	zend_module_entry *module;
+
+	if (zend_hash_index_find(&module_registry, module_number, (void **) &module)==SUCCESS) {
+		return module;
+	} else {
+		return NULL;
+	}
+}
+
+ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
+                                  int is_ref, int num_symbol_tables, ...)
+{
+    HashTable  *symbol_table;
+    va_list     symbol_table_list;
+
+    if (num_symbol_tables <= 0) return FAILURE;
+
+    symbol->is_ref = is_ref;
+
+    va_start(symbol_table_list, num_symbol_tables);
+    while(num_symbol_tables-- > 0) {
+        symbol_table = va_arg(symbol_table_list, HashTable *);
+        zend_hash_update(symbol_table, name, name_length + 1, &symbol, sizeof(zval *), NULL);
+        zval_add_ref(&symbol);
+    }
+    va_end(symbol_table_list);
+    return SUCCESS;
+}
+
+
+
+
+/* Disabled functions support */
+
+static ZEND_FUNCTION(display_disabled_function)
+{
+	zend_error(E_WARNING, "%s() has been disabled for security reasons.", get_active_function_name());
+}
+
+
+static zend_function_entry disabled_function[] =  {
+	ZEND_FE(display_disabled_function,			NULL)
+	{ NULL, NULL, NULL }
+};
+
+
+ZEND_API int zend_disable_function(char *function_name, uint function_name_length)
+{
+	CLS_FETCH();
+
+	if (zend_hash_del(CG(function_table), function_name, function_name_length+1)==FAILURE) {
+		return FAILURE;
+	}
+	disabled_function[0].fname = function_name;
+	return zend_register_functions(disabled_function, CG(function_table), MODULE_PERSISTENT);
+}

Zend/zend_API.h

@@ -0,0 +1,426 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_API_H
+#define ZEND_API_H
+
+#include "modules.h"
+#include "zend_list.h"
+#include "zend_fast_cache.h"
+#include "zend_operators.h"
+#include "zend_variables.h"
+#include "zend_execute.h"
+
+#define ZEND_FN(name) zend_if_##name
+#define ZEND_NAMED_FUNCTION(name) void name(INTERNAL_FUNCTION_PARAMETERS)
+#define ZEND_FUNCTION(name) ZEND_NAMED_FUNCTION(ZEND_FN(name))
+
+#define ZEND_NAMED_FE(zend_name, name, arg_types) { #zend_name, name, arg_types },
+#define ZEND_FE(name, arg_types) ZEND_NAMED_FE(name, ZEND_FN(name), arg_types)
+#define ZEND_FALIAS(name, alias, arg_types) ZEND_NAMED_FE(name, ZEND_FN(alias), arg_types)
+
+#define ZEND_MINIT(module)       zend_minit_##module
+#define ZEND_MSHUTDOWN(module)   zend_mshutdown_##module
+#define ZEND_RINIT(module)       zend_rinit_##module
+#define ZEND_RSHUTDOWN(module)   zend_rshutdown_##module
+#define ZEND_MINFO(module)       zend_info_##module
+#define ZEND_GINIT(module)       zend_ginit_##module
+#define ZEND_GSHUTDOWN(module)   zend_gshutdown_##module
+
+#define ZEND_MINIT_FUNCTION(module)      int ZEND_MINIT(module)(INIT_FUNC_ARGS)
+#define ZEND_MSHUTDOWN_FUNCTION(module)  int ZEND_MSHUTDOWN(module)(SHUTDOWN_FUNC_ARGS)
+#define ZEND_RINIT_FUNCTION(module)      int ZEND_RINIT(module)(INIT_FUNC_ARGS)
+#define ZEND_RSHUTDOWN_FUNCTION(module)  int ZEND_RSHUTDOWN(module)(SHUTDOWN_FUNC_ARGS)
+#define ZEND_MINFO_FUNCTION(module)      void ZEND_MINFO(module)(ZEND_MODULE_INFO_FUNC_ARGS)
+#define ZEND_GINIT_FUNCTION(module)      int ZEND_GINIT(module)(GINIT_FUNC_ARGS)
+#define ZEND_GSHUTDOWN_FUNCTION(module)  int ZEND_GSHUTDOWN(module)(void)
+
+#define ZEND_GET_MODULE(name) \
+	ZEND_DLEXPORT zend_module_entry *get_module(void) { return &name##_module_entry; }
+
+#define ZEND_BEGIN_MODULE_GLOBALS(module_name)		\
+	typedef struct _zend_##module_name##_globals {
+#define ZEND_END_MODULE_GLOBALS(module_name)		\
+	} zend_##module_name##_globals;
+
+#ifdef ZTS
+
+#define ZEND_DECLARE_MODULE_GLOBALS(module_name)							\
+	static ts_rsrc_id module_name##_globals_id;
+#define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor)	\
+	module_name##_globals_id = ts_allocate_id(sizeof(zend_##module_name##_globals), (ts_allocate_ctor) globals_ctor, (ts_allocate_dtor) globals_dtor);
+
+#else
+
+#define ZEND_DECLARE_MODULE_GLOBALS(module_name)							\
+	static zend_##module_name##_globals module_name##_globals;
+#define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor)	\
+	globals_ctor(&module_name##_globals);
+
+#endif
+
+
+
+#define INIT_CLASS_ENTRY(class_container, class_name, functions)	\
+	{																\
+		class_container.name = strdup(class_name);					\
+		class_container.name_length = sizeof(class_name)-1;			\
+		class_container.builtin_functions = functions;				\
+		class_container.handle_function_call = NULL;				\
+		class_container.handle_property_get = NULL;					\
+		class_container.handle_property_set = NULL;					\
+	}
+
+#define INIT_OVERLOADED_CLASS_ENTRY(class_container, class_name, functions, handle_fcall, handle_propget, handle_propset) \
+	{															\
+		class_container.name = strdup(class_name);				\
+		class_container.name_length = sizeof(class_name)-1;		\
+		class_container.builtin_functions = functions;			\
+		class_container.handle_function_call = handle_fcall;	\
+		class_container.handle_property_get = handle_propget;	\
+		class_container.handle_property_set = handle_propset;	\
+	}
+
+
+
+int zend_next_free_module(void);
+
+ZEND_API int zend_get_parameters(int ht, int param_count, ...);
+ZEND_API int zend_get_parameters_array(int ht, int param_count, zval **argument_array);
+ZEND_API int zend_get_parameters_ex(int param_count, ...);
+ZEND_API int zend_get_parameters_array_ex(int param_count, zval ***argument_array);
+
+ZEND_API int ParameterPassedByReference(int ht, uint n);
+
+int zend_register_functions(zend_function_entry *functions, HashTable *function_table, int type);
+void zend_unregister_functions(zend_function_entry *functions, int count, HashTable *function_table);
+ZEND_API int zend_register_module(zend_module_entry *module_entry);
+
+ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *class_entry);
+ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce, char *parent_name);
+
+ZEND_API zend_module_entry *zend_get_module(int module_number);
+ZEND_API int zend_disable_function(char *function_name, uint function_name_length);
+
+ZEND_API void wrong_param_count(void);
+
+#define getThis() (this_ptr)
+
+#define WRONG_PARAM_COUNT					ZEND_WRONG_PARAM_COUNT()
+#define WRONG_PARAM_COUNT_WITH_RETVAL(ret)	ZEND_WRONG_PARAM_COUNT_WITH_RETVAL(ret)
+#define ARG_COUNT(dummy)	(ht)
+#define ZEND_NUM_ARGS()		(ht)
+#define ZEND_WRONG_PARAM_COUNT()					{ wrong_param_count(); return; }
+#define ZEND_WRONG_PARAM_COUNT_WITH_RETVAL(ret)		{ wrong_param_count(); return ret; }
+
+#ifndef ZEND_WIN32
+#define DLEXPORT
+#endif
+
+ZEND_API int zend_startup_module(zend_module_entry *module);
+
+#define array_init(arg)			_array_init((arg) ZEND_FILE_LINE_CC)
+#define object_init(arg)		_object_init((arg) ZEND_FILE_LINE_CC)
+#define object_init_ex(arg, ce)	_object_init_ex((arg), (ce) ZEND_FILE_LINE_CC)
+ZEND_API int _array_init(zval *arg ZEND_FILE_LINE_DC);
+ZEND_API int _object_init(zval *arg ZEND_FILE_LINE_DC);
+ZEND_API int _object_init_ex(zval *arg, zend_class_entry *ce ZEND_FILE_LINE_DC);
+
+/* no longer supported */
+ZEND_API int add_assoc_function(zval *arg, char *key,void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS));
+
+ZEND_API int add_assoc_long(zval *arg, char *key, long n);
+ZEND_API int add_assoc_unset(zval *arg, char *key);
+ZEND_API int add_assoc_bool(zval *arg, char *key, int b);
+ZEND_API int add_assoc_resource(zval *arg, char *key, int r);
+ZEND_API int add_assoc_double(zval *arg, char *key, double d);
+ZEND_API int add_assoc_string(zval *arg, char *key, char *str, int duplicate);
+ZEND_API int add_assoc_stringl(zval *arg, char *key, char *str, uint length, int duplicate);
+
+ZEND_API int add_index_long(zval *arg, uint idx, long n);
+ZEND_API int add_index_unset(zval *arg, uint idx);
+ZEND_API int add_index_bool(zval *arg, uint idx, int b);
+ZEND_API int add_index_resource(zval *arg, uint idx, int r);
+ZEND_API int add_index_double(zval *arg, uint idx, double d);
+ZEND_API int add_index_string(zval *arg, uint idx, char *str, int duplicate);
+ZEND_API int add_index_stringl(zval *arg, uint idx, char *str, uint length, int duplicate);
+
+ZEND_API int add_next_index_long(zval *arg, long n);
+ZEND_API int add_next_index_unset(zval *arg);
+ZEND_API int add_next_index_bool(zval *arg, int b);
+ZEND_API int add_next_index_resource(zval *arg, int r);
+ZEND_API int add_next_index_double(zval *arg, double d);
+ZEND_API int add_next_index_string(zval *arg, char *str, int duplicate);
+ZEND_API int add_next_index_stringl(zval *arg, char *str, uint length, int duplicate);
+
+ZEND_API int add_get_index_long(zval *arg, uint idx, long l, void **dest);
+ZEND_API int add_get_index_double(zval *arg, uint idx, double d, void **dest);
+ZEND_API int add_get_assoc_string(zval *arg, char *key, char *str, void **dest, int duplicate);
+ZEND_API int add_get_assoc_stringl(zval *arg, char *key, char *str, uint length, void **dest, int duplicate);
+ZEND_API int add_get_index_string(zval *arg, uint idx, char *str, void **dest, int duplicate);
+ZEND_API int add_get_index_stringl(zval *arg, uint idx, char *str, uint length, void **dest, int duplicate);
+
+ZEND_API int call_user_function(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, int param_count, zval *params[]);
+ZEND_API int call_user_function_ex(HashTable *function_table, zval *object, zval *function_name, zval **retval_ptr_ptr, int param_count, zval **params[], int no_separation, HashTable *symbol_table);
+
+ZEND_API int add_property_long(zval *arg, char *key, long l);
+ZEND_API int add_property_unset(zval *arg, char *key);
+ZEND_API int add_property_bool(zval *arg, char *key, int b);
+ZEND_API int add_property_resource(zval *arg, char *key, long r);
+ZEND_API int add_property_double(zval *arg, char *key, double d);
+ZEND_API int add_property_string(zval *arg, char *key, char *str, int duplicate);
+ZEND_API int add_property_stringl(zval *arg, char *key, char *str, uint length, int duplicate);
+
+ZEND_API int zend_set_hash_symbol(zval *symbol, char *name, int name_length,
+                                  int is_ref, int num_symbol_tables, ...);
+
+#define add_method(arg,key,method)	add_assoc_function((arg),(key),(method))
+
+#define ZVAL_RESOURCE(z,l) {			\
+		(z)->type = IS_RESOURCE;        \
+		(z)->value.lval = l;	        \
+	}
+#define ZVAL_BOOL(z,b) {				\
+		(z)->type = IS_BOOL;	        \
+		(z)->value.lval = b;	        \
+	}
+#define ZVAL_NULL(z) {					\
+		(z)->type = IS_NULL;	        \
+	}
+#define ZVAL_LONG(z,l) {				\
+		(z)->type = IS_LONG;	        \
+		(z)->value.lval = l;	        \
+	}
+#define ZVAL_DOUBLE(z,d) {				\
+		(z)->type = IS_DOUBLE;	        \
+		(z)->value.dval = d;	        \
+	}
+#define ZVAL_STRING(z,s,duplicate) {	\
+		char *__s=(s);					\
+		(z)->value.str.len = strlen(__s);	\
+		(z)->value.str.val = (duplicate?estrndup(__s,(z)->value.str.len):__s);	\
+		(z)->type = IS_STRING;	        \
+	}
+#define ZVAL_STRINGL(z,s,l,duplicate) {	\
+		char *__s=(s); int __l=l;		\
+		(z)->value.str.len = __l;	    \
+		(z)->value.str.val = (duplicate?estrndup(__s,__l):__s);	\
+		(z)->type = IS_STRING;		    \
+	}
+
+#define ZVAL_EMPTY_STRING(z) {	        \
+		(z)->value.str.len = 0;  	    \
+		(z)->value.str.val = empty_string; \
+		(z)->type = IS_STRING;		    \
+	}
+
+#define ZVAL_FALSE  { (z)->value.lval = 0;  (z)->type = IS_BOOL; }
+#define ZVAL_TRUE   { (z)->value.lval = 1;  (z)->type = IS_BOOL; }
+
+#define RETVAL_RESOURCE(l) {			\
+		return_value->type = IS_RESOURCE;\
+		return_value->value.lval = l;	\
+	}
+#define RETVAL_BOOL(b) {				\
+		return_value->type = IS_BOOL;	\
+		return_value->value.lval = b;	\
+	}
+#define RETVAL_NULL() {					\
+		return_value->type = IS_NULL;	\
+	}
+#define RETVAL_LONG(l) {				\
+		return_value->type = IS_LONG;	\
+		return_value->value.lval = l;	\
+	}
+#define RETVAL_DOUBLE(d) {				\
+		return_value->type = IS_DOUBLE;	\
+		return_value->value.dval = d;	\
+	}
+#define RETVAL_STRING(s,duplicate) {	\
+		char *__s=(s);					\
+		return_value->value.str.len = strlen(__s);	\
+		return_value->value.str.val = (duplicate?estrndup(__s,return_value->value.str.len):__s);	\
+		return_value->type = IS_STRING;	\
+	}
+#define RETVAL_STRINGL(s,l,duplicate) {		\
+		char *__s=(s); int __l=l;			\
+		return_value->value.str.len = __l;	\
+		return_value->value.str.val = (duplicate?estrndup(__s,__l):__s);	\
+		return_value->type = IS_STRING;		\
+	}
+
+#define RETVAL_EMPTY_STRING() {	            \
+		return_value->value.str.len = 0;  	\
+		return_value->value.str.val = empty_string; \
+		return_value->type = IS_STRING;		\
+	}
+
+#define RETVAL_FALSE  { return_value->value.lval = 0;  return_value->type = IS_BOOL; }
+#define RETVAL_TRUE   { return_value->value.lval = 1;  return_value->type = IS_BOOL; }
+
+#define RETURN_RESOURCE(l) {			\
+		return_value->type = IS_RESOURCE;\
+		return_value->value.lval = l;	\
+		return;							\
+	}
+
+#define RETURN_BOOL(b) {				\
+		return_value->type = IS_BOOL;	\
+		return_value->value.lval = b;	\
+		return;							\
+	}
+
+#define RETURN_NULL() {				\
+		return_value->type = IS_NULL;	\
+		return;							\
+	}
+
+#define RETURN_LONG(l) {				\
+		return_value->type = IS_LONG;	\
+		return_value->value.lval = l;	\
+		return;							\
+	}
+#define RETURN_DOUBLE(d) {				\
+		return_value->type = IS_DOUBLE;	\
+		return_value->value.dval = d;	\
+		return;							\
+	}
+#define RETURN_STRING(s,duplicate) {	\
+		char *__s=(s);					\
+		return_value->value.str.len = strlen(__s);	\
+		return_value->value.str.val = (duplicate?estrndup(__s,return_value->value.str.len):__s);	\
+		return_value->type = IS_STRING;	\
+		return;							\
+	}
+#define RETURN_STRINGL(s,l,duplicate) {		\
+		char *__s=(s); int __l=l;			\
+		return_value->value.str.len = __l;	\
+		return_value->value.str.val = (duplicate?estrndup(__s,__l):__s);	\
+      	return_value->type = IS_STRING;		\
+		return;								\
+	}
+
+#define RETURN_EMPTY_STRING() {	            \
+		return_value->value.str.len = 0;  	\
+		return_value->value.str.val = empty_string; \
+		return_value->type = IS_STRING;		\
+        return;                             \
+	}
+
+#define RETURN_FALSE  { RETVAL_FALSE; return; }
+#define RETURN_TRUE   { RETVAL_TRUE; return; }
+
+#define SET_VAR_STRING(n,v)	{																				\
+								{																			\
+									zval *var;																\
+									char *str=(v); /* prevent 'v' from being evaluated more than once */	\
+																											\
+									ALLOC_ZVAL(var);														\
+									var->value.str.val = (str);												\
+									var->value.str.len = strlen((str));										\
+									var->type = IS_STRING;													\
+									ZEND_SET_GLOBAL_VAR(n, var);											\
+								}																			\
+							}
+
+#define SET_VAR_STRINGL(n,v,l)	{														\
+									{													\
+										zval *var;										\
+																						\
+										ALLOC_ZVAL(var);								\
+										var->value.str.val = (v);						\
+										var->value.str.len = (l);						\
+										var->type = IS_STRING;							\
+										ZEND_SET_GLOBAL_VAR(n, var);					\
+									}													\
+								}
+
+#define SET_VAR_LONG(n,v)	{															\
+								{														\
+									zval *var;											\
+																						\
+									ALLOC_ZVAL(var);									\
+									var->value.lval = (v);								\
+									var->type = IS_LONG;								\
+									ZEND_SET_GLOBAL_VAR(n, var);						\
+								}														\
+							}
+
+#define SET_VAR_DOUBLE(n,v)	{															\
+								{														\
+									zval *var;											\
+																						\
+									ALLOC_ZVAL(var);									\
+									var->value.dval = (v);								\
+									var->type = IS_DOUBLE;								\
+									ZEND_SET_GLOBAL_VAR(n, var);						\
+								}														\
+							}
+
+
+#define ZEND_SET_SYMBOL(symtable, name, var)										\
+	{																				\
+		char *_name = (name);														\
+																					\
+		ZEND_SET_SYMBOL_WITH_LENGTH(symtable, _name, strlen(_name)+1, var, 1, 0);	\
+	}
+
+#define ZEND_SET_SYMBOL_WITH_LENGTH(symtable, name, name_length, var, _refcount, _is_ref)				\
+	{																									\
+		zval **orig_var;																				\
+																										\
+		if (zend_hash_find(symtable, (name), (name_length), (void **) &orig_var)==SUCCESS				\
+			&& PZVAL_IS_REF(*orig_var)) {																\
+			(var)->refcount = (*orig_var)->refcount;													\
+			(var)->is_ref = 1;																			\
+																										\
+			if (_refcount) {																			\
+				(var)->refcount += _refcount-1;															\
+			}																							\
+			zval_dtor(*orig_var);																		\
+			**orig_var = *(var);																		\
+			FREE_ZVAL(var);																					\
+		} else {																						\
+			(var)->is_ref = _is_ref;																	\
+			if (_refcount) {																			\
+				(var)->refcount = _refcount;															\
+			}																							\
+			zend_hash_update(symtable, (name), (name_length), &(var), sizeof(zval *), NULL);			\
+		}																								\
+	}
+
+
+#define ZEND_SET_GLOBAL_VAR(name, var)				\
+	ZEND_SET_SYMBOL(&EG(symbol_table), name, var)
+
+#define ZEND_SET_GLOBAL_VAR_WITH_LENGTH(name, name_length, var, _refcount, _is_ref)		\
+	ZEND_SET_SYMBOL_WITH_LENGTH(&EG(symbol_table), name, name_length, var, _refcount, _is_ref)
+
+#define HASH_OF(p) ((p)->type==IS_ARRAY ? (p)->value.ht : (((p)->type==IS_OBJECT ? (p)->value.obj.properties : NULL)))
+#define ZVAL_IS_NULL(z) ((z)->type==IS_NULL)
+
+#endif /* ZEND_API_H */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */

Zend/zend_alloc.c

@@ -0,0 +1,721 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#include <stdlib.h>
+
+#include "zend.h"
+#include "zend_alloc.h"
+#include "zend_globals.h"
+#include "zend_fast_cache.h"
+#ifdef HAVE_SIGNAL_H
+# include <signal.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#ifndef ZTS
+ZEND_API zend_alloc_globals alloc_globals;
+#endif
+
+
+#define ZEND_DISABLE_MEMORY_CACHE 0
+
+
+#if ZEND_DEBUG
+# define END_MAGIC_SIZE sizeof(long)
+# define END_ALIGNMENT(size) (((size)%PLATFORM_ALIGNMENT)?(PLATFORM_ALIGNMENT-((size)%PLATFORM_ALIGNMENT)):0)
+#else
+# define END_MAGIC_SIZE 0
+# define END_ALIGNMENT(size) 0
+#endif
+
+
+# if MEMORY_LIMIT
+#  if ZEND_DEBUG
+#define CHECK_MEMORY_LIMIT(s, rs) _CHECK_MEMORY_LIMIT(s, rs, __zend_filename, __zend_lineno)
+#  else
+#define CHECK_MEMORY_LIMIT(s, rs)	_CHECK_MEMORY_LIMIT(s, rs, NULL,0)
+#  endif
+
+#define _CHECK_MEMORY_LIMIT(s, rs, file, lineno) { AG(allocated_memory) += rs;\
+								if (AG(memory_limit)<AG(allocated_memory)) {\
+									if ((AG(memory_limit)+1048576)<AG(allocated_memory)) { \
+										/* failed to handle this gracefully, exit() */ \
+										exit(1);	\
+									}	\
+									if (!AG(memory_exhausted)) {	\
+										if (!file) { \
+											zend_error(E_ERROR,"Allowed memory size of %d bytes exhausted (tried to allocate %d bytes)", AG(memory_limit),s); \
+										} else { \
+											zend_error(E_ERROR,"Allowed memory size of %d bytes exhausted at %s:%d (tried to allocate %d bytes)", AG(memory_limit), file, lineno, s); \
+										} \
+										AG(memory_exhausted)=1;	\
+									}	\
+								} \
+							}
+# endif
+
+#ifndef CHECK_MEMORY_LIMIT
+#define CHECK_MEMORY_LIMIT(s, rs)
+#endif
+
+
+#define REMOVE_POINTER_FROM_LIST(p)				\
+	if (!p->persistent && p==AG(head)) {		\
+		AG(head) = p->pNext;					\
+	} else if (p->persistent && p==AG(phead)) {	\
+		AG(phead) = p->pNext;					\
+	} else {									\
+		p->pLast->pNext = p->pNext;				\
+	}											\
+	if (p->pNext) {								\
+		p->pNext->pLast = p->pLast;				\
+	}
+
+#define ADD_POINTER_TO_LIST(p)		\
+	if (p->persistent) {			\
+		p->pNext = AG(phead);		\
+		if (AG(phead)) {			\
+			AG(phead)->pLast = p;	\
+		}							\
+		AG(phead) = p;				\
+	} else {						\
+		p->pNext = AG(head);		\
+		if (AG(head)) {				\
+			AG(head)->pLast = p;	\
+		}							\
+		AG(head) = p;				\
+	}								\
+	p->pLast = (zend_mem_header *) NULL;
+
+#define DECLARE_CACHE_VARS		\
+	unsigned int real_size;		\
+	unsigned int cache_index;
+
+#define REAL_SIZE(size) ((size+7) & ~0x7)
+
+#define CALCULATE_REAL_SIZE_AND_CACHE_INDEX(size)	\
+	real_size = REAL_SIZE(size);				\
+	cache_index = real_size >> 3;
+
+#define SIZE real_size
+
+#define CACHE_INDEX cache_index
+
+ZEND_API void *_emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
+{
+	zend_mem_header *p;
+	DECLARE_CACHE_VARS
+	ALS_FETCH();
+
+	CALCULATE_REAL_SIZE_AND_CACHE_INDEX(size);
+
+	if (!ZEND_DISABLE_MEMORY_CACHE && (CACHE_INDEX < MAX_CACHED_MEMORY) && (AG(cache_count)[CACHE_INDEX] > 0)) {
+		p = AG(cache)[CACHE_INDEX][--AG(cache_count)[CACHE_INDEX]];
+#if ZEND_DEBUG
+		p->filename = __zend_filename;
+		p->lineno = __zend_lineno;
+		p->orig_filename = __zend_orig_filename;
+		p->orig_lineno = __zend_orig_lineno;
+		p->magic = MEM_BLOCK_START_MAGIC;
+		p->reported = 0;
+		/* Setting the thread id should not be necessary, because we fetched this block
+		 * from this thread's cache
+		 */
+		AG(cache_stats)[CACHE_INDEX][1]++;
+#endif
+		p->persistent = 0;
+		p->cached = 0;
+		p->size = size;
+		HANDLE_BLOCK_INTERRUPTIONS();
+		ADD_POINTER_TO_LIST(p);
+		HANDLE_UNBLOCK_INTERRUPTIONS();
+		return (void *)((char *)p + sizeof(zend_mem_header) + PLATFORM_PADDING);
+	} else {
+#if ZEND_DEBUG
+		if (CACHE_INDEX<MAX_CACHED_MEMORY) {
+			AG(cache_stats)[CACHE_INDEX][0]++;
+		}
+#endif
+		p  = (zend_mem_header *) malloc(sizeof(zend_mem_header) + SIZE + PLATFORM_PADDING + END_ALIGNMENT(SIZE) + END_MAGIC_SIZE);
+	}
+
+	HANDLE_BLOCK_INTERRUPTIONS();
+
+	if (!p) {
+		fprintf(stderr,"FATAL:  emalloc():  Unable to allocate %ld bytes\n", (long) size);
+#if ZEND_DEBUG && defined(HAVE_KILL) && defined(HAVE_GETPID)
+		kill(getpid(), SIGSEGV);
+#else
+		exit(1);
+#endif
+		HANDLE_UNBLOCK_INTERRUPTIONS();
+		return (void *)p;
+	}
+	p->persistent = p->cached = 0;
+	ADD_POINTER_TO_LIST(p);
+	p->size = size; /* Save real size for correct cache output */
+#if ZEND_DEBUG
+	p->filename = __zend_filename;
+	p->lineno = __zend_lineno;
+	p->orig_filename = __zend_orig_filename;
+	p->orig_lineno = __zend_orig_lineno;
+	p->magic = MEM_BLOCK_START_MAGIC;
+	p->reported = 0;
+# ifdef ZTS
+	p->thread_id = tsrm_thread_id();
+# endif
+	*((long *)(((char *) p) + sizeof(zend_mem_header)+SIZE+PLATFORM_PADDING+END_ALIGNMENT(SIZE))) = MEM_BLOCK_END_MAGIC;
+#endif
+#if MEMORY_LIMIT
+	CHECK_MEMORY_LIMIT(size, SIZE);
+#endif
+	HANDLE_UNBLOCK_INTERRUPTIONS();
+	return (void *)((char *)p + sizeof(zend_mem_header) + PLATFORM_PADDING);
+}
+
+
+ZEND_API void _efree(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
+{
+	zend_mem_header *p = (zend_mem_header *) ((char *)ptr - sizeof(zend_mem_header) - PLATFORM_PADDING);
+	DECLARE_CACHE_VARS
+	ALS_FETCH();
+
+#if defined(ZTS) && ZEND_DEBUG
+	if (p->thread_id != tsrm_thread_id()) {
+		tsrm_error(TSRM_ERROR_LEVEL_ERROR, "Memory block allocated at %s:(%d) on thread %x freed at %s:(%d) on thread %x, ignoring",
+			p->filename, p->lineno, p->thread_id,
+			__zend_filename, __zend_lineno, tsrm_thread_id());
+		return;
+	}
+#endif
+
+	CALCULATE_REAL_SIZE_AND_CACHE_INDEX(p->size);
+#if ZEND_DEBUG
+	if (!_mem_block_check(ptr, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC)) {
+		return;
+	}
+	memset(ptr, 0x5a, SIZE);
+#endif
+
+	if (!ZEND_DISABLE_MEMORY_CACHE 
+		&& !p->persistent && (CACHE_INDEX < MAX_CACHED_MEMORY) && (AG(cache_count)[CACHE_INDEX] < MAX_CACHED_ENTRIES)) {
+		AG(cache)[CACHE_INDEX][AG(cache_count)[CACHE_INDEX]++] = p;
+		p->cached = 1;
+#if ZEND_DEBUG
+		p->magic = MEM_BLOCK_CACHED_MAGIC;
+#endif
+		HANDLE_BLOCK_INTERRUPTIONS();
+		REMOVE_POINTER_FROM_LIST(p);
+		HANDLE_UNBLOCK_INTERRUPTIONS();
+		return;
+	}
+	HANDLE_BLOCK_INTERRUPTIONS();
+	REMOVE_POINTER_FROM_LIST(p);
+
+#if MEMORY_LIMIT
+	AG(allocated_memory) -= SIZE;
+#endif
+	
+	free(p);
+	HANDLE_UNBLOCK_INTERRUPTIONS();
+}
+
+
+ZEND_API void *_ecalloc(size_t nmemb, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
+{
+	void *p;
+	int final_size=size*nmemb;
+	
+	HANDLE_BLOCK_INTERRUPTIONS();
+	p = _emalloc(final_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
+	if (!p) {
+		HANDLE_UNBLOCK_INTERRUPTIONS();
+		return (void *) p;
+	}
+	memset(p,(int)NULL, final_size);
+	HANDLE_UNBLOCK_INTERRUPTIONS();
+	return p;
+}
+
+
+ZEND_API void *_erealloc(void *ptr, size_t size, int allow_failure ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
+{
+	zend_mem_header *p = (zend_mem_header *) ((char *)ptr-sizeof(zend_mem_header)-PLATFORM_PADDING);
+	zend_mem_header *orig = p;
+	DECLARE_CACHE_VARS
+	ALS_FETCH();
+
+	if (!ptr) {
+		return _emalloc(size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
+	}
+
+#if defined(ZTS) && ZEND_DEBUG
+	if (p->thread_id != tsrm_thread_id()) {
+		void *new_p;
+
+		tsrm_error(TSRM_ERROR_LEVEL_ERROR, "Memory block allocated at %s:(%d) on thread %x reallocated at %s:(%d) on thread %x, duplicating",
+			p->filename, p->lineno, p->thread_id,
+			__zend_filename, __zend_lineno, tsrm_thread_id());
+		new_p = _emalloc(size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
+		memcpy(new_p, ptr, p->size);
+		return new_p;
+	}
+#endif
+
+	CALCULATE_REAL_SIZE_AND_CACHE_INDEX(size);
+
+	HANDLE_BLOCK_INTERRUPTIONS();
+	REMOVE_POINTER_FROM_LIST(p);
+	p = (zend_mem_header *) realloc(p,sizeof(zend_mem_header)+SIZE+PLATFORM_PADDING+END_ALIGNMENT(SIZE)+END_MAGIC_SIZE);
+	if (!p) {
+		if (!allow_failure) {
+			fprintf(stderr,"FATAL:  erealloc():  Unable to allocate %ld bytes\n", (long) size);
+#if ZEND_DEBUG && HAVE_KILL && HAVE_GETPID
+			kill(getpid(), SIGSEGV);
+#else
+			exit(1);
+#endif
+		}
+		ADD_POINTER_TO_LIST(orig);
+		HANDLE_UNBLOCK_INTERRUPTIONS();
+		return (void *)NULL;
+	}
+	ADD_POINTER_TO_LIST(p);
+#if ZEND_DEBUG
+	p->filename = __zend_filename;
+	p->lineno = __zend_lineno;
+	p->magic = MEM_BLOCK_START_MAGIC;
+	*((long *)(((char *) p) + sizeof(zend_mem_header)+SIZE+PLATFORM_PADDING+END_ALIGNMENT(SIZE))) = MEM_BLOCK_END_MAGIC;
+#endif	
+#if MEMORY_LIMIT
+	CHECK_MEMORY_LIMIT(size - p->size, SIZE - REAL_SIZE(p->size));
+#endif
+	p->size = size;
+
+	HANDLE_UNBLOCK_INTERRUPTIONS();
+	return (void *)((char *)p+sizeof(zend_mem_header)+PLATFORM_PADDING);
+}
+
+
+ZEND_API char *_estrdup(const char *s ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
+{
+	int length;
+	char *p;
+
+	length = strlen(s)+1;
+	HANDLE_BLOCK_INTERRUPTIONS();
+	p = (char *) _emalloc(length ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
+	if (!p) {
+		HANDLE_UNBLOCK_INTERRUPTIONS();
+		return (char *)NULL;
+	}
+	HANDLE_UNBLOCK_INTERRUPTIONS();
+	memcpy(p,s,length);
+	return p;
+}
+
+
+ZEND_API char *_estrndup(const char *s, uint length ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
+{
+	char *p;
+
+	HANDLE_BLOCK_INTERRUPTIONS();
+	p = (char *) _emalloc(length+1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
+	if (!p) {
+		HANDLE_UNBLOCK_INTERRUPTIONS();
+		return (char *)NULL;
+	}
+	HANDLE_UNBLOCK_INTERRUPTIONS();
+	memcpy(p,s,length);
+	p[length]=0;
+	return p;
+}
+
+
+ZEND_API char *zend_strndup(const char *s, uint length)
+{
+	char *p;
+
+	p = (char *) malloc(length+1);
+	if (!p) {
+		return (char *)NULL;
+	}
+	if (length) {
+		memcpy(p,s,length);
+	}
+	p[length]=0;
+	return p;
+}
+
+
+ZEND_API int zend_set_memory_limit(unsigned int memory_limit)
+{
+#if MEMORY_LIMIT
+	ALS_FETCH();
+
+	AG(memory_limit) = memory_limit;
+	return SUCCESS;
+#else
+	return FAILURE;
+#endif
+}
+
+
+ZEND_API void start_memory_manager(ALS_D)
+{
+#ifndef ZTS
+	int i, j;
+	void *cached_entries[MAX_CACHED_MEMORY][MAX_CACHED_ENTRIES];
+#endif
+
+	AG(phead) = AG(head) = NULL;
+	
+#if MEMORY_LIMIT
+	AG(memory_limit)=1<<30;		/* rediculous limit, effectively no limit */
+	AG(allocated_memory)=0;
+	AG(memory_exhausted)=0;
+#endif
+
+	memset(AG(fast_cache_list_head), 0, sizeof(AG(fast_cache_list_head)));
+	memset(AG(cache_count),0,sizeof(AG(cache_count)));
+
+#ifndef ZTS
+	/* Initialize cache, to prevent fragmentation */
+	/* We can't do this in ZTS mode, because calling emalloc() from within start_memory_manager()
+	 * will yield an endless recursion calling to alloc_globals_ctor()
+	 */
+	for (i=1; i<MAX_CACHED_MEMORY; i++) {
+		for (j=0; j<PRE_INIT_CACHE_ENTRIES; j++) {
+			cached_entries[i][j] = emalloc(8*i);
+		}
+	}
+	for (i=1; i<MAX_CACHED_MEMORY; i++) {
+		for (j=0; j<PRE_INIT_CACHE_ENTRIES; j++) {
+			efree(cached_entries[i][j]);
+		}
+	}
+#endif
+
+#if ZEND_DEBUG
+	memset(AG(cache_stats), 0, sizeof(AG(cache_stats)));
+	memset(AG(fast_cache_stats), 0, sizeof(AG(fast_cache_stats)));
+#endif
+}
+
+
+ZEND_API void shutdown_memory_manager(int silent, int clean_cache)
+{
+	zend_mem_header *p, *t;
+	unsigned int fci, i, j;
+#if ZEND_DEBUG
+	int had_leaks=0;
+#endif
+	zend_fast_cache_list_entry *fast_cache_list_entry, *next_fast_cache_list_entry;
+	ALS_FETCH();
+
+	for (fci=0; fci<MAX_FAST_CACHE_TYPES; fci++) {
+		fast_cache_list_entry = AG(fast_cache_list_head)[fci];
+		while (fast_cache_list_entry) {
+			next_fast_cache_list_entry = fast_cache_list_entry->next;
+			efree(fast_cache_list_entry);
+			fast_cache_list_entry = next_fast_cache_list_entry;
+		}
+		AG(fast_cache_list_head)[fci] = NULL;
+	}
+
+	p=AG(head);
+	t=AG(head);
+	while (t) {
+		if (!t->cached || clean_cache) {
+#if ZEND_DEBUG
+			if (!t->cached && !t->reported) {
+				zend_mem_header *iterator;
+				int total_leak=0, total_leak_count=0;
+
+				had_leaks=1;
+				if (!silent) {
+					zend_message_dispatcher(ZMSG_MEMORY_LEAK_DETECTED, t);
+				}
+				t->reported = 1;
+				for (iterator=t->pNext; iterator; iterator=iterator->pNext) {
+					if (!iterator->cached
+						&& iterator->filename==t->filename
+						&& iterator->lineno==t->lineno) {
+						total_leak += iterator->size;
+						total_leak_count++;
+						iterator->reported = 1;
+					}
+				}
+				if (!silent && total_leak_count>0) {
+					zend_message_dispatcher(ZMSG_MEMORY_LEAK_REPEATED, (void *) (long) (total_leak_count));
+				}
+			}
+#endif
+#if MEMORY_LIMIT
+			AG(allocated_memory) -= t->size;
+#endif
+			p = t->pNext;
+			REMOVE_POINTER_FROM_LIST(t);
+			free(t);
+			t = p;
+		} else {
+			t = t->pNext;
+		}
+	}
+
+	if(clean_cache) {
+		for (i=1; i<MAX_CACHED_MEMORY; i++) {
+			for (j=0; j<AG(cache_count)[i]; j++) {
+				free(AG(cache)[i][j]);
+			}
+		}
+	}
+#if MEMORY_LIMIT
+	AG(memory_exhausted)=0;
+#endif
+
+#if (ZEND_DEBUG)
+	do {
+		zval display_memory_cache_stats;
+		int i, j;
+
+		if (clean_cache) {
+			/* we're shutting down completely, don't even touch the INI subsystem */
+			break;
+		}
+		if (zend_get_ini_entry("display_memory_cache_stats", sizeof("display_memory_cache_stats"), &display_memory_cache_stats)==FAILURE) {
+			break;
+		}
+		if (!atoi(display_memory_cache_stats.value.str.val)) {
+			break;
+		}
+		fprintf(stderr, "Memory cache statistics\n"
+						"-----------------------\n\n"
+						"[zval, %2ld]\t\t%d / %d (%.2f%%)\n"
+						"[hash, %2ld]\t\t%d / %d (%.2f%%)\n",
+						(long) sizeof(zval),
+						AG(fast_cache_stats)[ZVAL_CACHE_LIST][1], AG(fast_cache_stats)[ZVAL_CACHE_LIST][0]+AG(fast_cache_stats)[ZVAL_CACHE_LIST][1],
+						((double) AG(fast_cache_stats)[ZVAL_CACHE_LIST][1] / (AG(fast_cache_stats)[ZVAL_CACHE_LIST][0]+AG(fast_cache_stats)[ZVAL_CACHE_LIST][1]))*100,
+						(long) sizeof(HashTable),
+						AG(fast_cache_stats)[HASHTABLE_CACHE_LIST][1], AG(fast_cache_stats)[HASHTABLE_CACHE_LIST][0]+AG(fast_cache_stats)[HASHTABLE_CACHE_LIST][1],
+						((double) AG(fast_cache_stats)[HASHTABLE_CACHE_LIST][1] / (AG(fast_cache_stats)[HASHTABLE_CACHE_LIST][0]+AG(fast_cache_stats)[HASHTABLE_CACHE_LIST][1]))*100);
+
+
+		for (i=0; i<MAX_CACHED_MEMORY; i+=2) {
+			fprintf(stderr, "[%2d, %2d]\t\t", i, i+1);
+			for (j=0; j<2; j++) {
+				fprintf(stderr, "%d / %d (%.2f%%)\t\t",
+						AG(cache_stats)[i+j][1], AG(cache_stats)[i+j][0]+AG(cache_stats)[i+j][1],
+						((double) AG(cache_stats)[i+j][1] / (AG(cache_stats)[i+j][0]+AG(cache_stats)[i+j][1]))*100);
+			}
+			fprintf(stderr, "\n");
+		}
+					
+	} while (0);
+#endif
+}
+
+
+#if ZEND_DEBUG
+void zend_debug_alloc_output(char *format, ...)
+{
+	char output_buf[256];
+	va_list args;
+
+	va_start(args, format);
+	vsprintf(output_buf, format, args);
+	va_end(args);
+
+#ifdef ZEND_WIN32
+	OutputDebugString(output_buf);
+#else
+	fprintf(stderr, "%s", output_buf);
+#endif
+}
+
+
+ZEND_API int _mem_block_check(void *ptr, int silent ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
+{
+	zend_mem_header *p = (zend_mem_header *) ((char *)ptr - sizeof(zend_mem_header) - PLATFORM_PADDING);
+	int no_cache_notice=0;
+	int valid_beginning=1;
+	int had_problems=0;
+
+	if (silent==2) {
+		silent=1;
+		no_cache_notice=1;
+	}
+	if (silent==3) {
+		silent=0;
+		no_cache_notice=1;
+	}
+	if (!silent) {
+		zend_message_dispatcher(ZMSG_LOG_SCRIPT_NAME, NULL);
+		zend_debug_alloc_output("---------------------------------------\n");
+		zend_debug_alloc_output("%s(%d) : Block 0x%0.8lX status:\n" ZEND_FILE_LINE_RELAY_CC, (long) p);
+		if (__zend_orig_filename) {
+			zend_debug_alloc_output("%s(%d) : Actual location (location was relayed)\n" ZEND_FILE_LINE_ORIG_RELAY_CC);
+		}
+		zend_debug_alloc_output("%10s\t","Beginning:  ");
+	}
+
+	switch (p->magic) {
+		case MEM_BLOCK_START_MAGIC:
+			if (!silent) {
+				zend_debug_alloc_output("OK (allocated on %s:%d, %d bytes)\n", p->filename, p->lineno, p->size);
+			}
+			break; /* ok */
+		case MEM_BLOCK_FREED_MAGIC:
+			if (!silent) {
+				zend_debug_alloc_output("Freed\n");
+				had_problems=1;
+			} else {
+				return _mem_block_check(ptr, 0 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
+			}
+			break;
+		case MEM_BLOCK_CACHED_MAGIC:
+			if (!silent) {
+				if (!no_cache_notice) {
+					zend_debug_alloc_output("Cached (allocated on %s:%d, %d bytes)\n", p->filename, p->lineno, p->size);
+					had_problems=1;
+				}
+			} else {
+				if (!no_cache_notice) {
+					return _mem_block_check(ptr, 0 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
+				}
+			}
+			break;
+		default:
+			if (!silent) {
+				zend_debug_alloc_output("Overrun (magic=0x%0.8lX, expected=0x%0.8lX)\n", p->magic, MEM_BLOCK_START_MAGIC);
+			} else {
+				return _mem_block_check(ptr, 0 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
+			}
+			had_problems=1;
+			valid_beginning=0;
+			break;
+	}
+
+
+	if (valid_beginning
+		&& *((long *)(((char *) p)+sizeof(zend_mem_header)+REAL_SIZE(p->size)+PLATFORM_PADDING+END_ALIGNMENT(REAL_SIZE(p->size)))) != MEM_BLOCK_END_MAGIC) {
+		long magic_num = MEM_BLOCK_END_MAGIC;
+		char *overflow_ptr, *magic_ptr=(char *) &magic_num;
+		int overflows=0;
+		int i;
+
+		if (silent) {
+			return _mem_block_check(ptr, 0 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
+		}
+		had_problems=1;
+		overflow_ptr = ((char *) p)+sizeof(zend_mem_header)+REAL_SIZE(p->size)+PLATFORM_PADDING;
+
+		for (i=0; i<sizeof(long); i++) {
+			if (overflow_ptr[i]!=magic_ptr[i]) {
+				overflows++;
+			}
+		}
+
+		zend_debug_alloc_output("%10s\t", "End:");
+		zend_debug_alloc_output("Overflown (magic=0x%0.8lX instead of 0x%0.8lX)\n", 
+				*((long *)(((char *) p) + sizeof(zend_mem_header)+REAL_SIZE(p->size)+PLATFORM_PADDING+END_ALIGNMENT(REAL_SIZE(p->size)))), MEM_BLOCK_END_MAGIC);
+		zend_debug_alloc_output("%10s\t","");
+		if (overflows>=sizeof(long)) {
+			zend_debug_alloc_output("At least %d bytes overflown\n", sizeof(long));
+		} else {
+			zend_debug_alloc_output("%d byte(s) overflown\n", overflows);
+		}
+	} else if (!silent) {
+		zend_debug_alloc_output("%10s\t", "End:");
+		if (valid_beginning) {
+			zend_debug_alloc_output("OK\n");
+		} else {
+			zend_debug_alloc_output("Unknown\n");
+		}
+	}
+
+	if (had_problems) {
+		int foo = 5;
+
+		foo+=1;
+	}
+		
+	if (!silent) {
+		zend_debug_alloc_output("---------------------------------------\n");
+	}
+	return ((!had_problems) ? 1 : 0);
+}
+
+
+ZEND_API void _full_mem_check(int silent ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
+{
+	zend_mem_header *p;
+	int errors=0;
+	ALS_FETCH();
+
+	p = AG(head);
+	
+
+	zend_debug_alloc_output("------------------------------------------------\n");
+	zend_debug_alloc_output("Full Memory Check at %s:%d\n" ZEND_FILE_LINE_RELAY_CC);
+
+	while (p) {
+		if (!_mem_block_check((void *)((char *)p + sizeof(zend_mem_header) + PLATFORM_PADDING), (silent?2:3) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC)) {
+			errors++;
+		}
+		p = p->pNext;
+	}
+	zend_debug_alloc_output("End of full memory check %s:%d (%d errors)\n" ZEND_FILE_LINE_RELAY_CC, errors);
+	zend_debug_alloc_output("------------------------------------------------\n");
+}
+#endif
+
+
+ZEND_API int _persist_alloc(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
+{
+	zend_mem_header *p = (zend_mem_header *) ((char *)ptr-sizeof(zend_mem_header)-PLATFORM_PADDING);
+	ALS_FETCH();
+
+#if ZEND_DEBUG
+	_mem_block_check(ptr, 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
+#endif
+
+	HANDLE_BLOCK_INTERRUPTIONS();
+
+	/* remove the block from the non persistent list */
+	REMOVE_POINTER_FROM_LIST(p);
+
+	p->persistent = 1;
+
+	/* add the block to the persistent list */
+	ADD_POINTER_TO_LIST(p);
+	HANDLE_UNBLOCK_INTERRUPTIONS();
+	return REAL_SIZE(p->size)+sizeof(zend_mem_header)+PLATFORM_PADDING;
+}
+
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */

Zend/zend_alloc.h

@@ -0,0 +1,144 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_ALLOC_H
+#define ZEND_ALLOC_H
+
+#include <stdio.h>
+
+#ifdef ZTS
+#include "../TSRM/TSRM.h"
+#endif
+
+#include "zend_globals_macros.h"
+
+#define MEM_BLOCK_START_MAGIC	0x7312F8DCL
+#define MEM_BLOCK_END_MAGIC	0x2A8FCC84L
+#define MEM_BLOCK_FREED_MAGIC	0x99954317L
+#define MEM_BLOCK_CACHED_MAGIC	0xFB8277DCL
+
+typedef struct _zend_mem_header {
+#if ZEND_DEBUG
+	long magic;
+	char *filename;
+	uint lineno;
+	int reported;
+	char *orig_filename;
+	uint orig_lineno;
+# ifdef ZTS
+	THREAD_T thread_id;
+# endif
+#endif
+    struct _zend_mem_header *pNext;
+    struct _zend_mem_header *pLast;
+	unsigned int size:30;
+	unsigned int persistent:1;
+	unsigned int cached:1;
+} zend_mem_header;
+
+typedef union _align_test {
+	void *ptr;
+	double dbl;
+	long lng;
+} align_test;
+
+#define MAX_CACHED_MEMORY	11
+#define MAX_CACHED_ENTRIES	256
+#define PRE_INIT_CACHE_ENTRIES	32
+
+#if (defined (__GNUC__) && __GNUC__ >= 2)
+#define PLATFORM_ALIGNMENT (__alignof__ (align_test))
+#else
+#define PLATFORM_ALIGNMENT (sizeof(align_test))
+#endif
+
+#define PLATFORM_PADDING (((PLATFORM_ALIGNMENT-sizeof(zend_mem_header))%PLATFORM_ALIGNMENT+PLATFORM_ALIGNMENT)%PLATFORM_ALIGNMENT)
+
+
+BEGIN_EXTERN_C()
+
+ZEND_API char *zend_strndup(const char *s, unsigned int length);
+
+ZEND_API void *_emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
+ZEND_API void _efree(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
+ZEND_API void *_ecalloc(size_t nmemb, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
+ZEND_API void *_erealloc(void *ptr, size_t size, int allow_failure ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
+ZEND_API char *_estrdup(const char *s ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
+ZEND_API char *_estrndup(const char *s, unsigned int length ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
+ZEND_API int _persist_alloc(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
+
+/* Standard wrapper macros */
+#define emalloc(size)					_emalloc((size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
+#define efree(ptr)						_efree((ptr) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
+#define ecalloc(nmemb,size)				_ecalloc((nmemb), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
+#define erealloc(ptr,size)				_erealloc((ptr), (size),0 ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
+#define erealloc_recoverable(ptr,size)	_erealloc((ptr), (size),1 ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
+#define estrdup(s)						_estrdup((s) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
+#define estrndup(s,length)				_estrndup((s), (length) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
+#define persist_alloc(p)				_persist_alloc((p) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
+
+/* Relay wrapper macros */
+#define emalloc_rel(size)					_emalloc((size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
+#define efree_rel(ptr)						_efree((ptr) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
+#define ecalloc_rel(nmemb, size)			_ecalloc((nmemb), (size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
+#define erealloc_rel(ptr, size)				_erealloc((ptr), (size), 0 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
+#define erealloc_recoverable_rel(ptr, size)	_erealloc((ptr), (size), 1 ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
+#define estrdup_rel(s)						_estrdup((s) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
+#define estrndup_rel(s, length)				_estrndup((s), (length) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
+#define persist_alloc_rel(p)				_persist_alloc((p) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
+
+/* Selective persistent/non persistent allocation macros */
+#define pemalloc(size,persistent) ((persistent)?malloc(size):emalloc(size))
+#define pefree(ptr,persistent)  ((persistent)?free(ptr):efree(ptr))
+#define pecalloc(nmemb,size,persistent) ((persistent)?calloc((nmemb),(size)):ecalloc((nmemb),(size)))
+#define perealloc(ptr,size,persistent) ((persistent)?realloc((ptr),(size)):erealloc((ptr),(size)))
+#define perealloc_recoverable(ptr,size,persistent) ((persistent)?realloc((ptr),(size)):erealloc_recoverable((ptr),(size)))
+#define pestrdup(s,persistent) ((persistent)?strdup(s):estrdup(s))
+
+#define safe_estrdup(ptr)  ((ptr)?(estrdup(ptr)):(empty_string))
+#define safe_estrndup(ptr,len) ((ptr)?(estrndup((ptr),(len))):(empty_string))
+
+ZEND_API int zend_set_memory_limit(unsigned int memory_limit);
+
+ZEND_API void start_memory_manager(ALS_D);
+ZEND_API void shutdown_memory_manager(int silent, int clean_cache);
+
+#if ZEND_DEBUG
+ZEND_API int _mem_block_check(void *ptr, int silent ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
+ZEND_API void _full_mem_check(int silent ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
+void zend_debug_alloc_output(char *format, ...);
+#define mem_block_check(ptr, silent) _mem_block_check(ptr, silent ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
+#define full_mem_check(silent) _full_mem_check(silent ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
+#else
+#define mem_block_check(type, ptr, silent)
+#define full_mem_check(silent)
+#endif
+
+
+END_EXTERN_C()
+
+#endif
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */

Zend/zend_builtin_functions.h

@@ -0,0 +1,26 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_BUILTIN_FUNCTIONS_H
+#define ZEND_BUILTIN_FUNCTIONS_H
+
+int zend_startup_builtin_functions(void);
+
+#endif /* ZEND_BUILTIN_FUNCTIONS_H */

Zend/zend_compile.h

@@ -0,0 +1,634 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_COMPILE_H
+#define ZEND_COMPILE_H
+
+#include "zend.h"
+
+#ifdef HAVE_STDARG_H
+# include <stdarg.h>
+#endif
+
+#ifdef __cplusplus
+#include <istream.h>
+#endif
+
+#include "zend_llist.h"
+
+#define DEBUG_ZEND 0
+
+#ifndef ZTS
+# define SUPPORT_INTERACTIVE 1
+#else
+# define SUPPORT_INTERACTIVE 0
+#endif
+
+#define FREE_PNODE(znode)	zval_dtor(&znode->u.constant);
+#define FREE_OP(op, should_free) if (should_free) zval_dtor(&Ts[(op)->u.var].tmp_var);
+
+#define SET_UNUSED(op)  (op).op_type = IS_UNUSED
+
+#if SUPPORT_INTERACTIVE
+#define INC_BPC(op_array)	((op_array)->backpatch_count++)
+#define DEC_BPC(op_array)	((op_array)->backpatch_count--)
+#define HANDLE_INTERACTIVE()  if (EG(interactive)) { execute_new_code(CLS_C); }
+#else
+#define INC_BPC(op_array)
+#define DEC_BPC(op_array)
+#define HANDLE_INTERACTIVE()
+#endif
+
+typedef struct _zend_op_array zend_op_array;
+
+typedef struct _znode {
+	int op_type;
+	union {
+		zval constant;
+
+		zend_uint var;
+		zend_uint opline_num; /*  Needs to be signed */
+		zend_uint fetch_type;
+		zend_op_array *op_array;
+		struct {
+			zend_uint var;	/* dummy */
+			zend_uint type;
+		} EA;
+	} u;
+} znode;
+
+
+typedef struct _zend_op {
+	zend_uchar opcode;
+	znode result;
+	znode op1;
+	znode op2;
+	ulong extended_value;
+	uint lineno;
+} zend_op;
+
+
+typedef struct _zend_brk_cont_element {
+	int cont;
+	int brk;
+	int parent;
+} zend_brk_cont_element;
+
+
+struct _zend_op_array {
+	zend_uchar type;	/* MUST be the first element of this struct! */
+
+	zend_uchar *arg_types;		/* MUST be the second element of this struct! */
+	char *function_name;			/* MUST be the third element of this struct! */
+
+	zend_uint *refcount;
+
+	zend_op *opcodes;
+	zend_uint last, size;
+
+	zend_uint T;
+
+	zend_brk_cont_element *brk_cont_array;
+	zend_uint last_brk_cont;
+	zend_uint current_brk_cont;
+	zend_bool uses_globals;
+
+	/* static variables support */
+	HashTable *static_variables;
+
+#if SUPPORT_INTERACTIVE
+	int start_op_number, end_op_number;
+	int last_executed_op_number;
+	int backpatch_count;
+#endif
+	zend_bool return_reference;
+	zend_bool done_pass_two;
+
+	char *filename;
+
+	void *reserved[ZEND_MAX_RESERVED_RESOURCES];
+};
+
+
+typedef struct _zend_internal_function {
+	zend_uchar type;	/* MUST be the first element of this struct! */
+
+	zend_uchar *arg_types;		/* MUST be the second element of this struct */
+	char *function_name;			/* MUST be the third element of this struct */
+
+	void (*handler)(INTERNAL_FUNCTION_PARAMETERS);
+} zend_internal_function;
+
+
+typedef struct _zend_overloaded_function {
+	zend_uchar type;	/* MUST be the first element of this struct! */
+
+	zend_uchar *arg_types;		/* MUST be the second element of this struct */
+	char *function_name;		/* MUST be the third element of this struct */
+
+	zend_uint var;
+} zend_overloaded_function;
+
+
+typedef union _zend_function {
+	zend_uchar type;	/* MUST be the first element of this struct! */
+	struct {
+		zend_uchar type;  /* never used */
+		zend_uchar *arg_types;
+		char *function_name;
+	} common;
+	
+	zend_op_array op_array;
+	zend_internal_function internal_function;
+	zend_overloaded_function overloaded_function;
+} zend_function;
+
+
+typedef struct _zend_function_state {
+	HashTable *function_symbol_table;
+	zend_function *function;
+	void *reserved[ZEND_MAX_RESERVED_RESOURCES];
+} zend_function_state;
+
+
+typedef struct _zend_switch_entry {
+	znode cond;
+	int default_case;
+	int control_var;
+} zend_switch_entry;
+
+
+typedef struct _list_llist_element {
+	znode var;
+	zend_llist dimensions;
+	znode value;
+} list_llist_element;
+
+
+typedef struct _zend_file_handle {
+	zend_uchar type;
+	char *filename;
+	char *opened_path;
+	union {
+		int fd;
+		FILE *fp;
+#ifdef __cplusplus
+		istream *is;
+#endif
+	} handle;
+	zend_bool free_filename;
+} zend_file_handle;
+
+
+
+#define IS_CONST	(1<<0)
+#define IS_TMP_VAR	(1<<1)
+#define IS_VAR		(1<<2)
+#define IS_UNUSED	(1<<3)	/* Unused variable */
+
+
+#define EXT_TYPE_UNUSED		(1<<0)
+
+#include "zend_globals.h"
+
+BEGIN_EXTERN_C()
+
+void init_compiler(CLS_D ELS_DC);
+void shutdown_compiler(CLS_D);
+
+extern ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type CLS_DC);
+
+void zend_activate(CLS_D ELS_DC);
+void zend_deactivate(CLS_D ELS_DC);
+void zend_activate_modules(void);
+void zend_deactivate_modules(void);
+
+
+int lex_scan(zval *zendlval CLS_DC);
+void startup_scanner(CLS_D);
+void shutdown_scanner(CLS_D);
+
+ZEND_API char *zend_set_compiled_filename(char *new_compiled_filename);
+ZEND_API void zend_restore_compiled_filename(char *original_compiled_filename);
+ZEND_API char *zend_get_compiled_filename(CLS_D);
+ZEND_API int zend_get_compiled_lineno(CLS_D);
+
+#ifdef ZTS
+const char *zend_get_zendtext(CLS_D);
+int zend_get_zendleng(CLS_D);
+#endif
+
+
+/* parser-driven code generators */
+void zend_do_binary_op(int op, znode *result, znode *op1, znode *op2 CLS_DC);
+void zend_do_unary_op(int op, znode *result, znode *op1 CLS_DC);
+void zend_do_binary_assign_op(int op, znode *result, znode *op1, znode *op2 CLS_DC);
+void zend_do_assign(znode *result, znode *variable, znode *value CLS_DC);
+void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar CLS_DC);
+void fetch_simple_variable(znode *result, znode *varname, int bp CLS_DC);
+void fetch_simple_variable_ex(znode *result, znode *varname, int bp, int op CLS_DC);
+void zend_do_indirect_references(znode *result, znode *num_references, znode *variable CLS_DC);
+void zend_do_fetch_global_or_static_variable(znode *varname, znode *static_assignment, int fetch_type CLS_DC);
+void zend_do_fetch_globals(znode *varname CLS_DC);
+
+void fetch_array_begin(znode *result, znode *varname, znode *first_dim CLS_DC);
+void fetch_array_dim(znode *result, znode *parent, znode *dim CLS_DC);
+void fetch_string_offset(znode *result, znode *parent, znode *offset CLS_DC);
+void zend_do_print(znode *result, znode *arg CLS_DC);
+void zend_do_echo(znode *arg CLS_DC);
+typedef int (*unary_op_type)(zval *, zval *);
+ZEND_API unary_op_type get_unary_op(int opcode);
+ZEND_API void *get_binary_op(int opcode);
+
+void zend_do_while_cond(znode *expr, znode *close_bracket_token CLS_DC);
+void zend_do_while_end(znode *while_token, znode *close_bracket_token CLS_DC);
+void zend_do_do_while_begin(CLS_D);
+void zend_do_do_while_end(znode *do_token, znode *expr_open_bracket, znode *expr CLS_DC);
+
+
+void zend_do_if_cond(znode *cond, znode *closing_bracket_token CLS_DC);
+void zend_do_if_after_statement(znode *closing_bracket_token, unsigned char initialize CLS_DC);
+void zend_do_if_end(CLS_D);
+
+void zend_do_for_cond(znode *expr, znode *second_semicolon_token CLS_DC);
+void zend_do_for_before_statement(znode *cond_start, znode *second_semicolon_token CLS_DC);
+void zend_do_for_end(znode *second_semicolon_token CLS_DC);
+
+void zend_do_pre_incdec(znode *result, znode *op1, int op CLS_DC);
+void zend_do_post_incdec(znode *result, znode *op1, int op CLS_DC);
+
+void zend_do_begin_variable_parse(CLS_D);
+void zend_do_end_variable_parse(int type, int arg_offset CLS_DC);
+
+void zend_do_free(znode *op1 CLS_DC);
+
+void zend_do_init_string(znode *result CLS_DC);
+void zend_do_add_char(znode *result, znode *op1, znode *op2 CLS_DC);
+void zend_do_add_string(znode *result, znode *op1, znode *op2 CLS_DC);
+void zend_do_add_variable(znode *result, znode *op1, znode *op2 CLS_DC);
+
+void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference CLS_DC);
+void zend_do_end_function_declaration(znode *function_token CLS_DC);
+void zend_do_receive_arg(int op, znode *var, znode *offset, znode *initialization, unsigned char pass_type CLS_DC);
+int zend_do_begin_function_call(znode *function_name CLS_DC);
+void zend_do_begin_dynamic_function_call(znode *function_name CLS_DC);
+void zend_do_begin_class_member_function_call(znode *class_name, znode *function_name CLS_DC);
+void zend_do_end_function_call(znode *function_name, znode *result, znode *argument_list, int is_method, int is_dynamic_fcall CLS_DC);
+void zend_do_return(znode *expr, int do_end_vparse CLS_DC);
+ZEND_API int do_bind_function_or_class(zend_op *opline, HashTable *function_table, HashTable *class_table, int compile_time);
+void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce);
+void zend_do_early_binding(CLS_D);
+
+void zend_do_pass_param(znode *param, int op, int offset CLS_DC);
+
+
+void zend_do_boolean_or_begin(znode *expr1, znode *op_token CLS_DC);
+void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, znode *op_token CLS_DC);
+void zend_do_boolean_and_begin(znode *expr1, znode *op_token CLS_DC);               
+void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, znode *op_token CLS_DC);
+
+void zend_do_brk_cont(int op, znode *expr CLS_DC);
+
+void zend_do_switch_cond(znode *cond CLS_DC);
+void zend_do_switch_end(znode *case_list CLS_DC);
+void zend_do_case_before_statement(znode *case_list, znode *case_token, znode *case_expr CLS_DC);
+void zend_do_case_after_statement(znode *result, znode *case_token CLS_DC);
+void zend_do_default_before_statement(znode *case_list, znode *default_token CLS_DC);
+
+void zend_do_begin_class_declaration(znode *class_name, znode *parent_class_name CLS_DC);
+void zend_do_end_class_declaration(CLS_D);
+void zend_do_declare_property(znode *var_name, znode *value CLS_DC);
+
+void zend_do_fetch_property(znode *result, znode *object, znode *property CLS_DC);
+
+
+void zend_do_push_object(znode *object CLS_DC);
+void zend_do_pop_object(znode *object CLS_DC);
+
+
+void zend_do_begin_new_object(znode *new_token, znode *class_name CLS_DC);
+void zend_do_end_new_object(znode *result, znode *class_name, znode *new_token, znode *argument_list CLS_DC);
+
+void zend_do_fetch_constant(znode *result, znode *constant_name, int mode CLS_DC);
+
+void zend_do_shell_exec(znode *result, znode *cmd CLS_DC);
+
+void zend_do_init_array(znode *result, znode *expr, znode *offset, int is_ref CLS_DC);
+void zend_do_add_array_element(znode *result, znode *expr, znode *offset, int is_ref CLS_DC);
+void zend_do_add_static_array_element(znode *result, znode *offset, znode *expr);
+void zend_do_list_init(CLS_D);
+void zend_do_list_end(znode *result, znode *expr CLS_DC);
+void zend_do_add_list_element(znode *element CLS_DC);
+void zend_do_new_list_begin(CLS_D);
+void zend_do_new_list_end(CLS_D);
+
+void zend_do_cast(znode *result, znode *expr, int type CLS_DC);
+void zend_do_include_or_eval(int type, znode *result, znode *op1 CLS_DC);
+
+void zend_do_unset(znode *variable CLS_DC);
+void zend_do_isset_or_isempty(int type, znode *result, znode *variable CLS_DC);
+
+void zend_do_foreach_begin(znode *foreach_token, znode *array, znode *open_brackets_token, znode *as_token, int variable CLS_DC);
+void zend_do_foreach_cont(znode *value, znode *key, znode *as_token CLS_DC);
+void zend_do_foreach_end(znode *foreach_token, znode *open_brackets_token CLS_DC);
+
+void zend_do_declare_begin(CLS_D);
+void zend_do_declare_stmt(znode *var, znode *val CLS_DC);
+void zend_do_declare_end(CLS_D);
+
+void zend_do_end_heredoc(CLS_D);
+
+void zend_do_exit(znode *result, znode *message CLS_DC);
+
+void zend_do_begin_silence(znode *strudel_token CLS_DC);
+void zend_do_end_silence(znode *strudel_token CLS_DC);
+
+void zend_do_begin_qm_op(znode *cond, znode *qm_token CLS_DC);
+void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token CLS_DC);
+void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, znode *colon_token CLS_DC);
+
+void zend_do_extended_info(CLS_D);
+void zend_do_extended_fcall_begin(CLS_D);
+void zend_do_extended_fcall_end(CLS_D);
+
+void zend_do_ticks(CLS_D);
+
+ZEND_API void function_add_ref(zend_function *function);
+
+#define INITIAL_OP_ARRAY_SIZE 64
+
+
+/* helper functions in zend_language_scanner.l */
+ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type CLS_DC);
+ZEND_API zend_op_array *compile_string(zval *source_string, char *filename CLS_DC);	
+ZEND_API zend_op_array *compile_filename(int type, zval *filename CLS_DC ELS_DC);
+ZEND_API int zend_execute_scripts(int type CLS_DC ELS_DC, int file_count, ...);
+ZEND_API int open_file_for_scanning(zend_file_handle *file_handle CLS_DC);
+ZEND_API void init_op_array(zend_op_array *op_array, int type, int initial_ops_size CLS_DC);
+ZEND_API void destroy_op_array(zend_op_array *op_array);
+ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle CLS_DC);
+ZEND_API void zend_file_handle_dtor(zend_file_handle *fh);
+
+ZEND_API void destroy_zend_function(zend_function *function);
+ZEND_API void destroy_zend_class(zend_class_entry *ce);
+void zend_class_add_ref(zend_class_entry *ce);
+
+#define ZEND_FUNCTION_DTOR (void (*)(void *)) destroy_zend_function
+#define ZEND_CLASS_DTOR (void (*)(void *)) destroy_zend_class
+
+zend_op *get_next_op(zend_op_array *op_array CLS_DC);
+void init_op(zend_op *op CLS_DC);
+int get_next_op_number(zend_op_array *op_array);
+int print_class(zend_class_entry *class_entry);
+void print_op_array(zend_op_array *op_array, int optimizations);
+int pass_two(zend_op_array *op_array);
+zend_brk_cont_element *get_next_brk_cont_element(zend_op_array *op_array);
+ZEND_API zend_bool zend_is_compiling(void);
+ZEND_API char *zend_make_compiled_string_description(char *name);
+
+int zendlex(znode *zendlval CLS_DC);
+
+#define ZEND_NOP					0
+									
+#define ZEND_ADD					1
+#define ZEND_SUB					2
+#define ZEND_MUL					3
+#define ZEND_DIV					4
+#define ZEND_MOD					5
+#define ZEND_SL						6
+#define ZEND_SR						7
+#define ZEND_CONCAT					8
+#define ZEND_BW_OR					9
+#define ZEND_BW_AND					10
+#define ZEND_BW_XOR					11
+#define ZEND_BW_NOT					12
+#define ZEND_BOOL_NOT				13
+#define ZEND_BOOL_XOR				14
+#define ZEND_IS_IDENTICAL			15
+#define ZEND_IS_NOT_IDENTICAL       16
+#define ZEND_IS_EQUAL				17
+#define ZEND_IS_NOT_EQUAL			18
+#define ZEND_IS_SMALLER				19
+#define ZEND_IS_SMALLER_OR_EQUAL	20
+#define ZEND_CAST					21
+#define ZEND_QM_ASSIGN				22
+
+#define ZEND_ASSIGN_ADD				23
+#define ZEND_ASSIGN_SUB				24
+#define ZEND_ASSIGN_MUL				25
+#define ZEND_ASSIGN_DIV				26
+#define ZEND_ASSIGN_MOD				27
+#define ZEND_ASSIGN_SL				28
+#define ZEND_ASSIGN_SR				29
+#define ZEND_ASSIGN_CONCAT			30
+#define ZEND_ASSIGN_BW_OR			31
+#define ZEND_ASSIGN_BW_AND			32
+#define ZEND_ASSIGN_BW_XOR			33
+									
+#define ZEND_PRE_INC				34
+#define ZEND_PRE_DEC				35
+#define ZEND_POST_INC				36
+#define ZEND_POST_DEC				37
+								 	
+#define ZEND_ASSIGN					38
+#define ZEND_ASSIGN_REF				39
+
+#define ZEND_ECHO					40
+#define ZEND_PRINT					41
+
+#define ZEND_JMP					42
+#define ZEND_JMPZ					43
+#define ZEND_JMPNZ					44
+#define ZEND_JMPZNZ					45
+#define ZEND_JMPZ_EX				46
+#define ZEND_JMPNZ_EX				47
+#define ZEND_CASE					48
+#define ZEND_SWITCH_FREE			49
+#define ZEND_BRK					50
+#define ZEND_CONT					51
+#define ZEND_BOOL					52
+
+#define ZEND_INIT_STRING			53
+#define ZEND_ADD_CHAR				54
+#define ZEND_ADD_STRING				55
+#define ZEND_ADD_VAR				56
+
+#define ZEND_BEGIN_SILENCE			57
+#define ZEND_END_SILENCE			58
+
+#define ZEND_INIT_FCALL_BY_NAME		59
+#define ZEND_DO_FCALL				60
+#define ZEND_DO_FCALL_BY_NAME		61
+#define ZEND_RETURN					62
+
+#define ZEND_RECV					63
+#define ZEND_RECV_INIT				64
+									
+#define ZEND_SEND_VAL				65
+#define ZEND_SEND_VAR				66
+#define ZEND_SEND_REF				67
+
+#define ZEND_NEW 					68
+#define ZEND_JMP_NO_CTOR			69
+#define ZEND_FREE					70
+									
+#define ZEND_INIT_ARRAY				71
+#define ZEND_ADD_ARRAY_ELEMENT		72
+									
+#define ZEND_INCLUDE_OR_EVAL		73
+									
+#define ZEND_UNSET_VAR				74
+#define ZEND_UNSET_DIM_OBJ			75
+#define ZEND_ISSET_ISEMPTY			76
+									
+#define ZEND_FE_RESET				77
+#define ZEND_FE_FETCH				78
+									
+#define ZEND_EXIT					79
+
+
+/* the following 18 opcodes are 6 groups of 3 opcodes each, and must
+ * remain in that order!
+ */
+#define ZEND_FETCH_R				80
+#define ZEND_FETCH_DIM_R			81
+#define ZEND_FETCH_OBJ_R			82
+#define ZEND_FETCH_W				83
+#define ZEND_FETCH_DIM_W			84
+#define ZEND_FETCH_OBJ_W			85
+#define ZEND_FETCH_RW				86
+#define ZEND_FETCH_DIM_RW			87
+#define ZEND_FETCH_OBJ_RW			88
+#define ZEND_FETCH_IS				89
+#define ZEND_FETCH_DIM_IS			90
+#define ZEND_FETCH_OBJ_IS			91
+#define ZEND_FETCH_FUNC_ARG			92
+#define ZEND_FETCH_DIM_FUNC_ARG		93
+#define ZEND_FETCH_OBJ_FUNC_ARG		94
+#define ZEND_FETCH_UNSET			95
+#define ZEND_FETCH_DIM_UNSET		96
+#define ZEND_FETCH_OBJ_UNSET		97
+
+#define ZEND_FETCH_DIM_TMP_VAR		98
+#define ZEND_FETCH_CONSTANT			99
+
+#define ZEND_DECLARE_FUNCTION_OR_CLASS	100
+
+#define ZEND_EXT_STMT				101
+#define ZEND_EXT_FCALL_BEGIN		102
+#define ZEND_EXT_FCALL_END			103
+#define ZEND_EXT_NOP				104
+
+#define ZEND_TICKS					105
+
+#define ZEND_SEND_VAR_NO_REF		106
+
+/* end of block */
+
+
+
+
+/* global/local fetches */
+#define ZEND_FETCH_GLOBAL	0
+#define ZEND_FETCH_LOCAL	1
+#define ZEND_FETCH_STATIC	2
+
+/* var status for backpatching */
+#define BP_VAR_R			0
+#define BP_VAR_W			1
+#define BP_VAR_RW			2
+#define BP_VAR_IS			3
+#define BP_VAR_NA			4	/* if not applicable */
+#define BP_VAR_FUNC_ARG		5
+#define BP_VAR_UNSET		6
+
+
+#define ZEND_INTERNAL_FUNCTION		1
+#define ZEND_USER_FUNCTION			2
+#define ZEND_OVERLOADED_FUNCTION	3
+#define	ZEND_EVAL_CODE				4
+
+#define ZEND_INTERNAL_CLASS		1
+#define ZEND_USER_CLASS			2
+
+#define ZEND_EVAL				(1<<0)
+#define ZEND_INCLUDE			(1<<1)
+#define ZEND_INCLUDE_ONCE		(1<<2)
+#define ZEND_REQUIRE			(1<<3)
+#define ZEND_REQUIRE_ONCE		(1<<4)
+
+#define ZEND_ISSET				(1<<0)
+#define ZEND_ISEMPTY			(1<<1)
+
+#define ZEND_CT	(1<<0)
+#define ZEND_RT (1<<1)
+
+
+#define ZEND_HANDLE_FILENAME		0
+#define ZEND_HANDLE_FD				1
+#define ZEND_HANDLE_FP				2
+#define ZEND_HANDLE_STDIOSTREAM		3
+#define ZEND_HANDLE_FSTREAM			4
+
+#define ZEND_DECLARE_CLASS				1
+#define ZEND_DECLARE_FUNCTION			2
+#define ZEND_DECLARE_INHERITED_CLASS	3
+
+#define ZEND_FETCH_STANDARD		0
+#define ZEND_FETCH_ADD_LOCK		1
+
+#define ZEND_MEMBER_FUNC_CALL	1<<0
+#define ZEND_CTOR_CALL			1<<1
+
+#define ZEND_ARG_SEND_BY_REF (1<<0)
+#define ZEND_ARG_COMPILE_TIME_BOUND (1<<1)
+
+#define AI_USE_PTR(ai) \
+	if ((ai).ptr_ptr) { \
+		(ai).ptr = *((ai).ptr_ptr); \
+		(ai).ptr_ptr = &((ai).ptr); \
+	} else { \
+		(ai).ptr = NULL; \
+	}
+
+/* Lost In Stupid Parentheses */
+#define ARG_SHOULD_BE_SENT_BY_REF(offset, conduct_check, arg_types)	\
+	(																\
+		conduct_check												\
+		&& arg_types												\
+		&&															\
+		(															\
+			(														\
+				offset<=arg_types[0]								\
+				&& arg_types[offset]==BYREF_FORCE					\
+			)														\
+		||	(														\
+				offset>=arg_types[0]								\
+				&& arg_types[arg_types[0]]==BYREF_FORCE_REST		\
+			)														\
+		)															\
+	)
+
+#define ZEND_RETURN_VAL 0
+#define ZEND_RETURN_REF 1
+
+END_EXTERN_C()
+
+#endif /* ZEND_COMPILE_H */

Zend/zend_config.w32.h

@@ -0,0 +1,86 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_CONFIG_W32_H
+#define ZEND_CONFIG_W32_H
+
+
+#include <string.h>
+#include <windows.h>
+#include <float.h>
+
+typedef unsigned long ulong;
+typedef unsigned int uint;
+
+#define HAVE_ALLOCA 1
+#define HAVE_LIMITS_H 1
+#include <malloc.h>
+
+#undef HAVE_KILL
+#define HAVE_GETPID 1
+/* #define HAVE_ALLOCA_H 1 */
+#define HAVE_MEMCPY 1
+#define HAVE_STRDUP 1
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_STDIOSTR_H 1
+#define HAVE_CLASS_ISTDIOSTREAM
+#define istdiostream stdiostream
+#define HAVE_STDARG_H	1
+#define HAVE_SNPRINTF	1
+#define HAVE_VSNPRINTF	1
+
+#define vsnprintf _vsnprintf
+#define zend_isinf(a)	0
+
+#define zend_sprintf sprintf
+
+/* This will cause the compilation process to be MUCH longer, but will generate
+ * a much quicker PHP binary
+ */
+#undef inline
+#ifdef ZEND_WIN32_FORCE_INLINE
+# define inline __forceinline
+#else
+# define inline
+#endif
+
+#define zend_finite(A) _finite(A)
+#define zend_isnan(A) _isnan(A)
+
+#ifdef LIBZEND_EXPORTS
+#	define ZEND_API __declspec(dllexport)
+#else
+#	define ZEND_API __declspec(dllimport)
+#endif
+
+#define ZEND_DLEXPORT		__declspec(dllexport)
+
+/* 0x00200000L is MB_SERVICE_NOTIFICATION, which is only supported under Windows NT 
+ * (and requires _WIN32_WINNT to be defined, which prevents the resulting executable
+ * from running under Windows 9x
+ * Windows 9x should silently ignore it, so it's being used here directly
+ */
+#ifndef MB_SERVICE_NOTIFICATION
+#define	MB_SERVICE_NOTIFICATION		0x00200000L
+#endif
+
+#define ZEND_SERVICE_MB_STYLE		(MB_TOPMOST|MB_SERVICE_NOTIFICATION)
+
+#endif /* ZEND_CONFIG_W32_H */

Zend/zend_constants.c

@@ -0,0 +1,267 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#include "zend.h"
+#include "zend_constants.h"
+#include "zend_variables.h"
+#include "zend_operators.h"
+#include "zend_globals.h"
+
+
+void free_zend_constant(zend_constant *c)
+{
+	if (!(c->flags & CONST_PERSISTENT)) {
+		zval_dtor(&c->value);
+	}
+	free(c->name);
+}
+
+
+void copy_zend_constant(zend_constant *c)
+{
+	c->name = zend_strndup(c->name, c->name_len);
+	if (!(c->flags & CONST_PERSISTENT)) {
+		zval_copy_ctor(&c->value);
+	}
+}
+
+
+void zend_copy_constants(HashTable *target, HashTable *source)
+{
+	zend_constant tmp_constant;
+
+	zend_hash_copy(target, source, (copy_ctor_func_t) copy_zend_constant, &tmp_constant, sizeof(zend_constant));
+}
+
+
+static int clean_non_persistent_constant(zend_constant *c)
+{
+	if (c->flags & CONST_PERSISTENT) {
+		return 0;
+	} else {
+		return 1;
+	}
+}
+
+
+static int clean_module_constant(zend_constant *c, int *module_number)
+{
+	if (c->module_number == *module_number) {
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+
+void clean_module_constants(int module_number)
+{
+	ELS_FETCH();
+
+	zend_hash_apply_with_argument(EG(zend_constants), (int (*)(void *,void *)) clean_module_constant, (void *) &module_number);
+}
+
+
+int zend_startup_constants(ELS_D)
+{
+#ifdef ZEND_WIN32
+	DWORD dwBuild=0;
+	DWORD dwVersion = GetVersion();
+	DWORD dwWindowsMajorVersion =  (DWORD)(LOBYTE(LOWORD(dwVersion)));
+	DWORD dwWindowsMinorVersion =  (DWORD)(HIBYTE(LOWORD(dwVersion)));
+#endif
+
+	EG(zend_constants) = (HashTable *) malloc(sizeof(HashTable));
+
+	if (zend_hash_init(EG(zend_constants), 20, NULL, ZEND_CONSTANT_DTOR, 1)==FAILURE) {
+		return FAILURE;
+	}
+	return SUCCESS;
+}
+
+
+
+void zend_register_standard_constants(ELS_D)
+{
+	REGISTER_MAIN_LONG_CONSTANT("E_ERROR", E_ERROR, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_LONG_CONSTANT("E_WARNING", E_WARNING, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_LONG_CONSTANT("E_PARSE", E_PARSE, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_LONG_CONSTANT("E_NOTICE", E_NOTICE, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_LONG_CONSTANT("E_CORE_ERROR", E_CORE_ERROR, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_LONG_CONSTANT("E_CORE_WARNING", E_CORE_WARNING, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_ERROR", E_COMPILE_ERROR, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_LONG_CONSTANT("E_COMPILE_WARNING", E_COMPILE_WARNING, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_LONG_CONSTANT("E_USER_ERROR", E_USER_ERROR, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_LONG_CONSTANT("E_USER_WARNING", E_USER_WARNING, CONST_PERSISTENT | CONST_CS);
+	REGISTER_MAIN_LONG_CONSTANT("E_USER_NOTICE", E_USER_NOTICE, CONST_PERSISTENT | CONST_CS);
+
+	REGISTER_MAIN_LONG_CONSTANT("E_ALL", E_ALL, CONST_PERSISTENT | CONST_CS);
+
+	/* true/false constants */
+	{
+		zend_constant c;
+	
+		c.value.type = IS_BOOL;
+		c.flags = CONST_PERSISTENT;
+		c.module_number = 0;
+
+		c.name = zend_strndup(ZEND_STRL("TRUE"));
+		c.name_len = sizeof("TRUE");
+		c.value.value.lval = 1;
+		c.value.type = IS_BOOL;
+		zend_register_constant(&c ELS_CC);
+		
+		c.name = zend_strndup(ZEND_STRL("FALSE"));
+		c.name_len = sizeof("FALSE");
+		c.value.value.lval = 0;
+		c.value.type = IS_BOOL;
+		zend_register_constant(&c ELS_CC);
+
+		c.name = zend_strndup(ZEND_STRL("ZEND_THREAD_SAFE"));
+		c.name_len = sizeof("ZEND_THREAD_SAFE");
+		c.value.value.lval = ZTS_V;
+		c.value.type = IS_BOOL;
+		zend_register_constant(&c ELS_CC);
+
+		c.name = zend_strndup(ZEND_STRL("NULL"));
+		c.name_len = sizeof("NULL");
+		c.value.type = IS_NULL;
+		zend_register_constant(&c ELS_CC);
+	}
+}
+
+
+int zend_shutdown_constants(ELS_D)
+{
+	zend_hash_destroy(EG(zend_constants));
+	free(EG(zend_constants));
+	return SUCCESS;
+}
+
+
+void clean_non_persistent_constants(void)
+{
+	ELS_FETCH();
+
+	zend_hash_apply(EG(zend_constants), (int (*)(void *)) clean_non_persistent_constant);
+}
+
+
+ZEND_API void zend_register_long_constant(char *name, uint name_len, long lval, int flags, int module_number ELS_DC)
+{
+	zend_constant c;
+	
+	c.value.type = IS_LONG;
+	c.value.value.lval = lval;
+	c.flags = flags;
+	c.name = zend_strndup(name,name_len);
+	c.name_len = name_len;
+	c.module_number = module_number;
+	zend_register_constant(&c ELS_CC);
+}
+
+
+ZEND_API void zend_register_double_constant(char *name, uint name_len, double dval, int flags, int module_number ELS_DC)
+{
+	zend_constant c;
+	
+	c.value.type = IS_DOUBLE;
+	c.value.value.dval = dval;
+	c.flags = flags;
+	c.name = zend_strndup(name,name_len);
+	c.name_len = name_len;
+	c.module_number = module_number;
+	zend_register_constant(&c ELS_CC);
+}
+
+
+ZEND_API void zend_register_stringl_constant(char *name, uint name_len, char *strval, uint strlen, int flags, int module_number ELS_DC)
+{
+	zend_constant c;
+	
+	c.value.type = IS_STRING;
+	c.value.value.str.val = strval;
+	c.value.value.str.len = strlen;
+	c.flags = flags;
+	c.name = zend_strndup(name,name_len);
+	c.name_len = name_len;
+	c.module_number = module_number;
+	zend_register_constant(&c ELS_CC);
+}
+
+
+ZEND_API void zend_register_string_constant(char *name, uint name_len, char *strval, int flags, int module_number ELS_DC)
+{
+	zend_register_stringl_constant(name, name_len, strval, strlen(strval), flags, module_number ELS_CC);
+}
+
+
+ZEND_API int zend_get_constant(char *name, uint name_len, zval *result)
+{
+	zend_constant *c;
+	char *lookup_name = estrndup(name,name_len);
+	int retval;
+	ELS_FETCH();
+
+	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) {
+			retval=0;
+		} else {
+			retval=1;
+			*result = c->value;
+			zval_copy_ctor(result);
+		}
+	} else {
+		retval=0;
+	}
+	
+	efree(lookup_name);
+	return retval;
+}
+
+
+ZEND_API int zend_register_constant(zend_constant *c ELS_DC)
+{
+	char *lowercase_name = zend_strndup(c->name, c->name_len);
+	int ret = SUCCESS;
+
+#if 0
+	printf("Registering constant for module %d\n",c->module_number);
+#endif
+
+	zend_str_tolower(lowercase_name, c->name_len);
+	if (zend_hash_add(EG(zend_constants), lowercase_name, c->name_len, (void *) c, sizeof(zend_constant), NULL)==FAILURE) {
+		zval_dtor(&c->value);
+		zend_error(E_NOTICE,"Constant %s already defined",lowercase_name);
+		ret = FAILURE;
+	}
+	free(lowercase_name);
+	return ret;
+}
+
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */

Zend/zend_constants.h

@@ -0,0 +1,64 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_CONSTANTS_H
+#define ZEND_CONSTANTS_H
+
+#include "zend_globals.h"
+
+#define CONST_CS 0x1				/* Case Sensitive */
+#define CONST_PERSISTENT 0x2
+
+typedef struct _zend_constant {
+	zval value;
+	int flags;
+	char *name;
+	uint name_len;
+	int module_number;
+} zend_constant;
+
+#define REGISTER_LONG_CONSTANT(name,lval,flags)  zend_register_long_constant((name),sizeof(name),(lval),(flags),module_number ELS_CC)
+#define REGISTER_DOUBLE_CONSTANT(name,dval,flags)  zend_register_double_constant((name),sizeof(name),(dval),(flags),module_number ELS_CC)
+#define REGISTER_STRING_CONSTANT(name,str,flags)  zend_register_string_constant((name),sizeof(name),(str),(flags),module_number ELS_CC)
+#define REGISTER_STRINGL_CONSTANT(name,str,len,flags)  zend_register_stringl_constant((name),sizeof(name),(str),(len),(flags),module_number ELS_CC)
+
+#define REGISTER_MAIN_LONG_CONSTANT(name,lval,flags)  zend_register_long_constant((name),sizeof(name),(lval),(flags),0 ELS_CC)
+#define REGISTER_MAIN_DOUBLE_CONSTANT(name,dval,flags)  zend_register_double_constant((name),sizeof(name),(dval),(flags),0 ELS_CC)
+#define REGISTER_MAIN_STRING_CONSTANT(name,str,flags)  zend_register_string_constant((name),sizeof(name),(str),(flags),0 ELS_CC)
+#define REGISTER_MAIN_STRINGL_CONSTANT(name,str,len,flags)  zend_register_stringl_constant((name),sizeof(name),(str),(len),(flags),0 ELS_CC)
+
+void clean_module_constants(int module_number);
+void free_zend_constant(zend_constant *c);
+int zend_startup_constants(ELS_D);
+int zend_shutdown_constants(ELS_D);
+void zend_register_standard_constants(ELS_D);
+void clean_non_persistent_constants(void);
+ZEND_API int zend_get_constant(char *name, uint name_len, zval *result);
+ZEND_API void zend_register_long_constant(char *name, uint name_len, long lval, int flags, int module_number ELS_DC);
+ZEND_API void zend_register_double_constant(char *name, uint name_len, double dval, int flags, int module_number ELS_DC);
+ZEND_API void zend_register_string_constant(char *name, uint name_len, char *strval, int flags, int module_number ELS_DC);
+ZEND_API void zend_register_stringl_constant(char *name, uint name_len, char *strval, uint strlen, int flags, int module_number ELS_DC);
+ZEND_API int zend_register_constant(zend_constant *c ELS_DC);
+void zend_copy_constants(HashTable *target, HashTable *sourc);
+void copy_zend_constant(zend_constant *c);
+
+#define ZEND_CONSTANT_DTOR (void (*)(void *)) free_zend_constant
+
+#endif

Zend/zend_dynamic_array.c

@@ -0,0 +1,62 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+#include "zend.h"
+
+typedef struct _dynamic_array {
+        char *array;
+        unsigned int element_size;
+        unsigned int current;
+        unsigned int allocated;
+} dynamic_array;
+
+ZEND_API int zend_dynamic_array_init(dynamic_array *da, unsigned int element_size, unsigned int size)
+{
+	da->element_size = element_size;
+	da->allocated = size;
+	da->current = 0;
+	da->array = (char *) emalloc(size*element_size);
+	if (da->array == NULL) {
+		return 1;
+	}
+	return 0;
+}
+
+ZEND_API void *zend_dynamic_array_push(dynamic_array *da)
+{
+	if (da->current == da->allocated) {
+		da->allocated *= 2;
+		da->array = (char *) erealloc(da->array, da->allocated*da->element_size);
+	}
+	return (void *)(da->array+(da->current++)*da->element_size);
+}
+
+ZEND_API void *zend_dynamic_array_pop(dynamic_array *da)
+{
+	return (void *)(da->array+(--(da->current))*da->element_size);
+
+}
+
+ZEND_API void *zend_dynamic_array_get_element(dynamic_array *da, unsigned int index)
+{
+	if (index >= da->current) {
+		return NULL;
+	}
+	return (void *)(da->array+index*da->element_size);
+}

Zend/zend_dynamic_array.h

@@ -0,0 +1,38 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_DYNAMIC_ARRAY_H
+#define ZEND_DYNAMIC_ARRAY_H
+
+typedef struct _dynamic_array {
+	char *array;
+	unsigned int element_size;
+	unsigned int last_used;
+	unsigned int allocated;
+} dynamic_array;
+
+BEGIN_EXTERN_C()
+ZEND_API int zend_dynamic_array_init(dynamic_array *da);
+ZEND_API void *zend_dynamic_array_push(dynamic_array *da);
+ZEND_API void *zend_dynamic_array_pop(dynamic_array *da);
+ZEND_API void *zend_dynamic_array_get_element(dynamic_array *da, unsigned int index);
+END_EXTERN_C()
+
+#endif /* ZEND_DYNAMIC_ARRAY_H */

Zend/zend_errors.h

@@ -0,0 +1,40 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_ERRORS_H
+#define ZEND_ERRORS_H
+
+#define E_ERROR				(1<<0L)
+#define E_WARNING			(1<<1L)
+#define E_PARSE				(1<<2L)
+#define E_NOTICE			(1<<3L)
+#define E_CORE_ERROR		(1<<4L)
+#define E_CORE_WARNING		(1<<5L)
+#define E_COMPILE_ERROR		(1<<6L)
+#define E_COMPILE_WARNING	(1<<7L)
+#define E_USER_ERROR		(1<<8L)
+#define E_USER_WARNING		(1<<9L)
+#define E_USER_NOTICE		(1<<10L)
+
+#define E_ALL (E_ERROR | E_WARNING | E_PARSE | E_NOTICE | E_CORE_ERROR | E_CORE_WARNING | E_COMPILE_ERROR | E_COMPILE_WARNING | E_USER_ERROR | E_USER_WARNING | E_USER_NOTICE)
+#define E_CORE (E_CORE_ERROR | E_CORE_WARNING)
+
+#endif /* ZEND_ERRORS_H */
+

Zend/zend_execute.h

@@ -0,0 +1,213 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_EXECUTE_H
+#define ZEND_EXECUTE_H
+
+#include "zend_compile.h"
+#include "zend_hash.h"
+#include "zend_variables.h"
+#include "zend_execute_locks.h"
+
+typedef union _temp_variable {
+	zval tmp_var;
+	struct {
+		zval **ptr_ptr;
+		zval *ptr;
+	} var;
+	struct {
+		zval tmp_var; /* a dummy */
+
+		union {
+			struct {
+				zval *str;
+				int offset;
+			} str_offset;
+			zend_property_reference overloaded_element;
+		} data;
+			
+		unsigned char type;
+	} EA;
+} temp_variable;
+
+
+ZEND_API extern void (*zend_execute)(zend_op_array *op_array ELS_DC);
+
+void init_executor(CLS_D ELS_DC);
+void shutdown_executor(ELS_D);
+void execute(zend_op_array *op_array ELS_DC);
+ZEND_API int zend_is_true(zval *op);
+static inline void safe_free_zval_ptr(zval *p)
+{
+	ELS_FETCH();
+
+	if (p!=EG(uninitialized_zval_ptr)) {
+		FREE_ZVAL(p);
+	}
+}
+
+ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name CLS_DC ELS_DC);
+static inline int i_zend_is_true(zval *op)
+{
+	int result;
+
+	switch (op->type) {
+		case IS_NULL:
+			result = 0;
+			break;
+		case IS_LONG:
+		case IS_BOOL:
+		case IS_RESOURCE:
+			result = (op->value.lval?1:0);
+			break;
+		case IS_DOUBLE:
+			result = (op->value.dval ? 1 : 0);
+			break;
+		case IS_STRING:
+			if (op->value.str.len == 0
+				|| (op->value.str.len==1 && op->value.str.val[0]=='0')) {
+				result = 0;
+			} else {
+				result = 1;
+			}
+			break;
+		case IS_ARRAY:
+			result = (zend_hash_num_elements(op->value.ht)?1:0);
+			break;
+		case IS_OBJECT:
+			result = (zend_hash_num_elements(op->value.obj.properties)?1:0);
+			break;
+		default:
+			result = 0;
+			break;
+	}
+	return result;
+}
+
+ZEND_API int zval_update_constant(zval **pp, void *arg);
+
+/* dedicated Zend executor functions - do not use! */
+static inline void zend_ptr_stack_clear_multiple(ELS_D)
+{
+	void **p = EG(argument_stack).top_element-2;
+	int delete_count = (ulong) *p;
+
+	EG(argument_stack).top -= (delete_count+2);
+	while (--delete_count>=0) {
+		zval_ptr_dtor((zval **) --p);
+	}
+	EG(argument_stack).top_element = p;
+}
+
+static inline int zend_ptr_stack_get_arg(int requested_arg, void **data ELS_DC)
+{
+	void **p = EG(argument_stack).top_element-2;
+	int arg_count = (ulong) *p;
+
+	if (requested_arg>arg_count) {
+		return FAILURE;
+	}
+	*data = (p-arg_count+requested_arg-1);
+	return SUCCESS;
+}
+
+#if SUPPORT_INTERACTIVE
+void execute_new_code(CLS_D);
+#endif
+
+
+/* services */
+ZEND_API char *get_active_function_name(void);
+ZEND_API char *zend_get_executed_filename(ELS_D);
+ZEND_API uint zend_get_executed_lineno(ELS_D);
+ZEND_API zend_bool zend_is_executing(void);
+
+ZEND_API void zend_set_timeout(long seconds);
+ZEND_API void zend_unset_timeout(void);
+ZEND_API void zend_timeout(int dummy);
+
+#ifdef ZEND_WIN32
+void zend_init_timeout_thread();
+void zend_shutdown_timeout_thread();
+#define WM_REGISTER_ZEND_TIMEOUT		(WM_USER+1)
+#define WM_UNREGISTER_ZEND_TIMEOUT		(WM_USER+2)
+#endif
+
+#define zendi_zval_copy_ctor(p) zval_copy_ctor(&(p))
+#define zendi_zval_dtor(p) zval_dtor(&(p))
+
+#define active_opline (*EG(opline_ptr))
+
+static inline void zend_assign_to_variable_reference(znode *result, zval **variable_ptr_ptr, zval **value_ptr_ptr, temp_variable *Ts ELS_DC)
+{
+	zval *variable_ptr;
+	zval *value_ptr;
+
+	if (!value_ptr_ptr || !variable_ptr_ptr) {
+		zend_error(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
+		return;
+	}
+
+	variable_ptr = *variable_ptr_ptr;
+	value_ptr = *value_ptr_ptr;
+
+	if (variable_ptr == EG(error_zval_ptr) || value_ptr==EG(error_zval_ptr)) {
+		variable_ptr_ptr = &EG(uninitialized_zval_ptr);
+/*	} else if (variable_ptr==&EG(uninitialized_zval) || variable_ptr!=value_ptr) { */
+	} else if (variable_ptr_ptr != value_ptr_ptr) {
+		variable_ptr->refcount--;
+		if (variable_ptr->refcount==0) {
+			zendi_zval_dtor(*variable_ptr);
+			FREE_ZVAL(variable_ptr);
+		}
+
+		if (!PZVAL_IS_REF(value_ptr)) {
+			/* break it away */
+			value_ptr->refcount--;
+			if (value_ptr->refcount>0) {
+				ALLOC_ZVAL(*value_ptr_ptr);
+				**value_ptr_ptr = *value_ptr;
+				value_ptr = *value_ptr_ptr;
+				zendi_zval_copy_ctor(*value_ptr);
+			}
+			value_ptr->refcount = 1;
+			value_ptr->is_ref = 1;
+		}
+
+		*variable_ptr_ptr = value_ptr;
+		value_ptr->refcount++;
+	} else {
+		if (variable_ptr->refcount>1) { /* we need to break away */
+			SEPARATE_ZVAL(variable_ptr_ptr);
+		}
+		(*variable_ptr_ptr)->is_ref = 1;
+	}
+
+	if (result && !(result->u.EA.type & EXT_TYPE_UNUSED)) {
+		Ts[result->u.var].var.ptr_ptr = variable_ptr_ptr;
+		SELECTIVE_PZVAL_LOCK(*variable_ptr_ptr, result);
+		AI_USE_PTR(Ts[result->u.var].var);
+	}
+}
+
+#define IS_OVERLOADED_OBJECT 1
+#define IS_STRING_OFFSET 2
+
+#endif /* ZEND_EXECUTE_H */

Zend/zend_execute_API.c

@@ -0,0 +1,708 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#include <stdio.h>
+#include <signal.h>
+
+#include "zend.h"
+#include "zend_compile.h"
+#include "zend_execute.h"
+#include "zend_API.h"
+#include "zend_ptr_stack.h"
+#include "zend_constants.h"
+#include "zend_extensions.h"
+#include "zend_execute_locks.h"
+#if HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+
+
+ZEND_API void (*zend_execute)(zend_op_array *op_array ELS_DC);
+
+#ifdef ZEND_WIN32
+#include <process.h>
+/* true global */
+static WNDCLASS wc;
+static HWND timeout_window;
+static HANDLE timeout_thread_event;
+static DWORD timeout_thread_id;
+static int timeout_thread_initialized=0;
+#endif
+
+
+#if ZEND_DEBUG
+static void (*original_sigsegv_handler)(int);
+static void zend_handle_sigsegv(int dummy)
+{
+	fflush(stdout);
+	fflush(stderr);
+	if (original_sigsegv_handler==zend_handle_sigsegv) {
+		signal(SIGSEGV, original_sigsegv_handler);
+	} else {
+		signal(SIGSEGV, SIG_DFL);
+	}
+	{
+		ELS_FETCH();
+
+		fprintf(stderr, "SIGSEGV caught on opcode %d on opline %d of %s() at %s:%d\n\n",
+				active_opline->opcode,
+				active_opline-EG(active_op_array)->opcodes,
+				get_active_function_name(),
+				zend_get_executed_filename(ELS_C),
+				zend_get_executed_lineno(ELS_C));
+	}
+	if (original_sigsegv_handler!=zend_handle_sigsegv) {
+		original_sigsegv_handler(dummy);
+	}
+}
+#endif
+
+
+static void zend_extension_activator(zend_extension *extension)
+{
+	if (extension->activate) {
+		extension->activate();
+	}
+}
+
+
+static void zend_extension_deactivator(zend_extension *extension)
+{
+	if (extension->deactivate) {
+		extension->deactivate();
+	}
+}
+
+
+static int is_not_internal_function(zend_function *function)
+{
+	return(function->type != ZEND_INTERNAL_FUNCTION);
+}
+
+
+static int is_not_internal_class(zend_class_entry *ce)
+{
+	return(ce->type != ZEND_INTERNAL_CLASS);
+}
+
+
+void init_executor(CLS_D ELS_DC)
+{
+	INIT_ZVAL(EG(uninitialized_zval));
+	INIT_ZVAL(EG(error_zval));
+	EG(uninitialized_zval_ptr)=&EG(uninitialized_zval);
+	EG(error_zval_ptr)=&EG(error_zval);
+	zend_ptr_stack_init(&EG(arg_types_stack));
+/* destroys stack frame, therefore makes core dumps worthless */
+#if 0&&ZEND_DEBUG
+	original_sigsegv_handler = signal(SIGSEGV, zend_handle_sigsegv);
+#endif
+	EG(return_value_ptr_ptr) = &EG(global_return_value_ptr);
+	EG(global_return_value_ptr) = NULL;
+
+	EG(symtable_cache_ptr) = EG(symtable_cache)-1;
+	EG(symtable_cache_limit)=EG(symtable_cache)+SYMTABLE_CACHE_SIZE-1;
+	EG(no_extensions)=0;
+
+	EG(function_table) = CG(function_table);
+	EG(class_table) = CG(class_table);
+
+	EG(in_execution) = 0;
+
+	zend_ptr_stack_init(&EG(argument_stack));
+
+	zend_hash_init(&EG(symbol_table), 50, NULL, ZVAL_PTR_DTOR, 0);
+	EG(active_symbol_table) = &EG(symbol_table);
+
+	zend_llist_apply(&zend_extensions, (void (*)(void *)) zend_extension_activator);
+	EG(opline_ptr) = NULL;
+	EG(garbage_ptr) = 0;
+
+	zend_hash_init(&EG(included_files), 5, NULL, NULL, 0);
+
+	EG(ticks_count) = 0;
+
+	EG(user_error_handler) = NULL;
+
+	zend_ptr_stack_init(&EG(user_error_handlers));
+
+	EG(orig_error_reporting) = EG(error_reporting);
+
+#ifdef ZEND_WIN32
+	EG(timed_out) = 0;
+#endif
+}
+
+
+void shutdown_executor(ELS_D)
+{
+	zend_ptr_stack_destroy(&EG(arg_types_stack));
+			
+	while (EG(symtable_cache_ptr)>=EG(symtable_cache)) {
+		zend_hash_destroy(*EG(symtable_cache_ptr));
+		efree(*EG(symtable_cache_ptr));
+		EG(symtable_cache_ptr)--;
+	}
+	zend_llist_apply(&zend_extensions, (void (*)(void *)) zend_extension_deactivator);
+
+	zend_hash_destroy(&EG(symbol_table));
+
+	while (EG(garbage_ptr)--) {
+		if (EG(garbage)[EG(garbage_ptr)]->refcount==1) {
+			zval_ptr_dtor(&EG(garbage)[EG(garbage_ptr)]);
+		}
+	}
+
+	zend_ptr_stack_destroy(&EG(argument_stack));
+
+	/* Destroy all op arrays */
+	zend_hash_apply(EG(function_table), (int (*)(void *)) is_not_internal_function);
+	zend_hash_apply(EG(class_table), (int (*)(void *)) is_not_internal_class);
+
+	zend_destroy_rsrc_list(ELS_C); /* must be destroyed after the main symbol table and
+									* op arrays are destroyed.
+									*/
+
+	clean_non_persistent_constants();
+#if ZEND_DEBUG
+	signal(SIGSEGV, original_sigsegv_handler);
+#endif
+
+	zend_hash_destroy(&EG(included_files));
+
+	if (EG(user_error_handler)) {
+		zval_dtor(EG(user_error_handler));
+		FREE_ZVAL(EG(user_error_handler));
+	}
+
+	zend_ptr_stack_clean(&EG(user_error_handlers), ZVAL_DESTRUCTOR, 1);
+	zend_ptr_stack_destroy(&EG(user_error_handlers));
+
+	EG(error_reporting) = EG(orig_error_reporting);
+}
+
+
+ZEND_API char *get_active_function_name()
+{
+	ELS_FETCH();
+
+	switch(EG(function_state_ptr)->function->type) {
+		case ZEND_USER_FUNCTION: {
+				char *function_name = ((zend_op_array *) EG(function_state_ptr)->function)->function_name;
+			
+				if (function_name) {
+					return function_name;
+				} else {
+					return "main";
+				}
+			}
+			break;
+		case ZEND_INTERNAL_FUNCTION:
+			return ((zend_internal_function *) EG(function_state_ptr)->function)->function_name;
+			break;
+		default:
+			return NULL;
+	}
+}
+
+
+ZEND_API char *zend_get_executed_filename(ELS_D)
+{
+	if (EG(active_op_array)) {
+		return EG(active_op_array)->filename;
+	} else {
+		return "[no active file]";
+	}
+}
+
+
+ZEND_API uint zend_get_executed_lineno(ELS_D)
+{
+	if (EG(opline_ptr)) {
+		return active_opline->lineno;
+	} else {
+		return 0;
+	}
+}
+
+
+ZEND_API zend_bool zend_is_executing()
+{
+	ELS_FETCH();
+
+	return EG(in_execution);
+}
+
+
+ZEND_API void _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC)
+{
+#if DEBUG_ZEND>=2
+	printf("Reducing refcount for %x (%x):  %d->%d\n", *zval_ptr, zval_ptr, (*zval_ptr)->refcount, (*zval_ptr)->refcount-1);
+#endif
+	(*zval_ptr)->refcount--;
+	if ((*zval_ptr)->refcount==0) {
+		zval_dtor(*zval_ptr);
+		safe_free_zval_ptr(*zval_ptr);
+	} else if (((*zval_ptr)->refcount == 1) && ((*zval_ptr)->type != IS_OBJECT)) {
+		(*zval_ptr)->is_ref = 0;
+	}
+}
+	
+
+ZEND_API int zend_is_true(zval *op)
+{
+	return i_zend_is_true(op);
+}
+
+
+ZEND_API int zval_update_constant(zval **pp, void *arg)
+{
+	zval *p = *pp;
+	zend_bool inline_change = (zend_bool) (unsigned long) arg;
+
+	if (p->type == IS_CONSTANT) {
+		zval c;
+		int refcount;
+
+		SEPARATE_ZVAL(pp);
+		p = *pp;
+
+		refcount = p->refcount;
+
+		if (!zend_get_constant(p->value.str.val, p->value.str.len, &c)) {
+			zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
+						p->value.str.val,
+						p->value.str.val);
+			p->type = IS_STRING;
+			if (!inline_change) {
+				zval_copy_ctor(p);
+			}
+		} else {
+			if (inline_change) {
+				STR_FREE(p->value.str.val);
+			}
+			*p = c;
+		}
+		INIT_PZVAL(p);
+		p->refcount = refcount;
+	} else if (p->type == IS_CONSTANT_ARRAY) {
+		SEPARATE_ZVAL(pp);
+		p = *pp;
+		p->type = IS_ARRAY;
+		zend_hash_apply_with_argument(p->value.ht, (int (*)(void *,void *)) zval_update_constant, (void *) 1);
+	}
+	return 0;
+}
+
+
+int call_user_function(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, int param_count, zval *params[])
+{
+	zval ***params_array = (zval ***) emalloc(sizeof(zval **)*param_count);
+	int i;
+	int ex_retval;
+	zval *local_retval_ptr;
+
+	for (i=0; i<param_count; i++) {
+		params_array[i] = &params[i];
+	}
+	ex_retval = call_user_function_ex(function_table, object, function_name, &local_retval_ptr, param_count, params_array, 1, NULL);
+	if (local_retval_ptr) {
+		COPY_PZVAL_TO_ZVAL(*retval_ptr, local_retval_ptr);
+	} else {
+		INIT_ZVAL(*retval_ptr);
+	}
+	efree(params_array);
+	return ex_retval;
+}
+
+
+int call_user_function_ex(HashTable *function_table, zval *object, zval *function_name, zval **retval_ptr_ptr, int param_count, zval **params[], int no_separation, HashTable *symbol_table)
+{
+	int i;
+	zval **original_return_value;
+	HashTable *calling_symbol_table;
+	zend_function_state function_state;
+	zend_function_state *original_function_state_ptr;
+	zend_op_array *original_op_array;
+	zend_op **original_opline_ptr;
+	ELS_FETCH();
+
+	*retval_ptr_ptr = NULL;
+
+	if (function_name->type==IS_ARRAY) { /* assume array($obj, $name) couple */
+		zval **tmp_object_ptr, **tmp_real_function_name;
+
+		if (zend_hash_index_find(function_name->value.ht, 0, (void **) &tmp_object_ptr)==FAILURE) {
+			return FAILURE;
+		}
+		if (zend_hash_index_find(function_name->value.ht, 1, (void **) &tmp_real_function_name)==FAILURE) {
+			return FAILURE;
+		}
+		function_name = *tmp_real_function_name;
+		SEPARATE_ZVAL_IF_NOT_REF(tmp_object_ptr);
+		object = *tmp_object_ptr;
+		object->is_ref = 1;
+	}
+
+	if (object) {
+		if (object->type != IS_OBJECT) {
+			return FAILURE;
+		}
+		function_table = &object->value.obj.ce->function_table;
+	}
+
+	if (function_name->type!=IS_STRING) {
+		return FAILURE;
+	}
+
+	original_function_state_ptr = EG(function_state_ptr);
+	zend_str_tolower(function_name->value.str.val, function_name->value.str.len);
+	if (zend_hash_find(function_table, function_name->value.str.val, function_name->value.str.len+1, (void **) &function_state.function)==FAILURE) {
+		return FAILURE;
+	}
+
+	for (i=0; i<param_count; i++) {
+		zval *param;
+
+		if (function_state.function->common.arg_types
+			&& i<function_state.function->common.arg_types[0]
+			&& function_state.function->common.arg_types[i+1]==BYREF_FORCE
+			&& !PZVAL_IS_REF(*params[i])) {
+			if ((*params[i])->refcount>1) {
+				zval *new_zval;
+
+				if (no_separation) {
+					return FAILURE;
+				}
+				ALLOC_ZVAL(new_zval);
+				*new_zval = **params[i];
+				zval_copy_ctor(new_zval);
+				new_zval->refcount = 1;
+				(*params[i])->refcount--;
+				*params[i] = new_zval;
+			}
+			(*params[i])->refcount++;
+			(*params[i])->is_ref = 1;
+			param = *params[i];
+		} else if (*params[i] != &EG(uninitialized_zval)) {
+			(*params[i])->refcount++;
+			param = *params[i];
+		} else {
+			ALLOC_ZVAL(param);
+			*param = **(params[i]);
+			INIT_PZVAL(param);
+		}
+		zend_ptr_stack_push(&EG(argument_stack), param);
+	}
+
+	zend_ptr_stack_n_push(&EG(argument_stack), 2, (void *) (long) param_count, NULL);
+
+	if (function_state.function->type == ZEND_USER_FUNCTION) {
+		calling_symbol_table = EG(active_symbol_table);
+		if (symbol_table) {
+			EG(active_symbol_table) = symbol_table;
+		} else {
+			ALLOC_HASHTABLE(EG(active_symbol_table));
+			zend_hash_init(EG(active_symbol_table), 0, NULL, ZVAL_PTR_DTOR, 0);
+		}
+		if (object) {
+			zval *dummy, **this_ptr;
+
+			ALLOC_ZVAL(dummy);
+			INIT_ZVAL(*dummy);
+			
+			zend_hash_update(EG(active_symbol_table), "this", sizeof("this"), &dummy, sizeof(zval *), (void **) &this_ptr);
+			zend_assign_to_variable_reference(NULL, this_ptr, &object, NULL ELS_CC);
+		}
+		original_return_value = EG(return_value_ptr_ptr);
+		original_op_array = EG(active_op_array);
+		EG(return_value_ptr_ptr) = retval_ptr_ptr;
+		EG(active_op_array) = (zend_op_array *) function_state.function;
+		original_opline_ptr = EG(opline_ptr);
+		zend_execute(EG(active_op_array) ELS_CC);
+		if (!symbol_table) {
+			zend_hash_destroy(EG(active_symbol_table));
+			FREE_HASHTABLE(EG(active_symbol_table));
+		}
+		EG(active_symbol_table) = calling_symbol_table;
+		EG(active_op_array) = original_op_array;
+		EG(return_value_ptr_ptr)=original_return_value;
+		EG(opline_ptr) = original_opline_ptr;
+	} else {
+		ALLOC_INIT_ZVAL(*retval_ptr_ptr);
+		((zend_internal_function *) function_state.function)->handler(param_count, *retval_ptr_ptr, object, 1 ELS_CC);
+		INIT_PZVAL(*retval_ptr_ptr);
+	}
+	zend_ptr_stack_clear_multiple(ELS_C);
+	EG(function_state_ptr) = original_function_state_ptr;
+
+	return SUCCESS;
+}
+
+
+ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name CLS_DC ELS_DC)
+{
+	zval pv;
+	zend_op_array *new_op_array;
+	zend_op_array *original_active_op_array = EG(active_op_array);
+	zend_function_state *original_function_state_ptr = EG(function_state_ptr);
+	int original_handle_op_arrays;
+	int retval;
+
+	if (retval_ptr) {
+		pv.value.str.len = strlen(str)+sizeof("return  ;")-1;
+		pv.value.str.val = emalloc(pv.value.str.len+1);
+		strcpy(pv.value.str.val, "return ");
+		strcat(pv.value.str.val, str);
+		strcat(pv.value.str.val, " ;");
+	} else {
+		pv.value.str.len = strlen(str);
+		pv.value.str.val = estrndup(str, pv.value.str.len);
+	}
+	pv.type = IS_STRING;
+
+	/*printf("Evaluating '%s'\n", pv.value.str.val);*/
+
+	original_handle_op_arrays = CG(handle_op_arrays);
+	CG(handle_op_arrays) = 0;
+	new_op_array = compile_string(&pv, string_name CLS_CC);
+	CG(handle_op_arrays) = original_handle_op_arrays;
+
+	if (new_op_array) {
+		zval *local_retval_ptr=NULL;
+		zval **original_return_value_ptr_ptr = EG(return_value_ptr_ptr);
+		zend_op **original_opline_ptr = EG(opline_ptr);
+		
+		EG(return_value_ptr_ptr) = &local_retval_ptr;
+		EG(active_op_array) = new_op_array;
+		EG(no_extensions)=1;
+
+		zend_execute(new_op_array ELS_CC);
+
+		if (local_retval_ptr) {
+			if (retval_ptr) {
+				COPY_PZVAL_TO_ZVAL(*retval_ptr, local_retval_ptr);
+			} else {
+				zval_ptr_dtor(&local_retval_ptr);
+			}
+		} else {
+			if (retval_ptr) {
+				INIT_ZVAL(*retval_ptr);
+			}
+		}
+
+		EG(no_extensions)=0;
+		EG(opline_ptr) = original_opline_ptr;
+		EG(active_op_array) = original_active_op_array;
+		EG(function_state_ptr) = original_function_state_ptr;
+		destroy_op_array(new_op_array);
+		efree(new_op_array);
+		EG(return_value_ptr_ptr) = original_return_value_ptr_ptr;
+		retval = SUCCESS;
+	} else {
+		retval = FAILURE;
+	}
+	zval_dtor(&pv);
+	return retval;
+}
+
+
+
+#if SUPPORT_INTERACTIVE
+void execute_new_code(CLS_D)
+{
+	ELS_FETCH();
+
+	if (!EG(interactive)
+		|| CG(active_op_array)->backpatch_count>0
+		|| CG(active_op_array)->function_name
+		|| CG(active_op_array)->type!=ZEND_USER_FUNCTION) {
+		return;
+	}
+	CG(active_op_array)->start_op_number = CG(active_op_array)->last_executed_op_number;
+	CG(active_op_array)->end_op_number = CG(active_op_array)->last;
+	EG(active_op_array) = CG(active_op_array);
+	zend_execute(CG(active_op_array) ELS_CC);
+	zval_ptr_dtor(EG(return_value_ptr_ptr));
+	CG(active_op_array)->start_op_number = CG(active_op_array)->last_executed_op_number;
+}
+#endif
+
+
+ZEND_API void zend_timeout(int dummy)
+{
+	ELS_FETCH();
+
+	/* is there any point in this?  we're terminating the request anyway...
+	PLS_FETCH();
+
+	PG(connection_status) |= PHP_CONNECTION_TIMEOUT;
+	*/
+	zend_error(E_ERROR, "Maximum execution time of %d second%s exceeded",
+			  EG(timeout_seconds), EG(timeout_seconds) == 1 ? "" : "s");
+}
+
+
+#ifdef ZEND_WIN32
+static LRESULT CALLBACK zend_timeout_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) 
+{
+	switch (message) {
+		case WM_DESTROY:
+			PostQuitMessage(0);
+			break;
+		case WM_REGISTER_ZEND_TIMEOUT:
+			/* wParam is the thread id pointer, lParam is the timeout amount in seconds */
+			if (lParam==0) {
+				KillTimer(timeout_window, wParam);
+			} else {
+				SetTimer(timeout_window, wParam, lParam*1000, NULL);
+			}
+			break;
+		case WM_UNREGISTER_ZEND_TIMEOUT:
+			/* wParam is the thread id pointer */
+			KillTimer(timeout_window, wParam);
+			break;
+		case WM_TIMER: {
+#ifdef ZTS
+				zend_executor_globals *executor_globals;
+
+				executor_globals = ts_resource_ex(executor_globals_id, &wParam);
+				if (!executor_globals) {
+					/* Thread died before receiving its timeout? */
+					break;
+				}
+#endif
+				KillTimer(timeout_window, wParam);
+				EG(timed_out) = 1;
+			}
+			break;
+		default:
+			return DefWindowProc(hWnd,message,wParam,lParam);
+	}
+	return 0;
+}
+
+
+
+static unsigned __stdcall timeout_thread_proc(void *pArgs)
+{
+	MSG message;
+
+	wc.style=0;
+	wc.lpfnWndProc = zend_timeout_WndProc;
+	wc.cbClsExtra=0;
+	wc.cbWndExtra=0;
+	wc.hInstance=NULL;
+	wc.hIcon=NULL;
+	wc.hCursor=NULL;
+	wc.hbrBackground=(HBRUSH)(COLOR_BACKGROUND + 5);
+	wc.lpszMenuName=NULL;
+	wc.lpszClassName = "Zend Timeout Window";
+	if(!RegisterClass(&wc)) {
+		return -1;
+	}
+	timeout_window = CreateWindow(wc.lpszClassName, wc.lpszClassName, 0, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, NULL, NULL);
+	SetEvent(timeout_thread_event);
+	while (GetMessage(&message, NULL, 0, 0)) {
+		SendMessage(timeout_window, message.message, message.wParam, message.lParam);
+		if (message.message == WM_QUIT) {
+			break;
+		}
+	}
+	DestroyWindow(timeout_window);
+	UnregisterClass(wc.lpszClassName, NULL);
+	return 0;
+}
+
+
+void zend_init_timeout_thread()
+{
+	timeout_thread_event = CreateEvent(NULL, FALSE, FALSE, NULL);
+	_beginthreadex(NULL, 0, timeout_thread_proc, NULL, 0, &timeout_thread_id);
+	WaitForSingleObject(timeout_thread_event, INFINITE);
+}
+
+
+void zend_shutdown_timeout_thread()
+{
+	if (!timeout_thread_initialized) {
+		return;
+	}
+	PostThreadMessage(timeout_thread_id, WM_QUIT, 0, 0);
+}
+
+#endif
+
+/* This one doesn't exists on QNX */
+#ifndef SIGPROF
+#define SIGPROF 27
+#endif
+
+void zend_set_timeout(long seconds)
+{
+	ELS_FETCH();
+
+	EG(timeout_seconds) = seconds;
+#ifdef ZEND_WIN32
+	if (timeout_thread_initialized==0 && InterlockedIncrement(&timeout_thread_initialized)==1) {
+		/* We start up this process-wide thread here and not in zend_startup(), because if Zend
+		 * is initialized inside a DllMain(), you're not supposed to start threads from it.
+		 */
+		zend_init_timeout_thread();
+	}
+	PostThreadMessage(timeout_thread_id, WM_REGISTER_ZEND_TIMEOUT, (WPARAM) GetCurrentThreadId(), (LPARAM) seconds);
+#else
+#	ifdef HAVE_SETITIMER
+	{
+		struct itimerval t_r;		/* timeout requested */
+		sigset_t sigset;
+
+		t_r.it_value.tv_sec = seconds;
+		t_r.it_value.tv_usec = t_r.it_interval.tv_sec = t_r.it_interval.tv_usec = 0;
+
+		setitimer(ITIMER_PROF, &t_r, NULL);
+		signal(SIGPROF, zend_timeout);
+		sigemptyset(&sigset);
+		sigaddset(&sigset, SIGPROF);
+		sigprocmask(SIG_UNBLOCK,&sigset,NULL);
+	}
+#	endif
+#endif
+}
+
+
+void zend_unset_timeout(void)
+{
+	ELS_FETCH();
+
+#ifdef ZEND_WIN32
+	PostThreadMessage(timeout_thread_id, WM_UNREGISTER_ZEND_TIMEOUT, (WPARAM) GetCurrentThreadId(), (LPARAM) 0);
+#else
+#	ifdef HAVE_SETITIMER
+	{
+		struct itimerval no_timeout;
+
+		no_timeout.it_value.tv_sec = no_timeout.it_value.tv_usec = no_timeout.it_interval.tv_sec = no_timeout.it_interval.tv_usec = 0;
+
+		setitimer(ITIMER_PROF, &no_timeout, NULL);
+	}
+#	endif
+#endif
+}

Zend/zend_execute_locks.h

@@ -0,0 +1,22 @@
+#ifndef ZEND_EXECUTE_LOCKS_H
+#define ZEND_EXECUTE_LOCKS_H
+
+#define PZVAL_LOCK(z)	((z)->refcount++)
+#define PZVAL_UNLOCK(z)	{ ((z)->refcount--);								\
+							if (!(z)->refcount) {							\
+								(z)->refcount = 1;							\
+								(z)->is_ref = 0;							\
+								if (EG(garbage_ptr) == 4) {					\
+									zval_ptr_dtor(&EG(garbage)[0]);			\
+									zval_ptr_dtor(&EG(garbage)[1]);			\
+									EG(garbage)[0] = EG(garbage)[2];		\
+									EG(garbage)[1] = EG(garbage)[3];		\
+									EG(garbage_ptr) -= 2;					\
+								}											\
+								EG(garbage)[EG(garbage_ptr)++] = (z);		\
+							}												\
+						}
+
+#define SELECTIVE_PZVAL_LOCK(pzv, pzn)		if (!((pzn)->u.EA.type & EXT_TYPE_UNUSED)) { PZVAL_LOCK(pzv); }
+
+#endif /* ZEND_EXECUTE_LOCKS_H */

Zend/zend_extensions.c

@@ -0,0 +1,216 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#include "zend_extensions.h"
+
+ZEND_API zend_llist zend_extensions;
+static int last_resource_number;
+
+int zend_load_extension(char *path)
+{
+#if ZEND_EXTENSIONS_SUPPORT
+	DL_HANDLE handle;
+	zend_extension *new_extension;
+	zend_extension_version_info *extension_version_info;
+
+	handle = DL_LOAD(path);
+	if (!handle) {
+#ifndef ZEND_WIN32
+		fprintf(stderr, "Failed loading %s:  %s\n", path, dlerror());
+#else
+		fprintf(stderr, "Failed loading %s\n", path);
+#endif
+		return FAILURE;
+	}
+
+	extension_version_info = (zend_extension_version_info *) DL_FETCH_SYMBOL(handle, "extension_version_info");
+	new_extension = (zend_extension *) DL_FETCH_SYMBOL(handle, "zend_extension_entry");
+	if (!extension_version_info || !new_extension) {
+		fprintf(stderr, "%s doesn't appear to be a valid Zend extension\n", path);
+		return FAILURE;
+	}
+
+
+	/* allow extension to proclaim compatibility with any Zend version */
+	if(extension_version_info->zend_extension_api_no != ZEND_EXTENSION_API_NO &&(!new_extension->api_no_check || new_extension->api_no_check(ZEND_EXTENSION_API_NO) != SUCCESS)) {
+		if (extension_version_info->zend_extension_api_no > ZEND_EXTENSION_API_NO) {
+			fprintf(stderr, "%s requires Zend Engine API version %d\n"
+					"The installed Zend Engine API version is %d\n\n",
+					new_extension->name,
+					extension_version_info->zend_extension_api_no,
+					ZEND_EXTENSION_API_NO);
+			DL_UNLOAD(handle);
+			return FAILURE;
+		} else if (extension_version_info->zend_extension_api_no < ZEND_EXTENSION_API_NO) {
+			fprintf(stderr, "%s designed to be used with the Zend Engine API %d is outdated\n"
+					"It requires a more recent version of the Zend Engine\n"
+					"The installed Zend Engine API version is %d\n"
+					"Contact %s at %s for a later version of this module.\n\n",
+					new_extension->name,
+					extension_version_info->zend_extension_api_no,
+					ZEND_EXTENSION_API_NO,
+					new_extension->author,
+					new_extension->URL);
+			DL_UNLOAD(handle);
+			return FAILURE;
+		} 
+	} else if (ZTS_V!=extension_version_info->thread_safe) {
+		fprintf(stderr, "Cannot load %s - it %s thread safe, whereas Zend %s\n",
+					new_extension->name,
+					(extension_version_info->thread_safe?"is":"isn't"),
+					(ZTS_V?"is":"isn't"));
+		DL_UNLOAD(handle);
+		return FAILURE;
+	} else if (ZEND_DEBUG!=extension_version_info->debug) {
+		fprintf(stderr, "Cannot load %s - it %s debug information, whereas Zend %s\n",
+					new_extension->name,
+					(extension_version_info->debug?"contains":"does not contain"),
+					(ZEND_DEBUG?"does":"does not"));
+		DL_UNLOAD(handle);
+		return FAILURE;
+	}
+
+	return zend_register_extension(new_extension, handle);
+#else
+	fprintf(stderr, "Extensions are not supported on this platform.\n");
+	return FAILURE;
+#endif
+}
+
+
+int zend_register_extension(zend_extension *new_extension, DL_HANDLE handle)
+{
+#if ZEND_EXTENSIONS_SUPPORT
+	zend_extension extension;
+
+	extension = *new_extension;
+	extension.handle = handle;
+
+	zend_extension_dispatch_message(ZEND_EXTMSG_NEW_EXTENSION, &extension);
+
+	zend_llist_add_element(&zend_extensions, &extension);
+
+	zend_append_version_info(&extension);
+	/*fprintf(stderr, "Loaded %s, version %s\n", extension.name, extension.version);*/
+#endif
+
+	return SUCCESS;
+}
+
+
+static void zend_extension_shutdown(zend_extension *extension)
+{
+#if ZEND_EXTENSIONS_SUPPORT
+	if (extension->shutdown) {
+		extension->shutdown(extension);
+	}
+#endif
+}
+
+static int zend_extension_startup(zend_extension *extension)
+{
+#if ZEND_EXTENSIONS_SUPPORT
+	if (extension->startup) {
+		if (extension->startup(extension)!=SUCCESS) {
+			return 1;
+		}
+	}
+#endif
+	return 0;
+}
+
+
+int zend_startup_extensions_mechanism()
+{
+	/* Startup extensions mechanism */
+	zend_llist_init(&zend_extensions, sizeof(zend_extension), (void (*)(void *)) zend_extension_dtor, 1);
+	last_resource_number = 0;
+	return SUCCESS;
+}
+
+
+int zend_startup_extensions()
+{
+	zend_llist_apply_with_del(&zend_extensions, (int (*)(void *)) zend_extension_startup);
+	return SUCCESS;
+}
+
+
+void zend_shutdown_extensions()
+{
+	zend_llist_apply(&zend_extensions, (void (*)(void *)) zend_extension_shutdown);
+	zend_llist_destroy(&zend_extensions);
+}
+
+
+void zend_extension_dtor(zend_extension *extension)
+{
+#if ZEND_EXTENSIONS_SUPPORT && !ZEND_DEBUG
+	if (extension->handle) {
+		DL_UNLOAD(extension->handle);
+	}
+#endif
+}
+
+
+static void zend_extension_message_dispatcher(zend_extension *extension, int num_args, va_list args)
+{
+	int message;
+	void *arg;
+
+	if (!extension->message_handler || num_args!=2) {
+		return;
+	}
+	message = va_arg(args, int);
+	arg = va_arg(args, void *);
+	extension->message_handler(message, arg);
+}
+
+
+ZEND_API void zend_extension_dispatch_message(int message, void *arg)
+{
+	zend_llist_apply_with_arguments(&zend_extensions, (llist_apply_with_args_func_t) zend_extension_message_dispatcher, 2, message, arg);
+}
+
+
+ZEND_API int zend_get_resource_handle(zend_extension *extension)
+{
+	if (last_resource_number<ZEND_MAX_RESERVED_RESOURCES) {
+		extension->resource_number = last_resource_number;
+		return last_resource_number++;
+	} else {
+		return -1;
+	}
+}
+
+
+ZEND_API zend_extension *zend_get_extension(char *extension_name)
+{
+	zend_llist_element *element;
+
+	for (element = zend_extensions.head; element; element = element->next) {
+		zend_extension *extension = (zend_extension *) element->data;
+
+		if (!strcmp(extension->name, extension_name)) {
+			return extension;
+		}
+	}
+	return NULL;
+}

Zend/zend_extensions.h

@@ -0,0 +1,116 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_EXTENSIONS_H
+#define ZEND_EXTENSIONS_H
+
+#include "zend_compile.h"
+
+#define ZEND_EXTENSION_API_NO	20001120	
+
+typedef struct _zend_extension_version_info {
+	int zend_extension_api_no;
+	char *required_zend_version;
+	unsigned char thread_safe;
+	unsigned char debug;
+} zend_extension_version_info;
+
+
+typedef struct _zend_extension zend_extension;
+
+/* Typedef's for zend_extension function pointers */
+typedef int (*startup_func_t)(zend_extension *extension);
+typedef void (*shutdown_func_t)(zend_extension *extension);
+typedef void (*activate_func_t)();
+typedef void (*deactivate_func_t)();
+
+typedef void (*message_handler_func_t)(int message, void *arg);
+
+typedef void (*op_array_handler_func_t)(zend_op_array *op_array);
+
+typedef void (*statement_handler_func_t)(zend_op_array *op_array);
+typedef void (*fcall_begin_handler_func_t)(zend_op_array *op_array);
+typedef void (*fcall_end_handler_func_t)(zend_op_array *op_array);
+
+typedef void (*op_array_ctor_func_t)(zend_op_array *op_array);
+typedef void (*op_array_dtor_func_t)(zend_op_array *op_array);
+
+struct _zend_extension {
+	char *name;
+	char *version;
+	char *author;
+	char *URL;
+	char *copyright;
+
+	startup_func_t startup;
+	shutdown_func_t shutdown;
+	activate_func_t activate;
+	deactivate_func_t deactivate;
+
+	message_handler_func_t message_handler;
+
+	op_array_handler_func_t op_array_handler;
+
+	statement_handler_func_t statement_handler;	
+	fcall_begin_handler_func_t fcall_begin_handler;
+	fcall_end_handler_func_t fcall_end_handler;
+
+	op_array_ctor_func_t op_array_ctor;
+	op_array_dtor_func_t op_array_dtor;
+
+	int (*api_no_check)(int api_no);
+	void *reserved2;
+	void *reserved3;
+	void *reserved4;
+	void *reserved5;
+	void *reserved6;
+	void *reserved7;
+	void *reserved8;
+
+	DL_HANDLE handle;
+	int resource_number;
+};
+
+
+ZEND_API int zend_get_resource_handle(zend_extension *extension);
+ZEND_API void zend_extension_dispatch_message(int message, void *arg);
+
+#define ZEND_EXTMSG_NEW_EXTENSION		1
+
+
+#define ZEND_EXTENSION()	\
+	ZEND_EXT_API zend_extension_version_info extension_version_info = { ZEND_EXTENSION_API_NO, ZEND_VERSION, ZTS_V, ZEND_DEBUG }
+
+#define STANDARD_ZEND_EXTENSION_PROPERTIES NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, -1
+#define COMPAT_ZEND_EXTENSION_PROPERTIES   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, -1
+
+
+ZEND_API extern zend_llist zend_extensions;
+
+void zend_extension_dtor(zend_extension *extension);
+ZEND_API int zend_load_extension(char *path);
+ZEND_API int zend_register_extension(zend_extension *new_extension, DL_HANDLE handle);
+void zend_append_version_info(zend_extension *extension);
+int zend_startup_extensions_mechanism(void);
+int zend_startup_extensions(void);
+void zend_shutdown_extensions(void);
+ZEND_API zend_extension *zend_get_extension(char *extension_name);
+
+#endif /* ZEND_EXTENSIONS_H */

Zend/zend_fast_cache.h

@@ -0,0 +1,140 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_FAST_CACHE_H
+#define ZEND_FAST_CACHE_H
+
+#ifndef ZEND_ENABLE_FAST_CACHE
+# if ZEND_DEBUG
+# define ZEND_ENABLE_FAST_CACHE 0
+# else
+# define ZEND_ENABLE_FAST_CACHE 1
+# endif
+#endif
+
+typedef struct _zend_fast_cache_list_entry {
+	struct _zend_fast_cache_list_entry *next;
+} zend_fast_cache_list_entry;
+
+#define MAX_FAST_CACHE_TYPES	4
+
+
+#define ZVAL_CACHE_LIST			0
+#define HASHTABLE_CACHE_LIST	1
+
+#if ZEND_ENABLE_FAST_CACHE
+
+
+#include "zend_globals.h"
+#include "zend_globals_macros.h"
+#include "zend_alloc.h"
+
+
+#if ZEND_DEBUG
+# define RECORD_ZVAL_CACHE_HIT(fc_type)		AG(fast_cache_stats)[fc_type][1]++;
+# define RECORD_ZVAL_CACHE_MISS(fc_type)	AG(fast_cache_stats)[fc_type][0]++;
+#else
+# define RECORD_ZVAL_CACHE_HIT(fc_type)
+# define RECORD_ZVAL_CACHE_MISS(fc_type)
+#endif
+
+
+#define ZEND_FAST_ALLOC(p, type, fc_type)								\
+	{																\
+		ALS_FETCH();												\
+																	\
+		if (((p) = (type *) AG(fast_cache_list_head)[fc_type])) {	\
+			AG(fast_cache_list_head)[fc_type] = ((zend_fast_cache_list_entry *) AG(fast_cache_list_head)[fc_type])->next;	\
+			RECORD_ZVAL_CACHE_HIT(fc_type);							\
+		} else {													\
+			(p) = (type *) emalloc(sizeof(type));					\
+			RECORD_ZVAL_CACHE_MISS(fc_type);						\
+		}															\
+	}
+
+
+#define ZEND_FAST_FREE(p, fc_type)										\
+	{																\
+		ALS_FETCH();												\
+																	\
+		((zend_fast_cache_list_entry *) (p))->next = (zend_fast_cache_list_entry *) AG(fast_cache_list_head)[fc_type];	\
+		AG(fast_cache_list_head)[fc_type] = (zend_fast_cache_list_entry *) (p);			\
+	}
+
+#define ZEND_FAST_ALLOC_REL(p, type, fc_type)	\
+	ZEND_FAST_ALLOC(p, type, fc_type)
+
+#define ZEND_FAST_FREE_REL(p, fc_type)	\
+	ZEND_FAST_FREE(p, fc_type)
+
+
+#else /* !ZEND_ENABLE_FAST_CACHE */
+
+#define ZEND_FAST_ALLOC(p, type, fc_type)	\
+	(p) = (type *) emalloc(sizeof(type))
+
+#define ZEND_FAST_FREE(p, fc_type)	\
+	efree(p)
+
+#define ZEND_FAST_ALLOC_REL(p, type, fc_type)	\
+	(p) = (type *) emalloc_rel(sizeof(type))
+
+#define ZEND_FAST_FREE_REL(p, fc_type)	\
+	efree_rel(p)
+
+#endif /* ZEND_ENABLE_FAST_CACHE */
+
+
+
+
+/* fast cache for zval's */
+#define ALLOC_ZVAL(z)	\
+	ZEND_FAST_ALLOC(z, zval, ZVAL_CACHE_LIST)
+
+#define FREE_ZVAL(z)	\
+	ZEND_FAST_FREE(z, ZVAL_CACHE_LIST)
+
+#define ALLOC_ZVAL_REL(z)	\
+	ZEND_FAST_ALLOC_REL(z, zval, ZVAL_CACHE_LIST)
+
+#define FREE_ZVAL_REL(z)	\
+	ZEND_FAST_FREE_REL(z, ZVAL_CACHE_LIST)
+
+/* fast cache for HashTables */
+#define ALLOC_HASHTABLE(ht)	\
+	ZEND_FAST_ALLOC(ht, HashTable, HASHTABLE_CACHE_LIST)
+
+#define FREE_HASHTABLE(ht)	\
+	ZEND_FAST_FREE(ht, HASHTABLE_CACHE_LIST)
+
+#define ALLOC_HASHTABLE_REL(ht)	\
+	ZEND_FAST_ALLOC_REL(ht, HashTable, HASHTABLE_CACHE_LIST)
+
+#define FREE_HASHTABLE_REL(ht)	\
+	ZEND_FAST_FREE_REL(ht, HASHTABLE_CACHE_LIST)
+
+#endif /* ZEND_FAST_CACHE_H */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */

Zend/zend_globals.h

@@ -0,0 +1,220 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_GLOBALS_H
+#define ZEND_GLOBALS_H
+
+
+#include <setjmp.h>
+
+#include "zend_globals_macros.h"
+
+#include "zend_stack.h"
+#include "zend_ptr_stack.h"
+#include "zend_hash.h"
+#include "zend_llist.h"
+#include "zend_fast_cache.h"
+
+/* Define ZTS if you want a thread-safe Zend */
+/*#undef ZTS*/
+
+#ifdef ZTS
+#include "../TSRM/TSRM.h"
+
+#ifdef __cplusplus
+class ZendFlexLexer;
+class ZendIniFlexLexer;
+#endif
+
+BEGIN_EXTERN_C()
+ZEND_API extern int compiler_globals_id;
+ZEND_API extern int executor_globals_id;
+ZEND_API extern int alloc_globals_id;
+END_EXTERN_C()
+
+#endif
+
+#define SYMTABLE_CACHE_SIZE 32
+
+
+#include "zend_compile.h"
+
+/* excpt.h on Digital Unix 4.0 defines function_table */
+#undef function_table
+
+
+typedef struct _zend_declarables {
+	zval ticks;
+} zend_declarables;
+
+
+struct _zend_compiler_globals {
+	zend_stack bp_stack;
+	zend_stack switch_cond_stack;
+	zend_stack foreach_copy_stack;
+	zend_stack object_stack;
+	zend_stack declare_stack;
+
+	zend_class_entry class_entry, *active_class_entry;
+
+	/* variables for list() compilation */
+	zend_llist list_llist;
+	zend_llist dimension_llist;
+
+	zend_stack function_call_stack;
+
+	char *compiled_filename;
+
+	int zend_lineno;
+	int comment_start_line;
+	char *heredoc;
+	int heredoc_len;
+
+	zend_op_array *active_op_array;
+
+	HashTable *function_table;	/* function symbol table */
+	HashTable *class_table;		/* class table */
+
+	HashTable filenames_table;
+
+	zend_bool in_compilation;
+	zend_bool short_tags;
+	zend_bool asp_tags;
+	zend_bool allow_call_time_pass_reference;
+
+	zend_declarables declarables;
+
+	/* For extensions support */
+	zend_bool extended_info;	/* generate extension information for debugger/profiler */
+	zend_bool handle_op_arrays;	/* run op_arrays through op_array handlers */
+
+	zend_bool unclean_shutdown;
+
+	zend_bool ini_parser_unbuffered_errors;
+
+	zend_llist open_files;
+#if defined(ZTS) && defined(__cplusplus)
+	ZendFlexLexer *ZFL;
+	ZendIniFlexLexer *ini_scanner;
+#else
+	void *ZFL;
+	void *ini_parser;
+#endif
+};
+
+
+struct _zend_executor_globals {
+	zval **return_value_ptr_ptr;
+
+	zval uninitialized_zval;
+	zval *uninitialized_zval_ptr;
+
+	zval error_zval;
+	zval *error_zval_ptr;
+
+	zend_function_state *function_state_ptr;
+	zend_ptr_stack arg_types_stack;
+
+	/* for global return() support */
+	zval *global_return_value_ptr;
+
+	/* symbol table cache */
+	HashTable *symtable_cache[SYMTABLE_CACHE_SIZE];
+	HashTable **symtable_cache_limit;
+	HashTable **symtable_cache_ptr;
+
+	zend_op **opline_ptr;
+
+	HashTable *active_symbol_table;
+	HashTable symbol_table;		/* main symbol table */
+
+	HashTable included_files;	/* files already included */
+
+	jmp_buf bailout;
+
+	int error_reporting;
+	int orig_error_reporting;
+	int exit_status;
+
+	zend_op_array *active_op_array;
+
+	HashTable *function_table;	/* function symbol table */
+	HashTable *class_table;		/* class table */
+	HashTable *zend_constants;	/* constants table */
+
+	long precision;
+
+	int ticks_count;
+
+	zend_bool in_execution;
+
+	/* for extended information support */
+	zend_bool no_extensions;
+
+#ifdef ZEND_WIN32
+	zend_bool timed_out;
+#endif
+
+	HashTable regular_list;
+	HashTable persistent_list;
+
+	zend_ptr_stack argument_stack;
+	int free_op1, free_op2;
+	int (*unary_op)(zval *result, zval *op1);
+	int (*binary_op)(zval *result, zval *op1, zval *op2);
+
+	zval *garbage[4];
+	int garbage_ptr;
+
+	zval *user_error_handler;
+	zend_ptr_stack user_error_handlers;
+
+	/* timeout support */
+	int timeout_seconds;
+
+	int lambda_count;
+
+	void *reserved[ZEND_MAX_RESERVED_RESOURCES];
+#if SUPPORT_INTERACTIVE
+	int interactive;
+#endif
+};
+
+
+struct _zend_alloc_globals {
+	zend_mem_header *head;		/* standard list */
+	zend_mem_header *phead;		/* persistent list */
+	void *cache[MAX_CACHED_MEMORY][MAX_CACHED_ENTRIES];
+	unsigned int cache_count[MAX_CACHED_MEMORY];
+	void *fast_cache_list_head[MAX_FAST_CACHE_TYPES];
+
+#if ZEND_DEBUG
+	/* for performance tuning */
+	int cache_stats[MAX_CACHED_MEMORY][2];
+	int fast_cache_stats[MAX_FAST_CACHE_TYPES][2];
+#endif
+#if MEMORY_LIMIT
+	unsigned int memory_limit;
+	unsigned int allocated_memory;
+	unsigned char memory_exhausted;
+#endif
+};
+
+#endif /* ZEND_GLOBALS_H */

Zend/zend_globals_macros.h

@@ -0,0 +1,89 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_GLOBALS_MACROS_H
+#define ZEND_GLOBALS_MACROS_H
+
+typedef struct _zend_compiler_globals zend_compiler_globals;
+typedef struct _zend_executor_globals zend_executor_globals;
+typedef struct _zend_alloc_globals zend_alloc_globals;
+
+/* Compiler */
+#ifdef ZTS
+# define CLS_D	zend_compiler_globals *compiler_globals
+# define CLS_DC	, CLS_D
+# define CLS_C	compiler_globals
+# define CLS_CC , CLS_C
+# define CG(v) (((zend_compiler_globals *) compiler_globals)->v)
+# define CLS_FETCH()	zend_compiler_globals *compiler_globals = (zend_compiler_globals *) ts_resource(compiler_globals_id)
+BEGIN_EXTERN_C()
+int zendparse(void *compiler_globals);
+END_EXTERN_C()
+#else
+# define CLS_D	void
+# define CLS_DC
+# define CLS_C
+# define CLS_CC
+# define CG(v) (compiler_globals.v)
+# define CLS_FETCH()
+extern ZEND_API struct _zend_compiler_globals compiler_globals;
+int zendparse(void);
+#endif
+
+
+/* Executor */
+#ifdef ZTS
+# define ELS_D	zend_executor_globals *executor_globals
+# define ELS_DC	, ELS_D
+# define ELS_C	executor_globals
+# define ELS_CC , ELS_C
+# define EG(v) (executor_globals->v)
+# define ELS_FETCH()	zend_executor_globals *executor_globals = (zend_executor_globals *) ts_resource(executor_globals_id)
+#else
+# define ELS_D	void
+# define ELS_DC
+# define ELS_C
+# define ELS_CC
+# define EG(v) (executor_globals.v)
+# define ELS_FETCH()
+extern ZEND_API zend_executor_globals executor_globals;
+#endif
+
+
+/* Memory Manager */
+#ifdef ZTS
+# define ALS_D	zend_alloc_globals *alloc_globals
+# define ALS_DC	, ALS_D
+# define ALS_C	alloc_globals
+# define ALS_CC , ALS_C
+# define AG(v) (((zend_alloc_globals *) alloc_globals)->v)
+# define ALS_FETCH()	zend_alloc_globals *alloc_globals = (zend_alloc_globals *) ts_resource(alloc_globals_id)
+#else
+# define ALS_D	void
+# define ALS_DC
+# define ALS_C
+# define ALS_CC
+# define AG(v) (alloc_globals.v)
+# define ALS_FETCH()
+extern ZEND_API zend_alloc_globals alloc_globals;
+#endif
+
+#endif /* ZEND_GLOBALS_MACROS_H */
+

Zend/zend_hash.h

@@ -0,0 +1,199 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+#ifndef ZEND_HASH_H
+#define ZEND_HASH_H
+
+#include <sys/types.h>
+
+#define HASH_KEY_IS_STRING 1
+#define HASH_KEY_IS_LONG 2
+#define HASH_KEY_NON_EXISTANT 3
+
+#define HASH_UPDATE 		(1<<0)
+#define HASH_ADD			(1<<1)
+#define HASH_NEXT_INSERT	(1<<2)
+
+#define HASH_DEL_KEY 0
+#define HASH_DEL_INDEX 1
+
+typedef int  (*compare_func_t)(const void *, const void *);
+typedef void (*sort_func_t)(void *, size_t, register size_t, compare_func_t);
+typedef void (*dtor_func_t)(void *pDest);
+typedef int (*apply_func_t)(void *pDest);
+typedef int (*apply_func_arg_t)(void *pDest, void *argument);
+typedef ulong (*hash_func_t)(char *arKey, uint nKeyLength);
+typedef void (*copy_ctor_func_t)(void *pElement);
+
+struct _hashtable;
+
+typedef struct bucket {
+	ulong h;						/* Used for numeric indexing */
+	uint nKeyLength;
+	void *pData;
+	void *pDataPtr;
+	struct bucket *pListNext;
+	struct bucket *pListLast;
+	struct bucket *pNext;
+	struct bucket *pLast;
+	char arKey[1]; /* Must be last element */
+} Bucket;
+
+typedef struct _hashtable {
+	uint nTableSize;
+	uint nHashSizeIndex;
+	uint nNumOfElements;
+	ulong nNextFreeElement;
+	hash_func_t pHashFunction;
+	Bucket *pInternalPointer;	/* Used for element traversal */
+	Bucket *pListHead;
+	Bucket *pListTail;
+	Bucket **arBuckets;
+	dtor_func_t pDestructor;
+	zend_bool persistent;
+	unsigned char nApplyCount;
+	zend_bool bApplyProtection;
+#if ZEND_DEBUG
+	int inconsistent;
+#endif
+} HashTable;
+
+typedef Bucket* HashPosition;
+
+BEGIN_EXTERN_C()
+
+/* startup/shutdown */
+ZEND_API int zend_hash_init(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, int persistent);
+ZEND_API int zend_hash_init_ex(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, int persistent, zend_bool bApplyProtection);
+ZEND_API void zend_hash_destroy(HashTable *ht);
+
+ZEND_API void zend_hash_clean(HashTable *ht);
+
+/* additions/updates/changes */
+ZEND_API int zend_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest,int flag);
+#define zend_hash_update(ht,arKey,nKeyLength,pData,nDataSize,pDest) \
+		zend_hash_add_or_update(ht,arKey,nKeyLength,pData,nDataSize,pDest,HASH_UPDATE)
+#define zend_hash_add(ht,arKey,nKeyLength,pData,nDataSize,pDest) \
+		zend_hash_add_or_update(ht,arKey,nKeyLength,pData,nDataSize,pDest,HASH_ADD)
+
+ZEND_API int zend_hash_quick_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest,int flag);
+#define zend_hash_quick_update(ht,arKey,nKeyLength,h,pData,nDataSize,pDest) \
+		zend_hash_quick_add_or_update(ht,arKey,nKeyLength,h,pData,nDataSize,pDest,HASH_UPDATE)
+#define zend_hash_quick_add(ht,arKey,nKeyLength,h,pData,nDataSize,pDest) \
+		zend_hash_quick_add_or_update(ht,arKey,nKeyLength,h,pData,nDataSize,pDest,HASH_ADD)
+
+ZEND_API int zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag);
+#define zend_hash_index_update(ht,h,pData,nDataSize,pDest) \
+		zend_hash_index_update_or_next_insert(ht,h,pData,nDataSize,pDest,HASH_UPDATE)
+#define zend_hash_next_index_insert(ht,pData,nDataSize,pDest) \
+		zend_hash_index_update_or_next_insert(ht,0,pData,nDataSize,pDest,HASH_NEXT_INSERT)
+
+typedef struct _zend_hash_key {
+	char *arKey;
+	uint nKeyLength;
+	ulong h;
+} zend_hash_key;
+
+
+typedef int (*apply_func_args_t)(void *pDest, int num_args, va_list args, zend_hash_key *hash_key);
+
+#define ZEND_STD_HASH_APPLIER		\
+	int (*)(void *element, int num_args, va_list args, zend_hash_key *hash_key)
+
+ZEND_API void zend_hash_graceful_destroy(HashTable *ht);
+ZEND_API void zend_hash_apply(HashTable *ht, apply_func_t apply_func);
+ZEND_API void zend_hash_apply_with_argument(HashTable *ht, apply_func_arg_t apply_func, void *);
+ZEND_API void zend_hash_apply_with_arguments(HashTable *ht, ZEND_STD_HASH_APPLIER, int, ...);
+
+
+
+
+/* Deletes */
+ZEND_API int zend_hash_del_key_or_index(HashTable *ht, char *arKey, uint nKeyLength, ulong h, int flag);
+#define zend_hash_del(ht,arKey,nKeyLength) \
+		zend_hash_del_key_or_index(ht,arKey,nKeyLength,0,HASH_DEL_KEY)
+#define zend_hash_index_del(ht,h) \
+		zend_hash_del_key_or_index(ht,NULL,0,h,HASH_DEL_INDEX)
+
+ZEND_API ulong zend_get_hash_value(HashTable *ht, char *arKey, uint nKeyLength);
+
+/* Data retreival */
+ZEND_API int zend_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData);
+ZEND_API int zend_hash_quick_find(HashTable *ht, char *arKey, uint nKeyLength, ulong h, void **pData);
+ZEND_API int zend_hash_index_find(HashTable *ht, ulong h, void **pData);
+
+/* Misc */
+ZEND_API int zend_hash_exists(HashTable *ht, char *arKey, uint nKeyLength);
+ZEND_API int zend_hash_index_exists(HashTable *ht, ulong h);
+ZEND_API ulong zend_hash_next_free_element(HashTable *ht);
+
+/* traversing */
+ZEND_API int zend_hash_move_forward_ex(HashTable *ht, HashPosition *pos);
+ZEND_API int zend_hash_move_backwards_ex(HashTable *ht, HashPosition *pos);
+ZEND_API int zend_hash_get_current_key_ex(HashTable *ht, char **str_index, ulong *str_length, ulong *num_index, HashPosition *pos);
+ZEND_API int zend_hash_get_current_key_type_ex(HashTable *ht, HashPosition *pos);
+ZEND_API int zend_hash_get_current_data_ex(HashTable *ht, void **pData, HashPosition *pos);
+ZEND_API void zend_hash_internal_pointer_reset_ex(HashTable *ht, HashPosition *pos);
+ZEND_API void zend_hash_internal_pointer_end_ex(HashTable *ht, HashPosition *pos);
+
+#define zend_hash_move_forward(ht) \
+	zend_hash_move_forward_ex(ht, NULL)
+#define zend_hash_move_backwards(ht) \
+	zend_hash_move_backwards_ex(ht, NULL)
+#define zend_hash_get_current_key(ht, str_index, num_index) \
+	zend_hash_get_current_key_ex(ht, str_index, NULL, num_index, NULL)
+#define zend_hash_get_current_key_type(ht) \
+	zend_hash_get_current_key_type_ex(ht, NULL)
+#define zend_hash_get_current_data(ht, pData) \
+	zend_hash_get_current_data_ex(ht, pData, NULL)
+#define zend_hash_internal_pointer_reset(ht) \
+	zend_hash_internal_pointer_reset_ex(ht, NULL)
+#define zend_hash_internal_pointer_end(ht) \
+	zend_hash_internal_pointer_end_ex(ht, NULL)
+
+/* Copying, merging and sorting */
+ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size);
+ZEND_API void zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite);
+ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, uint size, zend_bool (*pReplaceOrig)(void *orig, void *p_new));
+ZEND_API int zend_hash_sort(HashTable *ht, sort_func_t sort_func, compare_func_t compare_func, int renumber);
+ZEND_API int zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t compar, zend_bool ordered);
+ZEND_API int zend_hash_minmax(HashTable *ht, int (*compar)(const void *, const void *), int flag, void **pData);
+
+ZEND_API int zend_hash_num_elements(HashTable *ht);
+
+ZEND_API int zend_hash_rehash(HashTable *ht);
+
+ZEND_API ulong hashpjw(char *arKey, uint nKeyLength);
+
+#if ZEND_DEBUG
+/* debug */
+void zend_hash_display_pListTail(HashTable *ht);
+void zend_hash_display(HashTable *ht);
+#endif
+
+END_EXTERN_C()
+
+#define ZEND_INIT_SYMTABLE(ht)								\
+	ZEND_INIT_SYMTABLE_EX(ht, 2, 0)
+
+#define ZEND_INIT_SYMTABLE_EX(ht, n, persistent)			\
+	zend_hash_init(ht, n, NULL, ZVAL_PTR_DTOR, persistent)
+
+
+#endif							/* ZEND_HASH_H */

Zend/zend_highlight.c

@@ -0,0 +1,180 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#include "zend.h"
+#include "zend_language_parser.h"
+#include "zend_compile.h"
+#include "zend_highlight.h"
+#include "zend_ptr_stack.h"
+#include "zend_globals.h"
+
+#ifndef ZTS
+extern char *zendtext;
+extern int zendleng;
+#else
+#define zendtext ((char *) zend_get_zendtext(CLS_C))
+#define zendleng zend_get_zendleng(CLS_C)
+#endif
+
+ZEND_API void zend_html_putc(char c)
+{
+	switch (c) {
+		case '\n':
+			ZEND_PUTS("<br>");
+			break;
+		case '<':
+			ZEND_PUTS("&lt;");
+			break;
+		case '>':
+			ZEND_PUTS("&gt;");
+			break;
+		case '&':
+			ZEND_PUTS("&amp;");
+			break;
+		case ' ':
+			ZEND_PUTS("&nbsp;");
+			break;
+		case '\t':
+			ZEND_PUTS("&nbsp;&nbsp;&nbsp;&nbsp;");
+			break;
+		default:
+			ZEND_PUTC(c);
+			break;
+	}
+}
+
+
+ZEND_API void zend_html_puts(char *s, uint len)
+{
+	register char *ptr=s, *end=s+len;
+	
+	while (ptr<end) {
+		zend_html_putc(*ptr++);
+	}
+}
+
+
+
+ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini)
+{
+	zval token;
+	int token_type;
+	char *last_color = syntax_highlighter_ini->highlight_html;
+	char *next_color;
+	int in_string=0;
+	CLS_FETCH();
+
+	zend_printf("<code>");
+	zend_printf("<font color=\"%s\">\n", last_color);
+	/* highlight stuff coming back from zendlex() */
+	token.type = 0;
+	while ((token_type=lex_scan(&token CLS_CC))) {
+		switch (token_type) {
+			case T_INLINE_HTML:
+				next_color = syntax_highlighter_ini->highlight_html;
+				break;
+			case T_COMMENT:
+				next_color = syntax_highlighter_ini->highlight_comment;
+				break;
+			case T_OPEN_TAG:
+			case T_OPEN_TAG_WITH_ECHO:
+				next_color = syntax_highlighter_ini->highlight_default;
+				break;
+			case T_CLOSE_TAG:
+				next_color = syntax_highlighter_ini->highlight_default;
+				break;
+			case T_CONSTANT_ENCAPSED_STRING:
+				next_color = syntax_highlighter_ini->highlight_string;
+				break;
+			case '"':
+				next_color = syntax_highlighter_ini->highlight_string;
+				in_string = !in_string;
+				break;				
+			case T_WHITESPACE:
+				zend_html_puts(zendtext, zendleng);  /* no color needed */
+				token.type = 0;
+				continue;
+				break;
+			default:
+				if (token.type==0) {
+					next_color = syntax_highlighter_ini->highlight_keyword;
+				} else {
+					if (in_string) {
+						next_color = syntax_highlighter_ini->highlight_string;
+					} else {
+						next_color = syntax_highlighter_ini->highlight_default;
+					}
+				}
+				break;
+		}
+
+		if (last_color != next_color) {
+			if (last_color != syntax_highlighter_ini->highlight_html) {
+				zend_printf("</font>");
+			}
+			last_color = next_color;
+			if (last_color != syntax_highlighter_ini->highlight_html) {
+				zend_printf("<font color=\"%s\">", last_color);
+			}
+		}
+		switch (token_type) {
+			case T_END_HEREDOC:
+				zend_html_puts(token.value.str.val, token.value.str.len);
+				break;
+			default:
+				zend_html_puts(zendtext, zendleng);
+				break;
+		}
+
+		if (token.type == IS_STRING) {
+			switch (token_type) {
+				case T_OPEN_TAG:
+				case T_OPEN_TAG_WITH_ECHO:
+				case T_CLOSE_TAG:
+				case T_WHITESPACE:
+					break;
+				default:
+					efree(token.value.str.val);
+					break;
+			}
+		} else if (token_type == T_END_HEREDOC) {
+			zend_bool has_semicolon=(strchr(token.value.str.val, ';')?1:0);
+
+			efree(token.value.str.val);
+			if (has_semicolon) {
+				/* the following semicolon was unput(), ignore it */
+				lex_scan(&token CLS_CC);
+			}
+		}
+		token.type = 0;
+	}
+	if (last_color != syntax_highlighter_ini->highlight_html) {
+		zend_printf("</font>\n");
+	}
+	zend_printf("</font>\n");
+	zend_printf("</code>");
+}
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */

Zend/zend_highlight.h

@@ -0,0 +1,51 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_HIGHLIGHT_H
+#define ZEND_HIGHLIGHT_H
+
+#define HL_COMMENT_COLOR     "#FF8000"    /* orange */
+#define HL_DEFAULT_COLOR     "#0000BB"    /* blue */
+#define HL_HTML_COLOR        "#000000"    /* black */
+#define HL_STRING_COLOR      "#DD0000"    /* red */
+#define HL_BG_COLOR          "#FFFFFF"    /* white */
+#define HL_KEYWORD_COLOR     "#007700"    /* green */
+
+
+typedef struct _zend_syntax_highlighter_ini {
+	char *highlight_html;
+	char *highlight_comment;
+	char *highlight_default;
+	char *highlight_string;
+	char *highlight_keyword;
+} zend_syntax_highlighter_ini;
+
+
+BEGIN_EXTERN_C()
+ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini);
+ZEND_API int highlight_file(char *filename, zend_syntax_highlighter_ini *syntax_highlighter_ini);
+ZEND_API int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini, char *str_name);
+ZEND_API void zend_html_putc(char c);
+ZEND_API void zend_html_puts(char *s, uint len);
+END_EXTERN_C()
+
+extern zend_syntax_highlighter_ini syntax_highlighter_ini;
+
+#endif

Zend/zend_indent.c

@@ -0,0 +1,152 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+/* This indenter doesn't really work, it's here for no particular reason. */
+
+
+#include "zend.h"
+#include "zend_language_parser.h"
+#include "zend_compile.h"
+#include "zend_indent.h"
+
+#ifndef ZTS
+extern char *zendtext;
+extern int zendleng;
+#else
+#define zendtext ((char *) zend_get_zendtext(CLS_C))
+#define zendleng zend_get_zendleng(CLS_C)
+#endif
+
+
+static void handle_whitespace(int *emit_whitespace)
+{
+	unsigned char c;
+	int i;
+
+	for (c=0; c<128; c++) {
+		if (emit_whitespace[c]>0) {
+			for (i=0; i<emit_whitespace[c]; i++) {
+				zend_write((char *) &c, 1);
+			}
+		}
+	}
+	memset(emit_whitespace, 0, sizeof(int)*256);
+}
+
+
+ZEND_API void zend_indent()
+{
+	zval token;
+	int token_type;
+	int in_string=0;
+	int nest_level=0;
+	int emit_whitespace[256];
+	int i;
+	CLS_FETCH();
+
+	memset(emit_whitespace, 0, sizeof(int)*256);
+
+	/* highlight stuff coming back from zendlex() */
+	token.type = 0;
+	while ((token_type=lex_scan(&token CLS_CC))) {
+		switch (token_type) {
+			case T_INLINE_HTML:
+				zend_write(zendtext, zendleng);
+				break;
+			case T_WHITESPACE: {
+					token.type = 0;
+					/* eat whitespace, emit newlines */
+					for (i=0; i<zendleng; i++) {
+						emit_whitespace[(unsigned char) zendtext[i]]++;
+					}
+					continue;
+				}
+				break;
+			case '"':
+				in_string = !in_string;
+				/* break missing intentionally */
+			default:
+				if (token.type==0) {
+					/* keyword */
+					switch(token_type) {
+						case ',':
+							ZEND_PUTS(", ");
+							goto dflt_printout;
+							break;
+						case '{':
+							nest_level++;
+							if (emit_whitespace['\n']>0) {
+								ZEND_PUTS(" {\n");
+								memset(emit_whitespace, 0, sizeof(int)*256);
+							} else {
+								ZEND_PUTS("{");
+							}
+							break;
+						case '}':
+							nest_level--;
+							if (emit_whitespace['\n']==0) {
+								ZEND_PUTS("\n");
+							}
+							for (i=0; i<nest_level; i++) {
+								ZEND_PUTS("    ");
+							}
+							goto dflt_printout;
+							break;
+dflt_printout:
+						default:
+							if (emit_whitespace['\n']>0) {
+								for (i=0; i<emit_whitespace['\n']; i++) {
+									ZEND_PUTS("\n");
+								}
+								memset(emit_whitespace, 0, sizeof(int)*256);
+								for (i=0; i<nest_level; i++) {
+									ZEND_PUTS("    ");
+								}
+							} else {
+								handle_whitespace(emit_whitespace);
+							}
+							zend_write(zendtext, zendleng);
+							break;
+					}
+				} else {
+					handle_whitespace(emit_whitespace);
+					if (in_string) {
+						zend_write(zendtext, zendleng);
+						/* a part of a string */
+					} else {
+						zend_write(zendtext, zendleng);
+					}
+				}
+				break;
+		}
+		if (token.type == IS_STRING) {
+			switch (token_type) {
+			case T_OPEN_TAG:
+			case T_CLOSE_TAG:
+			case T_WHITESPACE:
+				break;
+			default:
+				efree(token.value.str.val);
+				break;
+			}
+		}
+		token.type = 0;
+	}
+}

Zend/zend_indent.h

@@ -1,28 +1,26 @@
 /*
    +----------------------------------------------------------------------+
-   | PHP version 4.0                                                      |
+   | Zend Engine                                                          |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1997-2001 The PHP Group                                |
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
    +----------------------------------------------------------------------+
-   | This source file is subject to version 2.02 of the PHP license,      |
-   | that is bundled with this package in the file LICENSE, and is        |
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
    | available at through the world-wide-web at                           |
-   | http://www.php.net/license/2_02.txt.                                 |
-   | If you did not receive a copy of the PHP license and are unable to   |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
    | obtain it through the world-wide-web, please send a note to          |
-   | license@php.net so we can mail you a copy immediately.               |
+   | license@zend.com so we can mail you a copy immediately.              |
    +----------------------------------------------------------------------+
-   | Author: Sascha Schumann <sascha@schumann.cx>                         |
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
    +----------------------------------------------------------------------+
 */
 
-#ifndef PHP_FASTCGI_H
-#define PHP_FASTCGI_H
 
-#include <sys/types.h>
-#include <sys/stat.h>
+#ifndef ZEND_INDENT_H
+#define ZEND_INDENT_H
 
-void	 fastcgi_php_shutdown(void);
-void	 fastcgi_php_init(void);
+ZEND_API void zend_indent(void);
 
-#endif
+#endif /* ZEND_INDENT_H */

Zend/zend_ini.c

@@ -0,0 +1,485 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Author: Zeev Suraski <zeev@zend.com>                                 |
+   +----------------------------------------------------------------------+
+*/
+
+
+#include <stdlib.h>
+
+#include "zend.h"
+#include "zend_API.h"
+#include "zend_ini.h"
+#include "zend_alloc.h"
+#include "zend_operators.h"
+
+static HashTable known_directives;
+
+
+/*
+ * hash_apply functions
+ */
+static int zend_remove_ini_entries(zend_ini_entry *ini_entry, int *module_number)
+{
+	if (ini_entry->module_number == *module_number) {
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+
+static int zend_restore_ini_entry_cb(zend_ini_entry *ini_entry, int stage)
+{
+	if (ini_entry->modified) {
+		if (ini_entry->on_modify) {
+			ini_entry->on_modify(ini_entry, ini_entry->orig_value, ini_entry->orig_value_length, ini_entry->mh_arg1, ini_entry->mh_arg2, ini_entry->mh_arg3, stage);
+		}
+		efree(ini_entry->value);
+		ini_entry->value = ini_entry->orig_value;
+		ini_entry->value_length = ini_entry->orig_value_length;
+		ini_entry->modified = 0;
+		ini_entry->orig_value = NULL;
+		ini_entry->orig_value_length = 0;
+	}
+	return 0;
+}
+
+/*
+ * Startup / shutdown
+ */
+int zend_ini_mstartup()
+{
+	if (zend_hash_init_ex(&known_directives, 100, NULL, NULL, 1, 0)==FAILURE) {
+		return FAILURE;
+	}
+	return SUCCESS;
+}
+
+
+int zend_ini_mshutdown()
+{
+	zend_hash_destroy(&known_directives);
+	return SUCCESS;
+}
+
+
+int zend_ini_rshutdown()
+{
+	zend_hash_apply_with_argument(&known_directives, (int (*)(void *, void *)) zend_restore_ini_entry_cb, (void *) ZEND_INI_STAGE_DEACTIVATE);
+	return SUCCESS;
+}
+
+
+static int ini_key_compare(const void *a, const void *b)
+{
+	Bucket *f;
+	Bucket *s;
+ 
+	f = *((Bucket **) a);
+	s = *((Bucket **) b);
+
+	if (f->nKeyLength==0 && s->nKeyLength==0) { /* both numeric */
+		return ZEND_NORMALIZE_BOOL(f->nKeyLength - s->nKeyLength);
+	} else if (f->nKeyLength==0) { /* f is numeric, s is not */
+		return -1;
+	} else if (s->nKeyLength==0) { /* s is numeric, f is not */
+		return 1;
+	} else { /* both strings */
+		return zend_binary_strcasecmp(f->arKey, f->nKeyLength, s->arKey, s->nKeyLength);
+	}
+}
+
+
+void zend_ini_sort_entries(void)
+{
+	zend_hash_sort(&known_directives, qsort, ini_key_compare, 0);
+}
+
+/*
+ * Registration / unregistration
+ */
+
+ZEND_API int zend_register_ini_entries(zend_ini_entry *ini_entry, int module_number)
+{
+	zend_ini_entry *p = ini_entry;
+	zend_ini_entry *hashed_ini_entry;
+	zval *default_value;
+
+	while (p->name) {
+		p->module_number = module_number;
+		if (zend_hash_add(&known_directives, p->name, p->name_length, p, sizeof(zend_ini_entry), (void **) &hashed_ini_entry)==FAILURE) {
+			zend_unregister_ini_entries(module_number);
+			return FAILURE;
+		}
+		if ((default_value=cfg_get_entry(p->name, p->name_length))) {
+			if (!hashed_ini_entry->on_modify
+				|| hashed_ini_entry->on_modify(hashed_ini_entry, default_value->value.str.val, default_value->value.str.len, hashed_ini_entry->mh_arg1, hashed_ini_entry->mh_arg2, hashed_ini_entry->mh_arg3, ZEND_INI_STAGE_STARTUP)==SUCCESS) {
+				hashed_ini_entry->value = default_value->value.str.val;
+				hashed_ini_entry->value_length = default_value->value.str.len;
+			}
+		} else {
+			if (hashed_ini_entry->on_modify) {
+				hashed_ini_entry->on_modify(hashed_ini_entry, hashed_ini_entry->value, hashed_ini_entry->value_length, hashed_ini_entry->mh_arg1, hashed_ini_entry->mh_arg2, hashed_ini_entry->mh_arg3, ZEND_INI_STAGE_STARTUP);
+			}
+		}
+		p++;
+	}
+	return SUCCESS;
+}
+
+
+ZEND_API void zend_unregister_ini_entries(int module_number)
+{
+	zend_hash_apply_with_argument(&known_directives, (int (*)(void *, void *)) zend_remove_ini_entries, (void *) &module_number);
+}
+
+
+static int zend_ini_refresh_cache(zend_ini_entry *p, int stage)
+{
+	if (p->on_modify) {
+		p->on_modify(p, p->value, p->value_length, p->mh_arg1, p->mh_arg2, p->mh_arg3, stage);
+	}
+	return 0;
+}
+
+
+ZEND_API void zend_ini_refresh_caches(int stage)
+{
+	zend_hash_apply_with_argument(&known_directives, (int (*)(void *, void *)) zend_ini_refresh_cache, (void *)(long) stage);
+}
+
+
+ZEND_API int zend_alter_ini_entry(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage)
+{
+	zend_ini_entry *ini_entry;
+	char *duplicate;
+
+	if (zend_hash_find(&known_directives, name, name_length, (void **) &ini_entry)==FAILURE) {
+		return FAILURE;
+	}
+
+	if (!(ini_entry->modifyable & modify_type)) {
+		return FAILURE;
+	}
+
+	duplicate = estrndup(new_value, new_value_length);
+	
+	if (!ini_entry->on_modify
+		|| ini_entry->on_modify(ini_entry, duplicate, new_value_length, ini_entry->mh_arg1, ini_entry->mh_arg2, ini_entry->mh_arg3, stage)==SUCCESS) {
+		if (!ini_entry->modified) {
+			ini_entry->orig_value = ini_entry->value;
+			ini_entry->orig_value_length = ini_entry->value_length;
+		} else { /* we already changed the value, free the changed value */
+			efree(ini_entry->value);
+		}
+		ini_entry->value = duplicate;
+		ini_entry->value_length = new_value_length;
+		ini_entry->modified = 1;
+	} else {
+		efree(duplicate);
+	}
+
+	return SUCCESS;
+}
+
+
+ZEND_API int zend_restore_ini_entry(char *name, uint name_length, int stage)
+{
+	zend_ini_entry *ini_entry;
+
+	if (zend_hash_find(&known_directives, name, name_length, (void **) &ini_entry)==FAILURE) {
+		return FAILURE;
+	}
+
+	zend_restore_ini_entry_cb(ini_entry, stage);
+	return SUCCESS;
+}
+
+
+ZEND_API int zend_ini_register_displayer(char *name, uint name_length, void (*displayer)(zend_ini_entry *ini_entry, int type))
+{
+	zend_ini_entry *ini_entry;
+
+	if (zend_hash_find(&known_directives, name, name_length, (void **) &ini_entry)==FAILURE) {
+		return FAILURE;
+	}
+
+	ini_entry->displayer = displayer;
+	return SUCCESS;
+}
+
+
+
+/*
+ * Data retrieval
+ */
+
+ZEND_API long zend_ini_long(char *name, uint name_length, int orig)
+{
+	zend_ini_entry *ini_entry;
+
+	if (zend_hash_find(&known_directives, name, name_length, (void **) &ini_entry)==SUCCESS) {
+		if (orig && ini_entry->modified) {
+			return (ini_entry->orig_value ? strtol(ini_entry->orig_value, NULL, 0) : 0);
+		} else if (ini_entry->value) {
+			return strtol(ini_entry->value, NULL, 0);
+		}
+	}
+
+	return 0;
+}
+
+
+ZEND_API double zend_ini_double(char *name, uint name_length, int orig)
+{
+	zend_ini_entry *ini_entry;
+
+	if (zend_hash_find(&known_directives, name, name_length, (void **) &ini_entry)==SUCCESS) {
+		if (orig && ini_entry->modified) {
+			return (double) (ini_entry->orig_value ? strtod(ini_entry->orig_value, NULL) : 0.0);
+		} else if (ini_entry->value) {
+			return (double) strtod(ini_entry->value, NULL);
+		}
+	}
+
+	return 0.0;
+}
+
+
+ZEND_API char *zend_ini_string(char *name, uint name_length, int orig)
+{
+	zend_ini_entry *ini_entry;
+
+	if (zend_hash_find(&known_directives, name, name_length, (void **) &ini_entry)==SUCCESS) {
+		if (orig && ini_entry->modified) {
+			return ini_entry->orig_value;
+		} else {
+			return ini_entry->value;
+		}
+	}
+
+	return "";
+}
+
+
+zend_ini_entry *get_ini_entry(char *name, uint name_length)
+{
+	zend_ini_entry *ini_entry;
+
+	if (zend_hash_find(&known_directives, name, name_length, (void **) &ini_entry)==SUCCESS) {
+		return ini_entry;
+	} else {
+		return NULL;
+	}
+}
+
+
+static void zend_ini_displayer_cb(zend_ini_entry *ini_entry, int type)
+{
+	if (ini_entry->displayer) {
+		ini_entry->displayer(ini_entry, type);
+	} else {
+		char *display_string;
+		uint display_string_length;
+
+		if (type==ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
+			if (ini_entry->orig_value) {
+				display_string = ini_entry->orig_value;
+				display_string_length = ini_entry->orig_value_length;
+			} else {
+				display_string = "<i>no value</i>";
+				display_string_length = sizeof("<i>no value</i>")-1;
+			}
+		} else if (ini_entry->value && ini_entry->value[0]) {
+			display_string = ini_entry->value;
+			display_string_length = ini_entry->value_length;
+		} else {
+			display_string = "<i>no value</i>";
+			display_string_length = sizeof("<i>no value</i>")-1;
+		}
+		ZEND_WRITE(display_string, display_string_length);
+	}
+}
+
+
+ZEND_INI_DISP(zend_ini_boolean_displayer_cb)
+{
+	int value;
+
+	if (type==ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
+		value = (ini_entry->orig_value ? atoi(ini_entry->orig_value) : 0);
+	} else if (ini_entry->value) {
+		value = atoi(ini_entry->value);
+	} else {
+		value = 0;
+	}
+	if (value) {
+		ZEND_PUTS("On");
+	} else {
+		ZEND_PUTS("Off");
+	}
+}
+
+
+ZEND_INI_DISP(zend_ini_color_displayer_cb)
+{
+	char *value;
+
+	if (type==ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
+		value = ini_entry->orig_value;
+	} else if (ini_entry->value) {
+		value = ini_entry->value;
+	} else {
+		value = NULL;
+	}
+	if (value) {
+		zend_printf("<font color=\"%s\">%s</font>", value, value);
+	} else {
+		ZEND_PUTS("<i>no value</i>;");
+	}
+}
+
+
+ZEND_INI_DISP(display_link_numbers)
+{
+	char *value;
+
+	if (type==ZEND_INI_DISPLAY_ORIG && ini_entry->modified) {
+		value = ini_entry->orig_value;
+	} else if (ini_entry->value) {
+		value = ini_entry->value;
+	} else {
+		value = NULL;
+	}
+
+	if (value) {
+		if (atoi(value)==-1) {
+			ZEND_PUTS("Unlimited");
+		} else {
+			zend_printf("%s", value);
+		}
+	}
+}
+
+
+ZEND_API void zend_ini_apply_with_argument(apply_func_arg_t apply_func, void *arg)
+{
+	zend_hash_apply_with_argument(&known_directives, apply_func, arg);
+}
+
+
+/* Standard message handlers */
+
+ZEND_API ZEND_INI_MH(OnUpdateBool)
+{
+	zend_bool *p;
+#ifndef ZTS
+	char *base = (char *) mh_arg2;
+#else
+	char *base;
+
+	base = (char *) ts_resource(*((int *) mh_arg2));
+#endif
+
+	p = (zend_bool *) (base+(size_t) mh_arg1);
+
+	*p = (zend_bool) atoi(new_value);
+	return SUCCESS;
+}
+
+
+ZEND_API ZEND_INI_MH(OnUpdateInt)
+{
+	long *p;
+#ifndef ZTS
+	char *base = (char *) mh_arg2;
+#else
+	char *base;
+
+	base = (char *) ts_resource(*((int *) mh_arg2));
+#endif
+
+	p = (long *) (base+(size_t) mh_arg1);
+
+	*p = zend_atoi(new_value, new_value_length);
+	return SUCCESS;
+}
+
+
+ZEND_API ZEND_INI_MH(OnUpdateReal)
+{
+	double *p;
+#ifndef ZTS
+	char *base = (char *) mh_arg2;
+#else
+	char *base;
+
+	base = (char *) ts_resource(*((int *) mh_arg2));
+#endif
+
+	p = (double *) (base+(size_t) mh_arg1);
+
+	*p = strtod(new_value, NULL);
+	return SUCCESS;
+}
+
+
+ZEND_API ZEND_INI_MH(OnUpdateString)
+{
+	char **p;
+#ifndef ZTS
+	char *base = (char *) mh_arg2;
+#else
+	char *base;
+
+	base = (char *) ts_resource(*((int *) mh_arg2));
+#endif
+
+	p = (char **) (base+(size_t) mh_arg1);
+
+	*p = new_value;
+	return SUCCESS;
+}
+
+
+ZEND_API ZEND_INI_MH(OnUpdateStringUnempty)
+{
+	char **p;
+#ifndef ZTS
+	char *base = (char *) mh_arg2;
+#else
+	char *base;
+
+	base = (char *) ts_resource(*((int *) mh_arg2));
+#endif
+
+	if (new_value && !new_value[0]) {
+		return FAILURE;
+	}
+
+	p = (char **) (base+(size_t) mh_arg1);
+
+	*p = new_value;
+	return SUCCESS;
+}
+
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */

Zend/zend_ini.h

@@ -0,0 +1,168 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Author: Zeev Suraski <zeev@zend.com>                                 |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_INI_H
+#define ZEND_INI_H
+
+#define ZEND_INI_USER	(1<<0)
+#define ZEND_INI_PERDIR	(1<<1)
+#define ZEND_INI_SYSTEM	(1<<2)
+
+#define ZEND_INI_ALL (ZEND_INI_USER|ZEND_INI_PERDIR|ZEND_INI_SYSTEM)
+
+typedef struct _zend_ini_entry zend_ini_entry;
+
+#define ZEND_INI_MH(name) int name(zend_ini_entry *entry, char *new_value, uint new_value_length, void *mh_arg1, void *mh_arg2, void *mh_arg3, int stage)
+#define ZEND_INI_DISP(name) void name(zend_ini_entry *ini_entry, int type)
+
+struct _zend_ini_entry {
+	int module_number;
+	int modifyable;
+	char *name;
+	uint name_length;
+	ZEND_INI_MH((*on_modify));
+	void *mh_arg1;
+	void *mh_arg2;
+	void *mh_arg3;
+
+	char *value;
+	uint value_length;
+
+	char *orig_value;
+	uint orig_value_length;
+	int modified;
+
+	void (*displayer)(zend_ini_entry *ini_entry, int type);
+};
+
+
+int zend_ini_mstartup(void);
+int zend_ini_mshutdown(void);
+int zend_ini_rshutdown(void);
+
+void zend_ini_sort_entries(void);
+
+ZEND_API int zend_register_ini_entries(zend_ini_entry *ini_entry, int module_number);
+ZEND_API void zend_unregister_ini_entries(int module_number);
+ZEND_API void zend_ini_refresh_caches(int stage);
+ZEND_API int zend_alter_ini_entry(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage);
+ZEND_API int zend_restore_ini_entry(char *name, uint name_length, int stage);
+ZEND_API void display_ini_entries(zend_module_entry *module);
+
+ZEND_API long zend_ini_long(char *name, uint name_length, int orig);
+ZEND_API double zend_ini_double(char *name, uint name_length, int orig);
+ZEND_API char *zend_ini_string(char *name, uint name_length, int orig);
+zend_ini_entry *get_ini_entry(char *name, uint name_length);
+
+ZEND_API int zend_ini_register_displayer(char *name, uint name_length, void (*displayer)(zend_ini_entry *ini_entry, int type));
+
+ZEND_API void zend_ini_apply_with_argument(apply_func_arg_t apply_func, void *arg);
+
+ZEND_API ZEND_INI_DISP(zend_ini_boolean_displayer_cb);
+ZEND_API ZEND_INI_DISP(zend_ini_color_displayer_cb);
+ZEND_API ZEND_INI_DISP(display_link_numbers);
+
+#define ZEND_INI_BEGIN()		static zend_ini_entry ini_entries[] = {
+#define ZEND_INI_END()		{ 0, 0, NULL, 0, NULL, NULL, NULL, NULL, NULL, 0, NULL, 0, 0, NULL } };
+
+#define ZEND_INI_ENTRY3_EX(name, default_value, modifyable, on_modify, arg1, arg2, arg3, displayer) \
+	{ 0, modifyable, name, sizeof(name), on_modify, arg1, arg2, arg3, default_value, sizeof(default_value)-1, NULL, 0, 0, displayer },
+
+#define ZEND_INI_ENTRY3(name, default_value, modifyable, on_modify, arg1, arg2, arg3) \
+	ZEND_INI_ENTRY3_EX(name, default_value, modifyable, on_modify, arg1, arg2, arg3, NULL)
+
+#define ZEND_INI_ENTRY2_EX(name, default_value, modifyable, on_modify, arg1, arg2, displayer) \
+	ZEND_INI_ENTRY3_EX(name, default_value, modifyable, on_modify, arg1, arg2, NULL, displayer)
+
+#define ZEND_INI_ENTRY2(name, default_value, modifyable, on_modify, arg1, arg2) \
+	ZEND_INI_ENTRY2_EX(name, default_value, modifyable, on_modify, arg1, arg2, NULL)
+
+#define ZEND_INI_ENTRY1_EX(name, default_value, modifyable, on_modify, arg1, displayer) \
+	ZEND_INI_ENTRY3_EX(name, default_value, modifyable, on_modify, arg1, NULL, NULL, displayer)
+
+#define ZEND_INI_ENTRY1(name, default_value, modifyable, on_modify, arg1) \
+	ZEND_INI_ENTRY1_EX(name, default_value, modifyable, on_modify, arg1, NULL)
+	
+#define ZEND_INI_ENTRY_EX(name, default_value, modifyable, on_modify, displayer) \
+	ZEND_INI_ENTRY3_EX(name, default_value, modifyable, on_modify, NULL, NULL, NULL, displayer)
+
+#define ZEND_INI_ENTRY(name, default_value, modifyable, on_modify) \
+	ZEND_INI_ENTRY_EX(name, default_value, modifyable, on_modify, NULL)
+
+#ifdef ZTS
+#define STD_ZEND_INI_ENTRY(name, default_value, modifyable, on_modify, property_name, struct_type, struct_ptr) \
+	ZEND_INI_ENTRY2(name, default_value, modifyable, on_modify, (void *) XtOffsetOf(struct_type, property_name), (void *) &struct_ptr##_id)
+#define STD_ZEND_INI_ENTRY_EX(name, default_value, modifyable, on_modify, property_name, struct_type, struct_ptr, displayer) \
+	ZEND_INI_ENTRY2_EX(name, default_value, modifyable, on_modify, (void *) XtOffsetOf(struct_type, property_name), (void *) &struct_ptr##_id, displayer)
+#define STD_ZEND_INI_BOOLEAN(name, default_value, modifyable, on_modify, property_name, struct_type, struct_ptr) \
+	ZEND_INI_ENTRY3_EX(name, default_value, modifyable, on_modify, (void *) XtOffsetOf(struct_type, property_name), (void *) &struct_ptr##_id, NULL, zend_ini_boolean_displayer_cb)
+#else
+#define STD_ZEND_INI_ENTRY(name, default_value, modifyable, on_modify, property_name, struct_type, struct_ptr) \
+	ZEND_INI_ENTRY2(name, default_value, modifyable, on_modify, (void *) XtOffsetOf(struct_type, property_name), (void *) &struct_ptr)
+#define STD_ZEND_INI_ENTRY_EX(name, default_value, modifyable, on_modify, property_name, struct_type, struct_ptr, displayer) \
+	ZEND_INI_ENTRY2_EX(name, default_value, modifyable, on_modify, (void *) XtOffsetOf(struct_type, property_name), (void *) &struct_ptr, displayer)
+#define STD_ZEND_INI_BOOLEAN(name, default_value, modifyable, on_modify, property_name, struct_type, struct_ptr) \
+	ZEND_INI_ENTRY3_EX(name, default_value, modifyable, on_modify, (void *) XtOffsetOf(struct_type, property_name), (void *) &struct_ptr, NULL, zend_ini_boolean_displayer_cb)
+#endif
+
+#define INI_INT(name) zend_ini_long((name), sizeof(name), 0)
+#define INI_FLT(name) zend_ini_double((name), sizeof(name), 0)
+#define INI_STR(name) zend_ini_string((name), sizeof(name), 0)
+#define INI_BOOL(name) ((zend_bool) INI_INT(name))
+
+#define INI_ORIG_INT(name)	zend_ini_long((name), sizeof(name), 1)
+#define INI_ORIG_FLT(name)	zend_ini_double((name), sizeof(name), 1)
+#define INI_ORIG_STR(name)	zend_ini_string((name), sizeof(name), 1)
+#define INI_ORIG_BOOL(name) ((zend_bool) INI_ORIG_INT(name))
+
+
+#define REGISTER_INI_ENTRIES() zend_register_ini_entries(ini_entries, module_number)
+#define UNREGISTER_INI_ENTRIES() zend_unregister_ini_entries(module_number)
+#define DISPLAY_INI_ENTRIES() display_ini_entries(zend_module)
+
+#define REGISTER_INI_DISPLAYER(name, displayer) zend_ini_register_displayer((name), sizeof(name), displayer)
+#define REGISTER_INI_BOOLEAN(name) REGISTER_INI_DISPLAYER(name, zend_ini_boolean_displayer_cb)
+
+zval *cfg_get_entry(char *name, uint name_length);
+
+
+/* Standard message handlers */
+ZEND_API ZEND_INI_MH(OnUpdateBool);
+ZEND_API ZEND_INI_MH(OnUpdateInt);
+ZEND_API ZEND_INI_MH(OnUpdateReal);
+ZEND_API ZEND_INI_MH(OnUpdateString);
+ZEND_API ZEND_INI_MH(OnUpdateStringUnempty);
+
+
+#define ZEND_INI_DISPLAY_ORIG	1
+#define ZEND_INI_DISPLAY_ACTIVE	2
+
+#define ZEND_INI_STAGE_STARTUP		(1<<0)
+#define ZEND_INI_STAGE_SHUTDOWN		(1<<1)
+#define ZEND_INI_STAGE_ACTIVATE		(1<<2)
+#define ZEND_INI_STAGE_DEACTIVATE	(1<<3)
+#define ZEND_INI_STAGE_RUNTIME		(1<<4)
+
+/* INI parsing engine */
+typedef void (*zend_ini_parser_cb_t)(zval *arg1, zval *arg2, int callback_type, void *arg);
+int zend_parse_ini_file(zend_file_handle *fh, zend_bool unbuffered_errors, zend_ini_parser_cb_t ini_parser_cb, void *arg);
+#define ZEND_INI_PARSER_ENTRY	1
+#define ZEND_INI_PARSER_SECTION	2
+
+#endif /* ZEND_INI_H */

Zend/zend_ini_parser.y

@@ -0,0 +1,231 @@
+%{
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Author: Zeev Suraski <zeev@zend.com>                                 |
+   +----------------------------------------------------------------------+
+*/
+
+
+/* $Id$ */
+
+#define DEBUG_CFG_PARSER 0
+#include "zend.h"
+#include "zend_API.h"
+#include "zend_ini.h"
+#include "zend_constants.h"
+#include "zend_ini_scanner.h"
+#include "zend_extensions.h"
+
+
+#if WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <winbase.h>
+#endif
+
+
+typedef struct _zend_ini_parser_param {
+	zend_ini_parser_cb_t ini_parser_cb;
+	void *arg;
+} zend_ini_parser_param;
+
+#define YYSTYPE zval
+#define YYPARSE_PARAM ini_parser_param
+
+#define ZEND_INI_PARSER_CB	((zend_ini_parser_param *) ini_parser_param)->ini_parser_cb
+#define ZEND_INI_PARSER_ARG	((zend_ini_parser_param *) ini_parser_param)->arg
+
+int ini_lex(zval *ini_lval);
+int ini_parse(void *ini_parser_param);
+
+zval yylval;
+
+#ifndef ZTS
+extern int ini_lex(zval *ini_lval);
+extern FILE *ini_in;
+extern int ini_lineno;
+extern void init_cfg_scanner(void);
+#endif
+
+void zend_ini_do_op(char type, zval *result, zval *op1, zval *op2)
+{
+	int i_result;
+	int i_op1, i_op2;
+	char str_result[MAX_LENGTH_OF_LONG];
+
+	i_op1 = atoi(op1->value.str.val);
+	free(op1->value.str.val);
+	if (op2) {
+		i_op2 = atoi(op2->value.str.val);
+		free(op2->value.str.val);
+	} else {
+		i_op2 = 0;
+	}
+
+	switch (type) {
+		case '|':
+			i_result = i_op1 | i_op2;
+			break;
+		case '&':
+			i_result = i_op1 & i_op2;
+			break;
+		case '~':
+			i_result = ~i_op1;
+			break;
+		case '!':
+			i_result = !i_op1;
+			break;
+		default:
+			i_result = 0;
+			break;
+	}
+
+	result->value.str.len = zend_sprintf(str_result, "%d", i_result);
+	result->value.str.val = (char *) malloc(result->value.str.len+1);
+	memcpy(result->value.str.val, str_result, result->value.str.len);
+	result->value.str.val[result->value.str.len] = 0;
+	result->type = IS_STRING;
+}
+
+
+void zend_ini_get_constant(zval *result, zval *name)
+{
+	zval z_constant;
+
+	if (zend_get_constant(name->value.str.val, name->value.str.len, &z_constant)) {
+		/* z_constant is emalloc()'d */
+		convert_to_string(&z_constant);
+		result->value.str.val = zend_strndup(z_constant.value.str.val, z_constant.value.str.len);
+		result->value.str.len = z_constant.value.str.len;
+		result->type = z_constant.type;
+		zval_dtor(&z_constant);
+		free(name->value.str.val);	
+	} else {
+		*result = *name;
+	}
+}
+
+
+static void ini_error(char *str)
+{
+	char *error_buf;
+	int error_buf_len;
+	char *currently_parsed_filename = zend_ini_scanner_get_filename();
+	CLS_FETCH();
+
+	error_buf_len = 128+strlen(currently_parsed_filename); /* should be more than enough */
+	error_buf = (char *) emalloc(error_buf_len);
+
+	sprintf(error_buf, "Error parsing %s on line %d\n", currently_parsed_filename, zend_ini_scanner_get_lineno());
+
+	if (CG(ini_parser_unbuffered_errors)) {
+#ifdef PHP_WIN32
+		MessageBox(NULL, error_buf, "PHP Error", MB_OK|MB_TOPMOST|0x00200000L);
+#else
+		fprintf(stderr, "PHP:  %s", error_buf);
+#endif
+	} else {
+		zend_error(E_CORE_WARNING, error_buf);
+	}
+	efree(error_buf);
+}
+
+
+int zend_parse_ini_file(zend_file_handle *fh, zend_bool unbuffered_errors, zend_ini_parser_cb_t ini_parser_cb, void *arg)
+{
+	zend_ini_parser_param ini_parser_param;
+	int retval;
+	CLS_FETCH();
+
+	ini_parser_param.ini_parser_cb = ini_parser_cb;
+	ini_parser_param.arg = arg;
+
+	if (zend_ini_open_file_for_scanning(fh)==FAILURE) {
+		return FAILURE;
+	}
+
+	CG(ini_parser_unbuffered_errors) = unbuffered_errors;
+	retval = ini_parse(&ini_parser_param);
+
+	zend_ini_close_file(fh);
+
+	if (retval==0) {
+		return SUCCESS;
+	} else {
+		return FAILURE;
+	}
+}
+
+
+%}
+
+%pure_parser
+%token TC_STRING
+%token TC_ENCAPSULATED_STRING
+%token SECTION
+%token CFG_TRUE
+%token CFG_FALSE
+%left '|' '&'
+%right '~' '!'
+
+%%
+
+statement_list:
+		statement_list statement
+	|	/* empty */
+;
+
+statement:
+		TC_STRING '=' string_or_value {
+#if DEBUG_CFG_PARSER
+			printf("'%s' = '%s'\n", $1.value.str.val, $3.value.str.val);
+#endif
+			ZEND_INI_PARSER_CB(&$1, &$3, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG);
+			free($1.value.str.val);
+			free($3.value.str.val);
+		}
+	|	TC_STRING { ZEND_INI_PARSER_CB(&$1, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG); free($1.value.str.val); }
+	|	SECTION { ZEND_INI_PARSER_CB(&$1, NULL, ZEND_INI_PARSER_SECTION, ZEND_INI_PARSER_ARG); free($1.value.str.val); }
+	|	'\n'
+;
+
+
+string_or_value:
+		expr { $$ = $1; }
+	|	TC_ENCAPSULATED_STRING { $$ = $1; }
+	|	CFG_TRUE { $$ = $1; }
+	|	CFG_FALSE { $$ = $1; }
+	|	'\n' { $$.value.str.val = strdup(""); $$.value.str.len=0; $$.type = IS_STRING; }
+	|	'\0' { $$.value.str.val = strdup(""); $$.value.str.len=0; $$.type = IS_STRING; }
+;
+
+expr:
+		constant_string			{ $$ = $1; }
+	|	expr '|' expr			{ zend_ini_do_op('|', &$$, &$1, &$3); }
+	|	expr '&' expr			{ zend_ini_do_op('&', &$$, &$1, &$3); }
+	|	'~' expr				{ zend_ini_do_op('~', &$$, &$2, NULL); }
+	|	'!'	expr				{ zend_ini_do_op('!', &$$, &$2, NULL); }
+	|	'(' expr ')'			{ $$ = $2; }
+;
+
+constant_string:
+		TC_STRING { zend_ini_get_constant(&$$, &$1); }
+;
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */

Zend/zend_ini_scanner.h

@@ -0,0 +1,24 @@
+#ifndef _ZEND_INI_SCANNER_H
+#define _ZEND_INI_SCANNER_H
+
+#if defined(ZTS) && defined(__cplusplus)
+class ZendIniFlexLexer : public yyFlexLexer
+{
+public:
+	virtual ~ZendIniFlexLexer();
+	int lex_scan(zval *zendlval);
+	void BeginState(int state);
+
+	char *filename;
+};
+#endif	/* ZTS && __cplusplus */
+
+BEGIN_EXTERN_C()
+int zend_ini_scanner_get_lineno();
+char *zend_ini_scanner_get_filename();
+int zend_ini_open_file_for_scanning(zend_file_handle *fh);
+void zend_ini_close_file(zend_file_handle *fh);
+int ini_lex(zval *ini_lval);
+END_EXTERN_C()
+
+#endif /* _ZEND_INI_SCANNER_H */

Zend/zend_ini_scanner.l

@@ -0,0 +1,283 @@
+%{
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Author: Zeev Suraski <zeev@zend.com>                                 |
+   +----------------------------------------------------------------------+
+*/
+
+#include "zend.h"
+#include "zend_globals.h"
+#include "zend_ini_parser.h"
+#include "zend_ini_scanner.h"
+
+#ifdef ZTS
+# ifdef HAVE_STDIOSTR_H
+#  include <stdiostr.h>
+# endif
+# ifdef HAVE_STDIOSTREAM_H
+#  include <stdiostream.h>
+# endif
+# ifdef ZEND_WIN32
+#  include <strstrea.h>
+# else
+#  include <strstream.h>
+# endif
+#endif
+
+#undef YYSTYPE
+#define YYSTYPE zval
+
+#ifdef ZTS
+#define YY_DECL int ZendIniFlexLexer::lex_scan(zval *ini_lval)
+#else
+#define YY_DECL int ini_lex(zval *ini_lval)
+#endif
+
+#ifndef ZTS
+static char *ini_filename;
+
+void init_ini_scanner()
+{
+	ini_lineno=1;
+}
+
+
+int zend_ini_scanner_get_lineno()
+{
+	return ini_lineno;
+}
+
+
+char *zend_ini_scanner_get_filename()
+{
+	return ini_filename;
+}
+
+#else /* ZTS */
+
+int zend_ini_scanner_get_lineno()
+{
+	CLS_FETCH();
+
+	return CG(ini_scanner)->lineno();
+}
+
+char *zend_ini_scanner_get_filename()
+{
+	CLS_FETCH();
+
+	return CG(ini_scanner)->filename;
+}
+
+int ini_lex(zval *ini_lval)
+{
+	CLS_FETCH();
+
+	return CG(ini_scanner)->lex_scan(ini_lval);
+}
+
+ZendIniFlexLexer::~ZendIniFlexLexer()
+{
+	if (yy_start_stack) {
+		yy_flex_free(yy_start_stack);
+	}
+}
+
+int yyFlexLexer::yylex()
+{
+	fprintf(stderr, "Error:  yyFlexLexer::yylex() called\n");
+	return -1;
+}
+
+#endif
+
+
+int zend_ini_open_file_for_scanning(zend_file_handle *fh)
+{
+	FILE *fp;
+	CLS_FETCH();
+
+	switch (fh->type) {
+		case ZEND_HANDLE_FP:
+			fp = fh->handle.fp;
+			break;
+		case ZEND_HANDLE_FILENAME:
+			fp = zend_fopen(fh->filename, NULL);
+			fh->type = ZEND_HANDLE_FP;
+			break;
+		default:
+			return FAILURE;
+	}
+
+#ifdef ZTS
+	if (!fp) {
+		return FAILURE;
+	}
+	fh->handle.is = new istdiostream(fp);
+	fh->type = ZEND_HANDLE_STDIOSTREAM;
+
+	CG(ini_scanner) = new ZendIniFlexLexer;
+	CG(ini_scanner)->switch_streams(fh->handle.is, &cout);
+	CG(ini_scanner)->filename = fh->filename;
+#else
+	init_ini_scanner();
+	yyin = fp;
+	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
+	ini_filename = fh->filename;
+#endif
+	return SUCCESS;
+}
+
+
+void zend_ini_close_file(zend_file_handle *fh)
+{
+	switch (fh->type) {
+		case ZEND_HANDLE_FP:
+			fclose(fh->handle.fp);
+			break;
+#ifdef ZTS
+		case ZEND_HANDLE_STDIOSTREAM: {
+				CLS_FETCH();
+				delete CG(ini_scanner);
+			}
+			break;
+#endif
+	}
+}
+
+%}
+
+%option noyywrap
+%option yylineno
+
+%%
+
+
+<INITIAL>[ ]*("true"|"on"|"yes")[ ]* {
+	ini_lval->value.str.val = zend_strndup("1",1);
+	ini_lval->value.str.len = 1;
+	ini_lval->type = IS_STRING;
+	return CFG_TRUE;
+}
+
+
+<INITIAL>[ ]*("false"|"off"|"no"|"none")[ ]* {
+	ini_lval->value.str.val = zend_strndup("",0);
+	ini_lval->value.str.len = 0;
+	ini_lval->type = IS_STRING;
+	return CFG_FALSE;
+}
+
+<INITIAL>[[][^[]+[\]]([\n]?|"\r\n"?) {
+	/* SECTION */
+
+	/* eat trailng ] */
+	while (yyleng>0 && (yytext[yyleng-1]=='\n' || yytext[yyleng-1]=='\r' || yytext[yyleng-1]==']')) {
+		yyleng--;
+		yytext[yyleng]=0;
+	}
+
+	/* eat leading [ */
+	yytext++;
+	yyleng--;
+
+	ini_lval->value.str.val = zend_strndup(yytext,yyleng);
+	ini_lval->value.str.len = yyleng;
+	ini_lval->type = IS_STRING;
+	return SECTION;
+}
+
+
+<INITIAL>["][^\n\r"]*["] {
+	/* ENCAPSULATED TC_STRING */
+
+	/* eat trailing " */
+	yytext[yyleng-1]=0;
+	
+	/* eat leading " */
+	yytext++;
+
+	ini_lval->value.str.val = zend_strndup(yytext, yyleng - 2);
+	ini_lval->value.str.len = yyleng - 2;
+	ini_lval->type = IS_STRING;
+	return TC_ENCAPSULATED_STRING;
+}
+
+<INITIAL>[&|~()!] {
+	return yytext[0];
+}
+
+
+<INITIAL>[^=\n\r\t;|&~()!"]+ {
+	/* STRING */
+	register int i;
+
+	/* eat trailing whitespace */
+	for (i=yyleng-1; i>=0; i--) {
+		if (yytext[i]==' ' || yytext[i]=='\t') {
+			yytext[i]=0;
+			yyleng--;
+		} else {
+			break;
+		}
+	}
+	/* eat leading whitespace */
+	while (yytext[0]) {
+		if (yytext[0]==' ' || yytext[0]=='\t') {
+			yytext++;
+			yyleng--;
+		} else {
+			break;
+		}
+	}
+	if (yyleng!=0) {
+		ini_lval->value.str.val = zend_strndup(yytext,yyleng);
+		ini_lval->value.str.len = yyleng;
+		ini_lval->type = IS_STRING;
+		return TC_STRING;
+	} else {
+		/* whitespace */
+	}
+}
+
+
+
+<INITIAL>[=\n] {
+	return yytext[0];
+}
+
+<INITIAL>"\r\n" {
+	return '\n';
+}
+
+<INITIAL>[;][^\r\n]*[\r\n]? {
+	/* comment */
+	return '\n';
+}
+
+<INITIAL>[ \t] {
+	/* eat whitespace */
+}
+
+<INITIAL>. {
+#if DEBUG
+	php_error(E_NOTICE,"Unexpected character on line %d:  '%s' (ASCII %d)\n",yylineno,yytext,yytext[0]);
+#endif
+}
+
+<<EOF>> {
+	yy_delete_buffer(YY_CURRENT_BUFFER);
+	yyterminate();
+}

Zend/zend_language_parser.y

@@ -0,0 +1,726 @@
+%{
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+/* 
+ * LALR shift/reduce conflicts and how they are resolved:
+ *
+ * - 2 shift/reduce conflicts due to the dangeling elseif/else ambiguity.  Solved by shift.
+ * - 1 shift/reduce conflict due to arrays within encapsulated strings. Solved by shift. 
+ * - 1 shift/reduce conflict due to objects within encapsulated strings.  Solved by shift.
+ * 
+ */
+
+
+#include "zend_compile.h"
+#include "zend.h"
+#include "zend_list.h"
+#include "zend_globals.h"
+#include "zend_API.h"
+
+#define YYERROR_VERBOSE
+#define YYSTYPE znode
+#ifdef ZTS
+# define YYPARSE_PARAM compiler_globals
+# define YYLEX_PARAM compiler_globals
+#endif
+
+
+%}
+
+%pure_parser
+%expect 4
+
+%left T_INCLUDE T_INCLUDE_ONCE T_EVAL T_REQUIRE T_REQUIRE_ONCE
+%left ','
+%left T_LOGICAL_OR
+%left T_LOGICAL_XOR
+%left T_LOGICAL_AND
+%right T_PRINT
+%left '=' T_PLUS_EQUAL T_MINUS_EQUAL T_MUL_EQUAL T_DIV_EQUAL T_CONCAT_EQUAL T_MOD_EQUAL T_AND_EQUAL T_OR_EQUAL T_XOR_EQUAL T_SL_EQUAL T_SR_EQUAL
+%left '?' ':'
+%left T_BOOLEAN_OR
+%left T_BOOLEAN_AND
+%left '|'
+%left '^'
+%left '&'
+%nonassoc T_IS_EQUAL T_IS_NOT_EQUAL T_IS_IDENTICAL T_IS_NOT_IDENTICAL
+%nonassoc '<' T_IS_SMALLER_OR_EQUAL '>' T_IS_GREATER_OR_EQUAL
+%left T_SL T_SR
+%left '+' '-' '.'
+%left '*' '/' '%'
+%right '!' '~' T_INC T_DEC T_INT_CAST T_DOUBLE_CAST T_STRING_CAST T_ARRAY_CAST T_OBJECT_CAST T_BOOL_CAST T_UNSET_CAST '@'
+%right '['
+%nonassoc T_NEW
+%token T_EXIT
+%token T_IF
+%left T_ELSEIF
+%left T_ELSE
+%left T_ENDIF
+%token T_LNUMBER
+%token T_DNUMBER
+%token T_STRING
+%token T_STRING_VARNAME
+%token T_VARIABLE
+%token T_NUM_STRING
+%token T_INLINE_HTML
+%token T_CHARACTER
+%token T_BAD_CHARACTER
+%token T_ENCAPSED_AND_WHITESPACE
+%token T_CONSTANT_ENCAPSED_STRING
+%token T_ECHO
+%token T_DO
+%token T_WHILE
+%token T_ENDWHILE
+%token T_FOR
+%token T_ENDFOR
+%token T_FOREACH
+%token T_ENDFOREACH
+%token T_DECLARE
+%token T_ENDDECLARE
+%token T_AS
+%token T_SWITCH
+%token T_ENDSWITCH
+%token T_CASE
+%token T_DEFAULT
+%token T_BREAK
+%token T_CONTINUE
+%token T_OLD_FUNCTION
+%token T_FUNCTION
+%token T_CONST
+%token T_RETURN
+%token T_USE
+%token T_GLOBAL
+%token T_STATIC
+%token T_VAR
+%token T_UNSET
+%token T_ISSET
+%token T_EMPTY
+%token T_CLASS
+%token T_EXTENDS
+%token T_OBJECT_OPERATOR
+%token T_DOUBLE_ARROW
+%token T_LIST
+%token T_ARRAY
+%token T_LINE
+%token T_FILE
+%token T_COMMENT
+%token T_ML_COMMENT
+%token T_OPEN_TAG
+%token T_OPEN_TAG_WITH_ECHO
+%token T_CLOSE_TAG
+%token T_WHITESPACE
+%token T_START_HEREDOC
+%token T_END_HEREDOC
+%token T_DOLLAR_OPEN_CURLY_BRACES
+%token T_CURLY_OPEN
+%token T_PAAMAYIM_NEKUDOTAYIM
+
+%% /* Rules */
+
+start:
+	top_statement_list
+;
+
+top_statement_list:	
+		top_statement_list  { zend_do_extended_info(CLS_C); } top_statement { HANDLE_INTERACTIVE(); }
+	|	/* empty */
+;
+
+
+top_statement:
+		statement
+	|	declaration_statement	{ zend_do_early_binding(CLS_C); }
+;
+
+
+inner_statement_list:
+		inner_statement_list  { zend_do_extended_info(CLS_C); } inner_statement { HANDLE_INTERACTIVE(); }
+	|	/* empty */
+;
+
+
+inner_statement:
+		statement
+	|	declaration_statement
+;
+
+
+statement:
+		unticked_statement { zend_do_ticks(CLS_C); }
+;
+
+
+unticked_statement:
+		'{' inner_statement_list '}'
+	|	T_IF '(' expr ')' { zend_do_if_cond(&$3, &$4 CLS_CC); } statement { zend_do_if_after_statement(&$4, 1 CLS_CC); } elseif_list else_single { zend_do_if_end(CLS_C); }
+	|	T_IF '(' expr ')' ':' { zend_do_if_cond(&$3, &$4 CLS_CC); } inner_statement_list { zend_do_if_after_statement(&$4, 1 CLS_CC); } new_elseif_list new_else_single T_ENDIF ';' { zend_do_if_end(CLS_C); }
+	|	T_WHILE '(' { $1.u.opline_num = get_next_op_number(CG(active_op_array));  } expr  ')' { zend_do_while_cond(&$4, &$5 CLS_CC); } while_statement { zend_do_while_end(&$1, &$5 CLS_CC); }
+	|	T_DO { $1.u.opline_num = get_next_op_number(CG(active_op_array));  zend_do_do_while_begin(CLS_C); } statement T_WHILE '(' { $5.u.opline_num = get_next_op_number(CG(active_op_array)); } expr ')' ';' { zend_do_do_while_end(&$1, &$5, &$7 CLS_CC); }
+	|	T_FOR 
+			'('
+				for_expr
+			';' { zend_do_free(&$3 CLS_CC); $4.u.opline_num = get_next_op_number(CG(active_op_array)); }
+				for_expr
+			';' { zend_do_extended_info(CLS_C); zend_do_for_cond(&$6, &$7 CLS_CC); }
+				for_expr
+			')' { zend_do_free(&$9 CLS_CC); zend_do_for_before_statement(&$4, &$7 CLS_CC); }
+			for_statement { zend_do_for_end(&$7 CLS_CC); }
+	|	T_SWITCH '(' expr ')'	{ zend_do_switch_cond(&$3 CLS_CC); } switch_case_list { zend_do_switch_end(&$6 CLS_CC); }
+	|	T_BREAK ';'				{ zend_do_brk_cont(ZEND_BRK, NULL CLS_CC); }
+	|	T_BREAK expr ';'		{ zend_do_brk_cont(ZEND_BRK, &$2 CLS_CC); }
+	|	T_CONTINUE ';'			{ zend_do_brk_cont(ZEND_CONT, NULL CLS_CC); }
+	|	T_CONTINUE expr ';'		{ zend_do_brk_cont(ZEND_CONT, &$2 CLS_CC); }
+	|	T_RETURN ';'						{ zend_do_return(NULL, 0 CLS_CC); }
+	|	T_RETURN expr_without_variable ';'	{ zend_do_return(&$2, 0 CLS_CC); }
+	|	T_RETURN cvar ';'					{ zend_do_return(&$2, 1 CLS_CC); }
+	|	T_GLOBAL global_var_list ';'
+	|	T_STATIC static_var_list ';'
+	|	T_ECHO echo_expr_list ';'
+	|	T_INLINE_HTML			{ zend_do_echo(&$1 CLS_CC); }
+	|	expr ';'				{ zend_do_free(&$1 CLS_CC); }
+	|	T_USE use_filename ';'		{ zend_error(E_COMPILE_ERROR,"use: Not yet supported. Please use include_once() or require_once()");  zval_dtor(&$2.u.constant); }
+	|	T_UNSET '(' unset_variables ')' ';'
+	|	T_FOREACH '(' w_cvar T_AS { zend_do_foreach_begin(&$1, &$3, &$2, &$4, 1 CLS_CC); } w_cvar foreach_optional_arg ')' { zend_do_foreach_cont(&$6, &$7, &$4 CLS_CC); } foreach_statement { zend_do_foreach_end(&$1, &$2 CLS_CC); }
+	|	T_FOREACH '(' expr_without_variable T_AS { zend_do_foreach_begin(&$1, &$3, &$2, &$4, 0 CLS_CC); } w_cvar foreach_optional_arg ')' { zend_do_foreach_cont(&$6, &$7, &$4 CLS_CC); } foreach_statement { zend_do_foreach_end(&$1, &$2 CLS_CC); }
+	|	T_DECLARE { zend_do_declare_begin(CLS_C); } '(' declare_list ')' declare_statement { zend_do_declare_end(CLS_C); }
+	|	';'		/* empty statement */
+;
+
+unset_variables:
+		unset_variable
+	|	unset_variables ',' unset_variable
+;
+
+unset_variable:
+		cvar	{ zend_do_end_variable_parse(BP_VAR_UNSET, 0 CLS_CC); zend_do_unset(&$1 CLS_CC); }
+;
+
+use_filename:
+		T_CONSTANT_ENCAPSED_STRING			{ $$ = $1; }
+	|	'(' T_CONSTANT_ENCAPSED_STRING ')'	{ $$ = $2; }
+;
+
+
+declaration_statement:
+		unticked_declaration_statement	{ zend_do_ticks(CLS_C); }
+;
+
+
+unticked_declaration_statement:
+		T_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 0, $3.op_type CLS_CC); }
+			'(' parameter_list ')' '{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 CLS_CC); }
+	|	T_OLD_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING  { zend_do_begin_function_declaration(&$1, &$4, 0, $3.op_type CLS_CC); }
+			parameter_list '(' inner_statement_list ')' ';' { zend_do_end_function_declaration(&$1 CLS_CC); }
+	|	T_CLASS T_STRING { zend_do_begin_class_declaration(&$2, NULL CLS_CC); } '{' class_statement_list '}' { zend_do_end_class_declaration(CLS_C); }
+	|	T_CLASS T_STRING T_EXTENDS T_STRING { zend_do_begin_class_declaration(&$2, &$4 CLS_CC); } '{' class_statement_list '}' { zend_do_end_class_declaration(CLS_C); }
+;
+
+
+foreach_optional_arg:
+		/* empty */				{ $$.op_type = IS_UNUSED; }
+	|	T_DOUBLE_ARROW w_cvar	{ $$ = $2; }
+;
+
+
+for_statement:
+		statement
+	|	':' inner_statement_list T_ENDFOR ';'
+;
+
+
+foreach_statement:
+		statement
+	|	':' inner_statement_list T_ENDFOREACH ';'
+;
+
+
+declare_statement:
+		statement
+	|	':' inner_statement_list T_ENDDECLARE ';'
+;
+
+
+declare_list:
+		T_STRING '=' static_scalar					{ zend_do_declare_stmt(&$1, &$3 CLS_CC); }
+	|	declare_list ',' T_STRING '=' static_scalar	{ zend_do_declare_stmt(&$3, &$5 CLS_CC); }
+;
+
+
+switch_case_list:
+		'{' case_list '}'					{ $$ = $2; }
+	|	'{' ';' case_list '}'				{ $$ = $3; }
+	|	':' case_list T_ENDSWITCH ';'		{ $$ = $2; }
+	|	':' ';' case_list T_ENDSWITCH ';'	{ $$ = $3; }
+;
+
+
+case_list:
+		/* empty */	{ $$.op_type = IS_UNUSED; }
+	|	case_list T_CASE expr case_separator { zend_do_extended_info(CLS_C);  zend_do_case_before_statement(&$1, &$2, &$3 CLS_CC); } inner_statement_list { zend_do_case_after_statement(&$$, &$2 CLS_CC); $$.op_type = IS_CONST }
+	|	case_list T_DEFAULT case_separator { zend_do_extended_info(CLS_C);  zend_do_default_before_statement(&$1, &$2 CLS_CC); } inner_statement_list { zend_do_case_after_statement(&$$, &$2 CLS_CC); $$.op_type = IS_CONST; }
+;
+
+
+case_separator:
+		':'
+	|	';'
+;
+
+
+while_statement:
+		statement
+	|	':' inner_statement_list T_ENDWHILE ';'
+;
+
+
+
+elseif_list:
+		/* empty */
+	|	elseif_list T_ELSEIF '(' expr ')' { zend_do_if_cond(&$4, &$5 CLS_CC); } statement { zend_do_if_after_statement(&$5, 0 CLS_CC); }
+;
+
+
+new_elseif_list:
+		/* empty */
+	|	new_elseif_list T_ELSEIF '(' expr ')' ':' { zend_do_if_cond(&$4, &$5 CLS_CC); } inner_statement_list { zend_do_if_after_statement(&$5, 0 CLS_CC); }
+;
+
+
+else_single:
+		/* empty */
+	|	T_ELSE statement
+;
+
+
+new_else_single:
+		/* empty */
+	|	T_ELSE ':' inner_statement_list
+;
+
+
+parameter_list: 
+		non_empty_parameter_list
+	|	/* empty */
+;
+
+
+non_empty_parameter_list:
+		T_VARIABLE				{ znode tmp;  fetch_simple_variable(&tmp, &$1, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
+	|	'&' T_VARIABLE			{ znode tmp;  fetch_simple_variable(&tmp, &$2, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_FORCE CLS_CC); }
+	|	T_CONST T_VARIABLE 		{ znode tmp;  fetch_simple_variable(&tmp, &$2, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
+	|	T_VARIABLE '=' static_scalar				{ znode tmp;  fetch_simple_variable(&tmp, &$1, 0 CLS_CC); $$.op_type = IS_CONST; $$.u.constant.value.lval=1; $$.u.constant.type=IS_LONG; INIT_PZVAL(&$$.u.constant); zend_do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, &$3, BYREF_NONE CLS_CC); }
+	|	non_empty_parameter_list ',' T_VARIABLE 	{ znode tmp;  fetch_simple_variable(&tmp, &$3, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
+	|	non_empty_parameter_list ',' '&' T_VARIABLE	{ znode tmp;  fetch_simple_variable(&tmp, &$4, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_FORCE CLS_CC); }
+	|	non_empty_parameter_list ',' T_CONST T_VARIABLE				{ znode tmp;  fetch_simple_variable(&tmp, &$4, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV, &tmp, &$$, NULL, BYREF_NONE CLS_CC); }
+	|	non_empty_parameter_list ',' T_VARIABLE '=' static_scalar 	{ znode tmp;  fetch_simple_variable(&tmp, &$3, 0 CLS_CC); $$=$1; $$.u.constant.value.lval++; zend_do_receive_arg(ZEND_RECV_INIT, &tmp, &$$, &$5, BYREF_NONE CLS_CC); }
+;
+
+
+function_call_parameter_list:
+		non_empty_function_call_parameter_list	{ $$ = $1; }
+	|	/* empty */				{ $$.u.constant.value.lval = 0; }
+;
+
+
+non_empty_function_call_parameter_list:
+		expr_without_variable	{ $$.u.constant.value.lval = 1;  zend_do_pass_param(&$1, ZEND_SEND_VAL, $$.u.constant.value.lval CLS_CC); }
+	|	cvar					{ $$.u.constant.value.lval = 1;  zend_do_pass_param(&$1, ZEND_SEND_VAR, $$.u.constant.value.lval CLS_CC); }
+	|	'&' w_cvar 				{ $$.u.constant.value.lval = 1;  zend_do_pass_param(&$2, ZEND_SEND_REF, $$.u.constant.value.lval CLS_CC); }
+	|	non_empty_function_call_parameter_list ',' expr_without_variable	{ $$.u.constant.value.lval=$1.u.constant.value.lval+1;  zend_do_pass_param(&$3, ZEND_SEND_VAL, $$.u.constant.value.lval CLS_CC); }
+	|	non_empty_function_call_parameter_list ',' cvar						{ $$.u.constant.value.lval=$1.u.constant.value.lval+1;  zend_do_pass_param(&$3, ZEND_SEND_VAR, $$.u.constant.value.lval CLS_CC); }
+	|	non_empty_function_call_parameter_list ',' '&' w_cvar				{ $$.u.constant.value.lval=$1.u.constant.value.lval+1;  zend_do_pass_param(&$4, ZEND_SEND_REF, $$.u.constant.value.lval CLS_CC); }
+;
+
+global_var_list:
+		global_var_list ',' global_var	{ zend_do_fetch_global_or_static_variable(&$3, NULL, ZEND_FETCH_GLOBAL CLS_CC); }
+	|	global_var						{ zend_do_fetch_global_or_static_variable(&$1, NULL, ZEND_FETCH_GLOBAL CLS_CC); }
+;
+
+
+global_var:
+		T_VARIABLE			{ $$ = $1; }
+	|	'$' r_cvar			{ $$ = $2; }
+	|	'$' '{' expr '}'	{ $$ = $3; }
+;
+
+
+static_var_list:
+		static_var_list ',' T_VARIABLE { zend_do_fetch_global_or_static_variable(&$3, NULL, ZEND_FETCH_STATIC CLS_CC); }
+	|	static_var_list ',' T_VARIABLE '=' static_scalar { zend_do_fetch_global_or_static_variable(&$3, &$5, ZEND_FETCH_STATIC CLS_CC); }
+	|	T_VARIABLE  { zend_do_fetch_global_or_static_variable(&$1, NULL, ZEND_FETCH_STATIC CLS_CC); }
+	|	T_VARIABLE '=' static_scalar { zend_do_fetch_global_or_static_variable(&$1, &$3, ZEND_FETCH_STATIC CLS_CC); }
+
+;
+
+
+class_statement_list:
+		class_statement_list class_statement
+	|	/* empty */
+;
+
+
+class_statement:
+		T_VAR class_variable_decleration ';'
+	|	T_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 1, $3.op_type CLS_CC); } '(' 
+			parameter_list ')' '{' inner_statement_list '}' { zend_do_end_function_declaration(&$1 CLS_CC); }
+	|	T_OLD_FUNCTION { $1.u.opline_num = CG(zend_lineno); } is_reference T_STRING { zend_do_begin_function_declaration(&$1, &$4, 1, $3.op_type CLS_CC); }
+			parameter_list '(' inner_statement_list ')' ';' { zend_do_end_function_declaration(&$1 CLS_CC); }
+
+;
+
+is_reference:
+		/* empty */	{ $$.op_type = ZEND_RETURN_VAL; }
+	|	'&'			{ $$.op_type = ZEND_RETURN_REF; }
+
+class_variable_decleration:
+		class_variable_decleration ',' T_VARIABLE					{ zend_do_declare_property(&$3, NULL CLS_CC); }
+	|	class_variable_decleration ',' T_VARIABLE '=' static_scalar	{ zend_do_declare_property(&$3, &$5 CLS_CC); }
+	|	T_VARIABLE						{ zend_do_declare_property(&$1, NULL CLS_CC); }
+	|	T_VARIABLE '=' static_scalar	{ zend_do_declare_property(&$1, &$3 CLS_CC); }
+;
+
+
+echo_expr_list:	
+	|	echo_expr_list ',' expr { zend_do_echo(&$3 CLS_CC); }
+	|	expr					{ zend_do_echo(&$1 CLS_CC); }
+;
+
+
+for_expr:
+		/* empty */			{ $$.op_type = IS_CONST;  $$.u.constant.type = IS_BOOL;  $$.u.constant.value.lval = 1; }
+	|	non_empty_for_expr	{ $$ = $1; }
+;
+
+non_empty_for_expr:
+		non_empty_for_expr ','	{ zend_do_free(&$1 CLS_CC); } expr { $$ = $4; }
+	|	expr					{ $$ = $1; }
+;
+
+
+expr_without_variable:	
+		T_LIST '(' { zend_do_list_init(CLS_C); } assignment_list ')' '=' expr { zend_do_list_end(&$$, &$7 CLS_CC); }
+	|	cvar '=' expr		{ zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); zend_do_assign(&$$, &$1, &$3 CLS_CC); }
+	|	cvar '=' '&' w_cvar	{ zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); zend_do_assign_ref(&$$, &$1, &$4 CLS_CC); }
+	|	cvar '=' '&' function_call { zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); zend_do_assign_ref(&$$, &$1, &$4 CLS_CC); }
+	|	cvar '=' '&' T_NEW class_name { zend_do_extended_fcall_begin(CLS_C); zend_do_begin_new_object(&$4, &$5 CLS_CC); } ctor_arguments { zend_do_end_new_object(&$3, &$5, &$4, &$7 CLS_CC); zend_do_extended_fcall_end(CLS_C); zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); zend_do_assign_ref(&$$, &$1, &$3 CLS_CC); }
+	|	T_NEW class_name { zend_do_extended_fcall_begin(CLS_C); zend_do_begin_new_object(&$1, &$2 CLS_CC); } ctor_arguments { zend_do_end_new_object(&$$, &$2, &$1, &$4 CLS_CC); zend_do_extended_fcall_end(CLS_C);}
+	|	cvar T_PLUS_EQUAL expr 	{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_ADD, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_MINUS_EQUAL expr	{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SUB, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_MUL_EQUAL expr		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MUL, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_DIV_EQUAL expr		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_DIV, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_CONCAT_EQUAL expr	{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_CONCAT, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_MOD_EQUAL expr		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_MOD, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_AND_EQUAL expr		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_AND, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_OR_EQUAL expr 		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_OR, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_XOR_EQUAL expr 		{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_BW_XOR, &$$, &$1, &$3 CLS_CC); }
+	|	cvar T_SL_EQUAL expr	{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SL, &$$, &$1, &$3 CLS_CC); } 
+	|	cvar T_SR_EQUAL expr	{ zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); zend_do_binary_assign_op(ZEND_ASSIGN_SR, &$$, &$1, &$3 CLS_CC); } 
+	|	rw_cvar T_INC { zend_do_post_incdec(&$$, &$1, ZEND_POST_INC CLS_CC); }
+	|	T_INC rw_cvar { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_INC CLS_CC); }
+	|	rw_cvar T_DEC { zend_do_post_incdec(&$$, &$1, ZEND_POST_DEC CLS_CC); }
+	|	T_DEC rw_cvar { zend_do_pre_incdec(&$$, &$2, ZEND_PRE_DEC CLS_CC); }
+	|	expr T_BOOLEAN_OR { zend_do_boolean_or_begin(&$1, &$2 CLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 CLS_CC); }
+	|	expr T_BOOLEAN_AND { zend_do_boolean_and_begin(&$1, &$2 CLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 CLS_CC); }  
+	|	expr T_LOGICAL_OR { zend_do_boolean_or_begin(&$1, &$2 CLS_CC); } expr { zend_do_boolean_or_end(&$$, &$1, &$4, &$2 CLS_CC); }
+	|	expr T_LOGICAL_AND { zend_do_boolean_and_begin(&$1, &$2 CLS_CC); } expr { zend_do_boolean_and_end(&$$, &$1, &$4, &$2 CLS_CC); }
+	|	expr T_LOGICAL_XOR expr { zend_do_binary_op(ZEND_BOOL_XOR, &$$, &$1, &$3 CLS_CC); }
+	|	expr '|' expr	{ zend_do_binary_op(ZEND_BW_OR, &$$, &$1, &$3 CLS_CC); }
+	|	expr '&' expr	{ zend_do_binary_op(ZEND_BW_AND, &$$, &$1, &$3 CLS_CC); }
+	|	expr '^' expr	{ zend_do_binary_op(ZEND_BW_XOR, &$$, &$1, &$3 CLS_CC); }
+	|	expr '.' expr 	{ zend_do_binary_op(ZEND_CONCAT,&$$,&$1,&$3 CLS_CC); }
+	|	expr '+' expr 	{ zend_do_binary_op(ZEND_ADD,&$$,&$1,&$3 CLS_CC); }
+	|	expr '-' expr 	{ zend_do_binary_op(ZEND_SUB,&$$,&$1,&$3 CLS_CC); }
+	|	expr '*' expr	{ zend_do_binary_op(ZEND_MUL,&$$,&$1,&$3 CLS_CC); }
+	|	expr '/' expr	{ zend_do_binary_op(ZEND_DIV,&$$,&$1,&$3 CLS_CC); }
+	|	expr '%' expr 	{ zend_do_binary_op(ZEND_MOD,&$$,&$1,&$3 CLS_CC); }
+	| 	expr T_SL expr	{ zend_do_binary_op(ZEND_SL, &$$, &$1, &$3 CLS_CC); }
+	|	expr T_SR expr	{ zend_do_binary_op(ZEND_SR, &$$, &$1, &$3 CLS_CC); }
+	|	'+' expr { $1.u.constant.value.lval=0; $1.u.constant.type=IS_LONG; $1.op_type = IS_CONST; INIT_PZVAL(&$1.u.constant); zend_do_binary_op(ZEND_ADD, &$$, &$1, &$2 CLS_CC); }
+	|	'-' expr { $1.u.constant.value.lval=0; $1.u.constant.type=IS_LONG; $1.op_type = IS_CONST; INIT_PZVAL(&$1.u.constant); zend_do_binary_op(ZEND_SUB, &$$, &$1, &$2 CLS_CC); }
+	|	'!' expr { zend_do_unary_op(ZEND_BOOL_NOT, &$$, &$2 CLS_CC); }
+	|	'~' expr { zend_do_unary_op(ZEND_BW_NOT, &$$, &$2 CLS_CC); }
+	|	expr T_IS_IDENTICAL expr		{ zend_do_binary_op(ZEND_IS_IDENTICAL, &$$, &$1, &$3 CLS_CC); }
+	|	expr T_IS_NOT_IDENTICAL expr	{ zend_do_binary_op(ZEND_IS_NOT_IDENTICAL, &$$, &$1, &$3 CLS_CC); }
+	|	expr T_IS_EQUAL expr			{ zend_do_binary_op(ZEND_IS_EQUAL, &$$, &$1, &$3 CLS_CC); }
+	|	expr T_IS_NOT_EQUAL expr 		{ zend_do_binary_op(ZEND_IS_NOT_EQUAL, &$$, &$1, &$3 CLS_CC); }
+	|	expr '<' expr 					{ zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$1, &$3 CLS_CC); }
+	|	expr T_IS_SMALLER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$1, &$3 CLS_CC); }
+	|	expr '>' expr 					{ zend_do_binary_op(ZEND_IS_SMALLER, &$$, &$3, &$1 CLS_CC); }
+	|	expr T_IS_GREATER_OR_EQUAL expr { zend_do_binary_op(ZEND_IS_SMALLER_OR_EQUAL, &$$, &$3, &$1 CLS_CC); }
+	|	'(' expr ')' 	{ $$ = $2; }
+	|	expr '?' { zend_do_begin_qm_op(&$1, &$2 CLS_CC); }
+		expr ':' { zend_do_qm_true(&$4, &$2, &$5 CLS_CC); }
+		expr	 { zend_do_qm_false(&$$, &$7, &$2, &$5 CLS_CC); }
+	|	function_call { $$ = $1; }
+	|	internal_functions_in_yacc { $$ = $1; }
+	|	T_INT_CAST expr 	{ zend_do_cast(&$$, &$2, IS_LONG CLS_CC); }
+	|	T_DOUBLE_CAST expr 	{ zend_do_cast(&$$, &$2, IS_DOUBLE CLS_CC); }
+	|	T_STRING_CAST expr	{ zend_do_cast(&$$, &$2, IS_STRING CLS_CC); } 
+	|	T_ARRAY_CAST expr 	{ zend_do_cast(&$$, &$2, IS_ARRAY CLS_CC); }
+	|	T_OBJECT_CAST expr 	{ zend_do_cast(&$$, &$2, IS_OBJECT CLS_CC); }
+	|	T_BOOL_CAST expr	{ zend_do_cast(&$$, &$2, IS_BOOL CLS_CC); }
+	|	T_UNSET_CAST expr	{ zend_do_cast(&$$, &$2, IS_NULL CLS_CC); }
+	|	T_EXIT exit_expr	{ zend_do_exit(&$$, &$2 CLS_CC); }
+	|	'@' { zend_do_begin_silence(&$1 CLS_CC); } expr { zend_do_end_silence(&$1 CLS_CC); $$ = $3; }
+	|	scalar				{ $$ = $1; }
+	|	T_ARRAY '(' array_pair_list ')' { $$ = $3; }
+	|	'`' encaps_list '`'		{ zend_do_shell_exec(&$$, &$2 CLS_CC); }
+	|	T_PRINT expr  { zend_do_print(&$$, &$2 CLS_CC); }
+;
+
+function_call:
+		T_STRING	'(' { $2.u.opline_num = zend_do_begin_function_call(&$1 CLS_CC); }
+				function_call_parameter_list
+				')' { zend_do_end_function_call(&$1, &$$, &$4, 0, $2.u.opline_num CLS_CC); zend_do_extended_fcall_end(CLS_C); }
+	|	cvar '(' { zend_do_begin_dynamic_function_call(&$1 CLS_CC); } 
+				function_call_parameter_list 
+				')' { zend_do_end_function_call(&$1, &$$, &$4, 0, 1 CLS_CC); zend_do_extended_fcall_end(CLS_C);}
+	|	T_STRING T_PAAMAYIM_NEKUDOTAYIM T_STRING '(' { zend_do_extended_fcall_begin(CLS_C); zend_do_begin_class_member_function_call(&$1, &$3 CLS_CC); } 
+											function_call_parameter_list 
+											')' { zend_do_end_function_call(&$3, &$$, &$6, 1, 1 CLS_CC); zend_do_extended_fcall_end(CLS_C);}
+;
+
+
+exit_expr:
+		/* empty */	{ memset(&$$, 0, sizeof(znode)); $$.op_type = IS_UNUSED; }	
+	|	'(' ')'		{ memset(&$$, 0, sizeof(znode)); $$.op_type = IS_UNUSED; }	
+	|	'(' expr ')'	{ $$ = $2; }
+;
+
+
+ctor_arguments:
+		/* empty */	{ $$.u.constant.value.lval=0; }
+	|	'(' function_call_parameter_list ')'	{ $$ = $2; }
+;
+
+
+class_name:
+		T_STRING	{ $$ = $1; }
+	|	r_cvar		{ $$ = $1; }
+;
+
+
+
+common_scalar:
+		T_LNUMBER 					{ $$ = $1; }
+	|	T_DNUMBER 					{ $$ = $1; }
+	|	T_CONSTANT_ENCAPSED_STRING	{ $$ = $1; }
+	|	T_LINE 						{ $$ = $1; }
+	|	T_FILE 						{ $$ = $1; }
+;
+
+
+static_scalar: /* compile-time evaluated scalars */
+		common_scalar		{ $$ = $1; }
+	|	T_STRING 		{ zend_do_fetch_constant(&$$, &$1, ZEND_CT CLS_CC); }
+	|	'+' static_scalar	{ $$ = $1; }
+	|	'-' static_scalar	{ zval minus_one;  minus_one.type = IS_LONG; minus_one.value.lval = -1;  mul_function(&$2.u.constant, &$2.u.constant, &minus_one);  $$ = $2; }
+	|	T_ARRAY '(' static_array_pair_list ')' { $$ = $3; $$.u.constant.type = IS_CONSTANT_ARRAY; }
+;
+
+
+scalar:
+		T_STRING 				{ zend_do_fetch_constant(&$$, &$1, ZEND_RT CLS_CC); }
+	|	T_STRING_VARNAME		{ $$ = $1; }
+	|	common_scalar			{ $$ = $1; }
+	|	'"' encaps_list '"' 	{ $$ = $2; }
+	|	'\'' encaps_list '\''	{ $$ = $2; }
+	|	T_START_HEREDOC encaps_list T_END_HEREDOC { $$ = $2; zend_do_end_heredoc(CLS_C); }
+;
+
+
+static_array_pair_list:
+		/* empty */ { $$.op_type = IS_CONST; INIT_PZVAL(&$$.u.constant); array_init(&$$.u.constant); }
+	|	non_empty_static_array_pair_list possible_comma	{ $$ = $1; }
+;
+
+possible_comma:
+		/* empty */
+	|	','
+;
+
+non_empty_static_array_pair_list:
+		non_empty_static_array_pair_list ',' static_scalar T_DOUBLE_ARROW static_scalar	{ zend_do_add_static_array_element(&$$, &$3, &$5); }
+	|	non_empty_static_array_pair_list ',' static_scalar { zend_do_add_static_array_element(&$$, NULL, &$3); }
+	|	static_scalar T_DOUBLE_ARROW static_scalar { $$.op_type = IS_CONST; INIT_PZVAL(&$$.u.constant); array_init(&$$.u.constant); zend_do_add_static_array_element(&$$, &$1, &$3); }
+	|	static_scalar { $$.op_type = IS_CONST; INIT_PZVAL(&$$.u.constant); array_init(&$$.u.constant); zend_do_add_static_array_element(&$$, NULL, &$1); }
+;
+
+expr:
+		r_cvar					{ $$ = $1; }
+	|	expr_without_variable	{ $$ = $1; }
+;
+
+/*
+w_expr:
+		w_cvar					{ $$ = $1; }
+	|	expr_without_variable	{ $$ = $1; }
+;
+*/
+
+
+r_cvar:
+	cvar { zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC); $$ = $1; }
+;
+
+
+w_cvar:
+	cvar { zend_do_end_variable_parse(BP_VAR_W, 0 CLS_CC); $$ = $1; }
+;
+
+
+rw_cvar:
+	cvar { zend_do_end_variable_parse(BP_VAR_RW, 0 CLS_CC); $$ = $1; }
+;
+
+
+cvar:
+		cvar_without_objects { $$ = $1; }
+	|	cvar_without_objects T_OBJECT_OPERATOR { zend_do_push_object(&$1 CLS_CC); } ref_list { $$ = $4; }
+;
+
+
+cvar_without_objects:
+		reference_variable { $$ = $1; }
+	|	simple_indirect_reference reference_variable { zend_do_indirect_references(&$$, &$1, &$2 CLS_CC); }
+;
+
+
+reference_variable:
+		reference_variable '[' dim_offset ']'	{ fetch_array_dim(&$$, &$1, &$3 CLS_CC); }
+	|	reference_variable '{' expr '}'		{ fetch_string_offset(&$$, &$1, &$3 CLS_CC); }
+	|	compound_variable			{ zend_do_fetch_globals(&$1 CLS_CC); zend_do_begin_variable_parse(CLS_C); fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
+;
+	
+
+compound_variable:
+		T_VARIABLE			{ $$ = $1; }
+	|	'$' '{' expr '}'	{ $$ = $3; }
+;
+
+dim_offset:
+		/* empty */		{ $$.op_type = IS_UNUSED; }
+	|	expr			{ $$ = $1; }
+;
+
+ref_list:
+		object_property  { $$ = $1; }
+	|	ref_list T_OBJECT_OPERATOR { zend_do_push_object(&$1 CLS_CC); } object_property { $$ = $4; }
+;
+
+object_property:
+		object_dim_list { $$ = $1; }
+	|	cvar_without_objects { zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC); } { znode tmp_znode;  zend_do_pop_object(&tmp_znode CLS_CC);  zend_do_fetch_property(&$$, &tmp_znode, &$1 CLS_CC);}
+;
+
+object_dim_list:
+		object_dim_list '[' dim_offset ']'	{ fetch_array_dim(&$$, &$1, &$3 CLS_CC); }
+	|	object_dim_list '{' expr '}'		{ fetch_string_offset(&$$, &$1, &$3 CLS_CC); }
+	|	variable_name { znode tmp_znode;  zend_do_pop_object(&tmp_znode CLS_CC);  zend_do_fetch_property(&$$, &tmp_znode, &$1 CLS_CC);}
+;
+
+variable_name:
+		T_STRING		{ $$ = $1; }
+	|	'{' expr '}'	{ $$ = $2; }
+;
+
+
+simple_indirect_reference:
+		'$' { $$.u.constant.value.lval = 1; }
+	|	simple_indirect_reference '$' { $$.u.constant.value.lval++; }
+;
+
+assignment_list:
+		assignment_list ',' assignment_list_element
+	|	assignment_list_element
+;
+
+
+assignment_list_element:
+		cvar								{ zend_do_add_list_element(&$1 CLS_CC); }
+	|	T_LIST '(' { zend_do_new_list_begin(CLS_C); } assignment_list ')'	{ zend_do_new_list_end(CLS_C); }
+	|	/* empty */							{ zend_do_add_list_element(NULL CLS_CC); }
+;
+
+
+array_pair_list:
+		/* empty */ { zend_do_init_array(&$$, NULL, NULL, 0 CLS_CC); }
+	|	non_empty_array_pair_list possible_comma	{ $$ = $1; }
+;
+
+non_empty_array_pair_list:
+		non_empty_array_pair_list ',' expr T_DOUBLE_ARROW expr	{ zend_do_add_array_element(&$$, &$5, &$3, 0 CLS_CC); }
+	|	non_empty_array_pair_list ',' expr			{ zend_do_add_array_element(&$$, &$3, NULL, 0 CLS_CC); }
+	|	expr T_DOUBLE_ARROW expr	{ zend_do_init_array(&$$, &$3, &$1, 0 CLS_CC); }
+	|	expr 				{ zend_do_init_array(&$$, &$1, NULL, 0 CLS_CC); }
+	|	non_empty_array_pair_list ',' expr T_DOUBLE_ARROW '&' w_cvar { zend_do_add_array_element(&$$, &$6, &$3, 1 CLS_CC); }
+	|	non_empty_array_pair_list ',' '&' w_cvar { zend_do_add_array_element(&$$, &$4, NULL, 1 CLS_CC); }
+	|	expr T_DOUBLE_ARROW '&' w_cvar	{ zend_do_init_array(&$$, &$4, &$1, 1 CLS_CC); }
+	|	'&' w_cvar 			{ zend_do_init_array(&$$, &$2, NULL, 1 CLS_CC); }
+;
+
+encaps_list:
+		encaps_list encaps_var { zend_do_end_variable_parse(BP_VAR_R, 0 CLS_CC);  zend_do_add_variable(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list T_STRING			{ zend_do_add_string(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list T_NUM_STRING		{ zend_do_add_string(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list T_ENCAPSED_AND_WHITESPACE	{ zend_do_add_string(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list T_CHARACTER 		{ zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list T_BAD_CHARACTER		{ zend_do_add_string(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list '['		{ $2.u.constant.value.lval = (long) '['; zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list ']'		{ $2.u.constant.value.lval = (long) ']'; zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list '{'		{ $2.u.constant.value.lval = (long) '{'; zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list '}'		{ $2.u.constant.value.lval = (long) '}'; zend_do_add_char(&$$, &$1, &$2 CLS_CC); }
+	|	encaps_list T_OBJECT_OPERATOR  { znode tmp;  $2.u.constant.value.lval = (long) '-';  zend_do_add_char(&tmp, &$1, &$2 CLS_CC);  $2.u.constant.value.lval = (long) '>'; zend_do_add_char(&$$, &tmp, &$2 CLS_CC); }
+	|	/* empty */			{ zend_do_init_string(&$$ CLS_CC); }
+
+;
+
+
+
+encaps_var:
+		T_VARIABLE { zend_do_fetch_globals(&$1 CLS_CC); zend_do_begin_variable_parse(CLS_C); fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
+	|	T_VARIABLE '[' { zend_do_begin_variable_parse(CLS_C); } encaps_var_offset ']'	{ zend_do_fetch_globals(&$1 CLS_CC);  fetch_array_begin(&$$, &$1, &$4 CLS_CC); }
+	|	T_VARIABLE T_OBJECT_OPERATOR T_STRING { zend_do_begin_variable_parse(CLS_C); fetch_simple_variable(&$2, &$1, 1 CLS_CC); zend_do_fetch_property(&$$, &$2, &$3 CLS_CC); }
+	|	T_DOLLAR_OPEN_CURLY_BRACES expr '}' { zend_do_begin_variable_parse(CLS_C);  fetch_simple_variable(&$$, &$2, 1 CLS_CC); }
+	|	T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '[' expr ']' '}' { zend_do_begin_variable_parse(CLS_C);  fetch_array_begin(&$$, &$2, &$4 CLS_CC); }
+	|	T_CURLY_OPEN cvar '}' { $$ = $2; }
+;
+
+
+encaps_var_offset:
+		T_STRING		{ $$ = $1; }
+	|	T_NUM_STRING	{ $$ = $1; }
+	|	T_VARIABLE		{ fetch_simple_variable(&$$, &$1, 1 CLS_CC); }
+;
+
+
+internal_functions_in_yacc:
+		T_ISSET '(' cvar ')'	{ zend_do_isset_or_isempty(ZEND_ISSET, &$$, &$3 CLS_CC); }
+	|	T_EMPTY '(' cvar ')'	{ zend_do_isset_or_isempty(ZEND_ISEMPTY, &$$, &$3 CLS_CC); }
+	|	T_INCLUDE expr 			{ zend_do_include_or_eval(ZEND_INCLUDE, &$$, &$2 CLS_CC); }
+	|	T_INCLUDE_ONCE expr 	{ zend_do_include_or_eval(ZEND_INCLUDE_ONCE, &$$, &$2 CLS_CC); }
+	|	T_EVAL '(' expr ')' 	{ zend_do_include_or_eval(ZEND_EVAL, &$$, &$3 CLS_CC); }
+	|	T_REQUIRE expr			{ zend_do_include_or_eval(ZEND_REQUIRE, &$$, &$2 CLS_CC); }
+	|	T_REQUIRE_ONCE expr		{ zend_do_include_or_eval(ZEND_REQUIRE_ONCE, &$$, &$2 CLS_CC); }
+;
+
+
+%%
+

Zend/zend_language_scanner.h

@@ -0,0 +1,56 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_SCANNER_H
+#define ZEND_SCANNER_H
+
+#ifdef ZTS
+class ZendFlexLexer : public yyFlexLexer
+{
+public:
+	virtual ~ZendFlexLexer();
+	int lex_scan(zval *zendlval CLS_DC);
+	void BeginState(int state);
+};
+
+#endif	/* ZTS */
+
+
+typedef struct _zend_lex_state {
+#ifndef ZTS
+	YY_BUFFER_STATE buffer_state;
+	int state;
+	FILE *in;
+#else
+	ZendFlexLexer *ZFL;
+	istream *input_file;
+#endif
+	uint lineno;
+	char *filename;
+} zend_lex_state;
+
+
+void zend_fatal_scanner_error(char *);
+inline void restore_lexical_state(zend_lex_state * CLS_DC);
+BEGIN_EXTERN_C()
+int zend_compare_file_handles(zend_file_handle *fh1, zend_file_handle *fh2);
+END_EXTERN_C()
+
+#endif

Zend/zend_list.c

@@ -0,0 +1,418 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+/* resource lists */
+
+#include "zend.h"
+#include "zend_list.h"
+#include "zend_API.h"
+#include "zend_globals.h"
+
+ZEND_API int le_index_ptr;
+
+/* true global */
+static HashTable list_destructors;
+
+
+static inline int zend_list_do_insert(HashTable *list, void *ptr, int type, zend_bool valid)
+{
+	int index;
+	zend_rsrc_list_entry le;
+
+	index = zend_hash_next_free_element(list);
+
+	if (index==0) index++;
+
+	le.ptr=ptr;
+	le.type=type;
+	le.refcount=1;
+	le.valid = valid;
+	zend_hash_index_update(list, index, (void *) &le, sizeof(zend_rsrc_list_entry), NULL);
+	return index;
+}
+
+static inline int zend_list_do_delete(HashTable *list,int id)
+{
+	zend_rsrc_list_entry *le;
+	ELS_FETCH();
+	
+	if (zend_hash_index_find(&EG(regular_list), id, (void **) &le)==SUCCESS) {
+/*		printf("del(%d): %d->%d\n", id, le->refcount, le->refcount-1); */
+		if (--le->refcount<=0) {
+			return zend_hash_index_del(&EG(regular_list), id);
+		} else {
+			return SUCCESS;
+		}
+	} else {
+		return FAILURE;
+	}
+}
+
+
+static inline void *zend_list_do_find(HashTable *list,int id, int *type)
+{
+	zend_rsrc_list_entry *le;
+
+	if (zend_hash_index_find(list, id, (void **) &le)==SUCCESS) {
+		*type = le->type;
+		return le->ptr;
+	} else {
+		*type = -1;
+		return NULL;
+	}
+}
+
+
+ZEND_API int zend_list_insert(void *ptr, int type)
+{
+	ELS_FETCH();
+
+	return zend_list_do_insert(&EG(regular_list), ptr, type, 1);
+}
+
+
+ZEND_API int zend_plist_insert(void *ptr, int type)
+{
+	ELS_FETCH();
+
+	return zend_list_do_insert(&EG(persistent_list), ptr, type, 1);
+}
+
+
+ZEND_API int zend_list_addref(int id)
+{
+	zend_rsrc_list_entry *le;
+	ELS_FETCH();
+	
+	if (zend_hash_index_find(&EG(regular_list), id, (void **) &le)==SUCCESS) {
+/*		printf("add(%d): %d->%d\n", id, le->refcount, le->refcount+1); */
+		le->refcount++;
+		return SUCCESS;
+	} else {
+		return FAILURE;
+	}
+}
+
+
+ZEND_API int zend_list_delete(int id)
+{
+	ELS_FETCH();
+
+	return zend_list_do_delete(&EG(regular_list), id);
+}
+
+
+ZEND_API int zend_plist_delete(int id)
+{
+	ELS_FETCH();
+
+	return zend_list_do_delete(&EG(persistent_list), id);
+}
+
+
+ZEND_API int zend_list_convert_to_number(int id)
+{
+	zend_rsrc_list_entry *le;
+	ELS_FETCH();
+	
+	if (zend_hash_index_find(&EG(regular_list), id, (void **) &le)==SUCCESS
+		&& le->valid) {
+		return id;
+	}
+	return 0;
+}
+
+
+
+ZEND_API void *zend_list_find(int id, int *type)
+{
+	ELS_FETCH();
+
+	return zend_list_do_find(&EG(regular_list), id, type);
+}
+
+
+ZEND_API void *zend_plist_find(int id, int *type)
+{
+	ELS_FETCH();
+
+	return zend_list_do_find(&EG(persistent_list), id, type);
+}
+
+
+ZEND_API int zend_register_resource(zval *rsrc_result, void *rsrc_pointer, int rsrc_type)
+{
+	int rsrc_id;
+
+	rsrc_id = zend_list_insert(rsrc_pointer, rsrc_type);
+	
+	if (rsrc_result) {
+		rsrc_result->value.lval = rsrc_id;
+		rsrc_result->type = IS_RESOURCE;
+	}
+
+	return rsrc_id;
+}
+
+
+ZEND_API int zend_register_false_resource(zval *rsrc_result, void *rsrc_pointer, int rsrc_type)
+{
+	int rsrc_id;
+	ELS_FETCH();
+
+	rsrc_id = zend_list_do_insert(&EG(regular_list), rsrc_pointer, rsrc_type, 0);
+	
+	if (rsrc_result) {
+		rsrc_result->value.lval = rsrc_id;
+		rsrc_result->type = IS_RESOURCE;
+	}
+
+	return rsrc_id;
+}
+
+
+ZEND_API void *zend_fetch_resource(zval **passed_id, int default_id, char *resource_type_name, int *found_resource_type, int num_resource_types, ...)
+{
+	int id;
+	int actual_resource_type;
+	void *resource;
+	va_list resource_types;
+	int i;
+
+	if (default_id==-1) { /* use id */
+		if (!passed_id) {
+			if (resource_type_name) {
+				zend_error(E_WARNING, "No %s resource supplied", resource_type_name);
+			}
+			return NULL;
+		} else if ((*passed_id)->type != IS_RESOURCE) {
+			if (resource_type_name) {
+				zend_error(E_WARNING, "Supplied argument is not a valid %s resource", resource_type_name);
+			}
+			return NULL;
+		}
+		id = (*passed_id)->value.lval;
+	} else {
+		id = default_id;
+	}
+
+	resource = zend_list_find(id, &actual_resource_type);
+	if (!resource) {
+		if (resource_type_name) {
+			zend_error(E_WARNING, "%d is not a valid %s resource", id, resource_type_name);
+		}
+		return NULL;
+	}
+
+	va_start(resource_types, num_resource_types);
+	for (i=0; i<num_resource_types; i++) {
+		if (actual_resource_type == va_arg(resource_types, int)) {
+			va_end(resource_types);
+			if (found_resource_type) {
+				*found_resource_type = actual_resource_type;
+			}
+			return resource;
+		}
+	}
+	va_end(resource_types);
+
+	if (resource_type_name) {
+		zend_error(E_WARNING, "Supplied resource is not a valid %s resource", resource_type_name);
+	}
+
+	return NULL;
+}
+
+
+void list_entry_destructor(void *ptr)
+{
+	zend_rsrc_list_entry *le = (zend_rsrc_list_entry *) ptr;
+	zend_rsrc_list_dtors_entry *ld;
+	
+	if (zend_hash_index_find(&list_destructors, le->type,(void **) &ld)==SUCCESS) {
+		switch (ld->type) {
+			case ZEND_RESOURCE_LIST_TYPE_STD:
+				if (ld->list_dtor) {
+					(ld->list_dtor)(le->ptr);
+				}
+				break;
+			case ZEND_RESOURCE_LIST_TYPE_EX:
+				if (ld->list_dtor_ex) {
+					ld->list_dtor_ex(le);
+				}
+				break;
+			EMPTY_SWITCH_DEFAULT_CASE()
+		}
+	} else {
+		zend_error(E_WARNING,"Unknown list entry type in request shutdown (%d)",le->type);
+	}
+}
+
+
+void plist_entry_destructor(void *ptr)
+{
+	zend_rsrc_list_entry *le = (zend_rsrc_list_entry *) ptr;
+	zend_rsrc_list_dtors_entry *ld;
+
+	if (zend_hash_index_find(&list_destructors, le->type,(void **) &ld)==SUCCESS) {
+		if (ld->plist_dtor) {
+			(ld->plist_dtor)(le->ptr);
+		}
+	} else {
+		zend_error(E_WARNING,"Unknown persistent list entry type in module shutdown (%d)",le->type);
+	}
+}
+
+
+int zend_init_rsrc_list(ELS_D)
+{
+	return zend_hash_init(&EG(regular_list), 0, NULL, list_entry_destructor, 0);
+}
+
+
+int zend_init_rsrc_plist(ELS_D)
+{
+	return zend_hash_init_ex(&EG(persistent_list), 0, NULL, plist_entry_destructor, 1, 0);
+}
+
+
+void zend_destroy_rsrc_list(ELS_D)
+{
+	zend_hash_graceful_destroy(&EG(regular_list));
+}
+
+
+void zend_destroy_rsrc_plist(ELS_D)
+{
+	zend_hash_graceful_destroy(&EG(persistent_list));
+}
+
+
+static int clean_module_resource(zend_rsrc_list_entry *le, int *resource_id)
+{
+	if (le->type == *resource_id) {
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+
+static int zend_clean_module_rsrc_dtors_cb(zend_rsrc_list_dtors_entry *ld, int *module_number)
+{
+	if (ld->module_number == *module_number) {
+		ELS_FETCH();
+
+		zend_hash_apply_with_argument(&EG(regular_list), (int (*)(void *,void *)) clean_module_resource, (void *) &(ld->resource_id));
+		zend_hash_apply_with_argument(&EG(persistent_list), (int (*)(void *,void *)) clean_module_resource, (void *) &(ld->resource_id));
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+
+void zend_clean_module_rsrc_dtors(int module_number)
+{
+	zend_hash_apply_with_argument(&list_destructors, (int (*)(void *,void *)) zend_clean_module_rsrc_dtors_cb, (void *) &module_number);
+}
+
+
+ZEND_API int zend_register_list_destructors(void (*ld)(void *), void (*pld)(void *), int module_number)
+{
+	zend_rsrc_list_dtors_entry lde;
+	
+#if 0
+	printf("Registering destructors %d for module %d\n", list_destructors.nNextFreeElement, module_number);
+#endif
+	
+	lde.list_dtor=(void (*)(void *)) ld;
+	lde.plist_dtor=(void (*)(void *)) pld;
+	lde.list_dtor_ex = lde.plist_dtor_ex = NULL;
+	lde.module_number = module_number;
+	lde.resource_id = list_destructors.nNextFreeElement;
+	lde.type = ZEND_RESOURCE_LIST_TYPE_STD;
+	lde.type_name = NULL;
+	
+	if (zend_hash_next_index_insert(&list_destructors, (void *) &lde, sizeof(zend_rsrc_list_dtors_entry), NULL)==FAILURE) {
+		return FAILURE;
+	}
+	return list_destructors.nNextFreeElement-1;
+}
+
+
+ZEND_API int zend_register_list_destructors_ex(rsrc_dtor_func_t ld, rsrc_dtor_func_t pld, char *type_name, int module_number)
+{
+	zend_rsrc_list_dtors_entry lde;
+	
+#if 0
+	printf("Registering destructors %d for module %d\n", list_destructors.nNextFreeElement, module_number);
+#endif
+
+	lde.list_dtor = NULL;
+	lde.plist_dtor = NULL;
+	lde.list_dtor_ex = ld;
+	lde.plist_dtor_ex = pld;
+	lde.module_number = module_number;
+	lde.resource_id = list_destructors.nNextFreeElement;
+	lde.type = ZEND_RESOURCE_LIST_TYPE_EX;
+	lde.type_name = type_name;
+	
+	if (zend_hash_next_index_insert(&list_destructors,(void *) &lde, sizeof(zend_rsrc_list_dtors_entry),NULL)==FAILURE) {
+		return FAILURE;
+	}
+	return list_destructors.nNextFreeElement-1;
+}
+
+
+int zend_init_rsrc_list_dtors()
+{
+	return zend_hash_init(&list_destructors, 50, NULL, NULL, 1);
+}
+
+
+void zend_destroy_rsrc_list_dtors()
+{
+	zend_hash_destroy(&list_destructors);
+}
+
+
+char *zend_rsrc_list_get_rsrc_type(int resource)
+{
+	zend_rsrc_list_dtors_entry *lde;
+	int rsrc_type;
+
+	if (!zend_list_find(resource, &rsrc_type))
+		return NULL;
+
+	if (zend_hash_index_find(&list_destructors, rsrc_type, (void **) &lde)==SUCCESS) {
+		return lde->type_name;
+	} else {
+		return NULL;
+	}
+}
+
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */

Zend/zend_list.h

@@ -0,0 +1,109 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_LIST_H
+#define ZEND_LIST_H
+
+#include "zend_hash.h"
+#include "zend_globals.h"
+
+
+#define ZEND_RESOURCE_LIST_TYPE_STD	1
+#define ZEND_RESOURCE_LIST_TYPE_EX	2
+
+typedef struct _zend_rsrc_list_entry {
+	void *ptr;
+	int type;
+	int refcount;
+	zend_bool valid;
+} zend_rsrc_list_entry;
+
+typedef void (*rsrc_dtor_func_t)(zend_rsrc_list_entry *rsrc);
+#define ZEND_RSRC_DTOR_FUNC(name)		void name(zend_rsrc_list_entry *rsrc)
+
+typedef struct _zend_rsrc_list_dtors_entry {
+	/* old style destructors */
+	void (*list_dtor)(void *);
+	void (*plist_dtor)(void *);
+
+	/* new style destructors */
+	rsrc_dtor_func_t list_dtor_ex;
+	rsrc_dtor_func_t plist_dtor_ex;
+
+	char *type_name;
+
+	int module_number;
+	int resource_id;
+	unsigned char type;
+} zend_rsrc_list_dtors_entry;
+
+
+#define register_list_destructors(ld, pld) zend_register_list_destructors((void (*)(void *))ld, (void (*)(void *))pld, module_number);
+ZEND_API int zend_register_list_destructors(void (*ld)(void *), void (*pld)(void *), int module_number);
+ZEND_API int zend_register_list_destructors_ex(rsrc_dtor_func_t ld, rsrc_dtor_func_t pld, char *type_name, int module_number);
+
+enum list_entry_type {
+	LE_DB=1000
+};
+
+void list_entry_destructor(void *ptr);
+void plist_entry_destructor(void *ptr);
+
+void zend_clean_module_rsrc_dtors(int module_number);
+int zend_init_rsrc_list(ELS_D);
+int zend_init_rsrc_plist(ELS_D);
+void zend_destroy_rsrc_list(ELS_D);
+void zend_destroy_rsrc_plist(ELS_D);
+int zend_init_rsrc_list_dtors();
+void zend_destroy_rsrc_list_dtors();
+
+ZEND_API int zend_list_insert(void *ptr, int type);
+ZEND_API int zend_plist_insert(void *ptr, int type);
+ZEND_API int zend_list_addref(int id);
+ZEND_API int zend_list_delete(int id);
+ZEND_API int zend_plist_delete(int id);
+ZEND_API int zend_list_convert_to_number(int id);
+ZEND_API void *zend_list_find(int id, int *type);
+ZEND_API void *zend_plist_find(int id, int *type);
+
+ZEND_API int zend_register_resource(zval *rsrc_result, void *rsrc_pointer, int rsrc_type);
+ZEND_API void *zend_fetch_resource(zval **passed_id, int default_id, char *resource_type_name, int *found_resource_type, int num_resource_types, ...);
+
+ZEND_API char *zend_rsrc_list_get_rsrc_type(int resource);
+
+extern ZEND_API int le_index_ptr;  /* list entry type for index pointers */
+
+#define ZEND_VERIFY_RESOURCE(rsrc)		\
+	if (!rsrc) {						\
+		RETURN_NULL();					\
+	}
+
+#define ZEND_FETCH_RESOURCE(rsrc, rsrc_type, passed_id, default_id, resource_type_name, resource_type)	\
+	rsrc = (rsrc_type) zend_fetch_resource(passed_id, default_id, resource_type_name, NULL, 1, resource_type);	\
+	ZEND_VERIFY_RESOURCE(rsrc);
+
+#define ZEND_FETCH_RESOURCE2(rsrc, rsrc_type, passed_id, default_id, resource_type_name, resource_type1,resource_type2)	\
+	rsrc = (rsrc_type) zend_fetch_resource(passed_id, default_id, resource_type_name, NULL, 2, resource_type1, resource_type2);	\
+	ZEND_VERIFY_RESOURCE(rsrc);
+
+#define ZEND_REGISTER_RESOURCE(rsrc_result, rsrc_pointer, rsrc_type)  \
+    zend_register_resource(rsrc_result, rsrc_pointer, rsrc_type);
+
+#endif

Zend/zend_llist.c

@@ -0,0 +1,294 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#include "zend.h"
+#include "zend_llist.h"
+
+ZEND_API void zend_llist_init(zend_llist *l, size_t size, void (*dtor)(void *data), unsigned char persistent)
+{
+	l->head = NULL;
+	l->tail = NULL;
+	l->size = size;
+	l->dtor = dtor;
+	l->persistent = persistent;
+}
+
+
+ZEND_API void zend_llist_add_element(zend_llist *l, void *element)
+{
+	zend_llist_element *tmp = pemalloc(sizeof(zend_llist_element)+l->size-1, l->persistent);
+
+	tmp->prev = l->tail;
+	tmp->next = NULL;
+	if (l->tail) {
+		l->tail->next = tmp;
+	} else {
+		l->head = tmp;
+	}
+	l->tail = tmp;
+	memcpy(tmp->data, element, l->size);
+}
+
+
+ZEND_API void zend_llist_prepend_element(zend_llist *l, void *element)
+{
+	zend_llist_element *tmp = pemalloc(sizeof(zend_llist_element)+l->size-1, l->persistent);
+
+	tmp->next = l->head;
+	tmp->prev = NULL;
+	if (l->head) {
+		l->head->prev = tmp;
+	} else {
+		l->tail = tmp;
+	}
+	l->head = tmp;
+	memcpy(tmp->data, element, l->size);
+}
+
+
+#define DEL_LLIST_ELEMENT(current,l) \
+			if (current->prev) {\
+				current->prev->next = current->next;\
+			} else {\
+				l->head = current->next;\
+			}\
+			if (current->next) {\
+				current->next->prev = current->prev;\
+			} else {\
+				l->tail = current->prev;\
+			}\
+			if (l->dtor) {\
+				l->dtor(current->data);\
+				pefree(current, l->persistent);\
+			}
+
+
+ZEND_API void zend_llist_del_element(zend_llist *l, void *element, int (*compare)(void *element1, void *element2))
+{
+	zend_llist_element *current=l->head;
+
+	while (current) {
+		if (compare(current->data, element)) {
+			DEL_LLIST_ELEMENT(current,l);
+			break;
+		}
+		current = current->next;
+	}
+}
+
+
+ZEND_API void zend_llist_destroy(zend_llist *l)
+{
+	zend_llist_element *current=l->head, *next;
+	
+	while (current) {
+		next = current->next;
+		if (l->dtor) {
+			l->dtor(current->data);
+		}
+		pefree(current, l->persistent);
+		current = next;
+	}
+}
+
+
+ZEND_API void zend_llist_clean(zend_llist *l)
+{
+	zend_llist_destroy(l);
+	l->head = l->tail = NULL;
+}
+
+
+ZEND_API void zend_llist_remove_tail(zend_llist *l)
+{
+	zend_llist_element *old_tail;
+
+	if ((old_tail = l->tail)) {
+		if (l->tail->prev) {
+			l->tail->prev->next = NULL;
+		}
+		l->tail = l->tail->prev;
+		pefree(old_tail, l->persistent);
+	}
+}
+
+
+ZEND_API void zend_llist_copy(zend_llist *dst, zend_llist *src)
+{
+	zend_llist_element *ptr;
+
+	zend_llist_init(dst, src->size, src->dtor, src->persistent);
+	ptr = src->head;
+	while (ptr) {
+		zend_llist_add_element(dst, ptr->data);
+		ptr = ptr->next;
+	}
+}
+
+
+ZEND_API void zend_llist_apply_with_del(zend_llist *l, int (*func)(void *data))
+{
+	zend_llist_element *element, *next;
+
+	element=l->head;
+	while (element) {
+		next = element->next;
+		if (func(element->data)) {
+			DEL_LLIST_ELEMENT(element,l);
+		}
+		element = next;
+	}
+}
+
+
+ZEND_API void zend_llist_apply(zend_llist *l, void (*func)(void *data))
+{
+	zend_llist_element *element;
+
+	for (element=l->head; element; element=element->next) {
+		func(element->data);
+	}
+}
+
+ZEND_API void zend_llist_sort(zend_llist *l, llist_compare_func_t comp_func)
+{
+	int list_size=0, i;
+
+	zend_llist_element **elements;
+	zend_llist_element *element, **ptr;
+
+	for (element=l->head; element; element=element->next) {
+		list_size++;
+	}
+
+	if (list_size == 0) {
+		return;
+	}
+
+	elements = (zend_llist_element **) emalloc(list_size*sizeof(zend_llist_element *));
+
+	ptr = &elements[0];
+
+	for (element=l->head; element; element=element->next) {
+		*ptr++ = element;
+	}
+
+	qsort(elements, list_size, sizeof(zend_llist_element *), (int (*)(const void *, const void *)) comp_func);
+
+	l->head = elements[0];
+	elements[0]->prev = NULL;
+
+	for (i=1; i<list_size; i++) {
+		elements[i]->prev = elements[i-1];
+		elements[i-1]->next = elements[i];
+	}
+	elements[i-1]->next = NULL;
+	l->tail = elements[i-1];
+	efree(elements);
+}
+
+
+ZEND_API void zend_llist_apply_with_argument(zend_llist *l, void (*func)(void *data, void *arg), void *arg)
+{
+	zend_llist_element *element;
+
+	for (element=l->head; element; element=element->next) {
+		func(element->data, arg);
+	}
+}
+
+
+ZEND_API void zend_llist_apply_with_arguments(zend_llist *l, llist_apply_with_args_func_t func, int num_args, ...)
+{
+	zend_llist_element *element;
+	va_list args;
+
+	va_start(args, num_args);
+	for (element=l->head; element; element=element->next) {
+		func(element->data, num_args, args);
+	}
+	va_end(args);
+}
+
+
+ZEND_API int zend_llist_count(zend_llist *l)
+{
+	zend_llist_element *element;
+	int element_count=0;
+
+	for (element=l->head; element; element=element->next) {
+		element_count++;
+	}
+	return element_count;
+}
+
+
+ZEND_API void *zend_llist_get_first_ex(zend_llist *l, zend_llist_position *pos)
+{
+	zend_llist_position *current = pos ? pos : &l->traverse_ptr;
+
+	*current = l->head;
+	if (*current) {
+		return (*current)->data;
+	} else {
+		return NULL;
+	}
+}
+
+
+ZEND_API void *zend_llist_get_last_ex(zend_llist *l, zend_llist_position *pos)
+{
+	zend_llist_position *current = pos ? pos : &l->traverse_ptr;
+
+	*current = l->tail;
+	if (*current) {
+		return (*current)->data;
+	} else {
+		return NULL;
+	}
+}
+
+
+ZEND_API void *zend_llist_get_next_ex(zend_llist *l, zend_llist_position *pos)
+{
+	zend_llist_position *current = pos ? pos : &l->traverse_ptr;
+
+	if (*current) {
+		*current = (*current)->next;
+		if (*current) {
+			return (*current)->data;
+		}
+	}
+	return NULL;
+}
+
+
+ZEND_API void *zend_llist_get_prev_ex(zend_llist *l, zend_llist_position *pos)
+{
+	zend_llist_position *current = pos ? pos : &l->traverse_ptr;
+
+	if (*current) {
+		*current = (*current)->prev;
+		if (*current) {
+			return (*current)->data;
+		}
+	}
+	return NULL;
+}

Zend/zend_llist.h

@@ -0,0 +1,77 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_LLIST_H
+#define ZEND_LLIST_H
+
+#include <stdlib.h>
+
+typedef struct _zend_llist_element {
+	struct _zend_llist_element *next;
+	struct _zend_llist_element *prev;
+	char data[1]; /* Needs to always be last in the struct */
+} zend_llist_element;
+
+typedef struct _zend_llist {
+	zend_llist_element *head;
+	zend_llist_element *tail;
+	size_t size;
+	void (*dtor)(void *data);
+	unsigned char persistent;
+	zend_llist_element *traverse_ptr;
+} zend_llist;
+
+typedef int (*llist_compare_func_t)(const zend_llist_element *, const zend_llist_element *);
+typedef void(*llist_apply_with_arg_func_t)(void *data, void *arg);
+typedef void(*llist_apply_with_args_func_t)(void *data, int num_args, va_list args);
+typedef void (*llist_apply_func_t)(void *);
+
+typedef zend_llist_element* zend_llist_position;
+
+BEGIN_EXTERN_C()
+ZEND_API void zend_llist_init(zend_llist *l, size_t size, void (*dtor)(void *data), unsigned char persistent);
+ZEND_API void zend_llist_add_element(zend_llist *l, void *element);
+ZEND_API void zend_llist_prepend_element(zend_llist *l, void *element);
+ZEND_API void zend_llist_del_element(zend_llist *l, void *element, int (*compare)(void *element1, void *element2));
+ZEND_API void zend_llist_destroy(zend_llist *l);
+ZEND_API void zend_llist_clean(zend_llist *l);
+ZEND_API void zend_llist_remove_tail(zend_llist *l);
+ZEND_API void zend_llist_copy(zend_llist *dst, zend_llist *src);
+ZEND_API void zend_llist_apply(zend_llist *l, llist_apply_func_t);
+ZEND_API void zend_llist_apply_with_del(zend_llist *l, int (*func)(void *data));
+ZEND_API void zend_llist_apply_with_argument(zend_llist *l, llist_apply_with_arg_func_t, void *arg);
+ZEND_API void zend_llist_apply_with_arguments(zend_llist *l, llist_apply_with_args_func_t func, int num_args, ...);
+ZEND_API int zend_llist_count(zend_llist *l);
+ZEND_API void zend_llist_sort(zend_llist *l, llist_compare_func_t comp_func);
+
+/* traversal */
+ZEND_API void *zend_llist_get_first_ex(zend_llist *l, zend_llist_position *pos);
+ZEND_API void *zend_llist_get_last_ex(zend_llist *l, zend_llist_position *pos);
+ZEND_API void *zend_llist_get_next_ex(zend_llist *l, zend_llist_position *pos);
+ZEND_API void *zend_llist_get_prev_ex(zend_llist *l, zend_llist_position *pos);
+
+#define zend_llist_get_first(l) zend_llist_get_first_ex(l, NULL)
+#define zend_llist_get_last(l) zend_llist_get_last_ex(l, NULL)
+#define zend_llist_get_next(l) zend_llist_get_next_ex(l, NULL)
+#define zend_llist_get_prev(l) zend_llist_get_prev_ex(l, NULL)
+
+END_EXTERN_C()
+
+#endif /* ZEND_LLIST_H */

Zend/zend_modules.h

@@ -0,0 +1,85 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef MODULES_H
+#define MODULES_H
+
+#define INIT_FUNC_ARGS		int type, int module_number ELS_DC
+#define INIT_FUNC_ARGS_PASSTHRU	type, module_number ELS_CC
+#define SHUTDOWN_FUNC_ARGS	int type, int module_number
+#define SHUTDOWN_FUNC_ARGS_PASSTHRU type, module_number
+#define ZEND_MODULE_INFO_FUNC_ARGS zend_module_entry *zend_module
+#define ZEND_MODULE_INFO_FUNC_ARGS_PASSTHRU zend_module
+#define GINIT_FUNC_ARGS		void
+#define GINIT_FUNC_ARGS_PASSTHRU
+
+extern unsigned char first_arg_force_ref[];
+extern unsigned char first_arg_allow_ref[];
+extern unsigned char second_arg_force_ref[];
+extern unsigned char second_arg_allow_ref[];
+
+#include "zend.h"
+
+#define ZEND_MODULE_API_NO 20000809
+#ifdef ZTS
+#define USING_ZTS 1
+#else
+#define USING_ZTS 0
+#endif
+
+#define STANDARD_MODULE_PROPERTIES_EX 0, 0, 0, NULL, 0, ZEND_DEBUG, USING_ZTS, ZEND_MODULE_API_NO
+
+#define STANDARD_MODULE_PROPERTIES \
+	NULL, NULL, STANDARD_MODULE_PROPERTIES_EX
+
+#define MODULE_PERSISTENT 1
+#define MODULE_TEMPORARY 2
+
+typedef struct _zend_module_entry zend_module_entry;
+
+struct _zend_module_entry {
+	char *name;
+	zend_function_entry *functions;
+	int (*module_startup_func)(INIT_FUNC_ARGS);
+	int (*module_shutdown_func)(SHUTDOWN_FUNC_ARGS);
+	int (*request_startup_func)(INIT_FUNC_ARGS);
+	int (*request_shutdown_func)(SHUTDOWN_FUNC_ARGS);
+	void (*info_func)(ZEND_MODULE_INFO_FUNC_ARGS);
+	int (*global_startup_func)(void);
+	int (*global_shutdown_func)(void);
+	int globals_id;
+	int module_started;
+	unsigned char type;
+	void *handle;
+	int module_number;
+	unsigned char zend_debug;
+	unsigned char zts;
+	unsigned int zend_api;
+};
+
+
+extern ZEND_API HashTable module_registry;
+
+void module_destructor(zend_module_entry *module);
+int module_registry_cleanup(zend_module_entry *module);
+int module_registry_request_startup(zend_module_entry *module);
+
+#define ZEND_MODULE_DTOR (void (*)(void *)) module_destructor
+#endif

Zend/zend_opcode.c

@@ -0,0 +1,405 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#include <stdio.h>
+
+#include "zend.h"
+#include "zend_alloc.h"
+#include "zend_compile.h"
+#include "zend_extensions.h"
+#include "zend_API.h"
+
+
+static void zend_extension_op_array_ctor_handler(zend_extension *extension, zend_op_array *op_array)
+{
+	if (extension->op_array_ctor) {
+		extension->op_array_ctor(op_array);
+	}
+}
+
+
+static void zend_extension_op_array_dtor_handler(zend_extension *extension, zend_op_array *op_array)
+{
+	if (extension->op_array_dtor) {
+		extension->op_array_dtor(op_array);
+	}
+}
+
+
+static void op_array_alloc_ops(zend_op_array *op_array)
+{
+	op_array->opcodes = erealloc(op_array->opcodes, (op_array->size)*sizeof(zend_op));
+}
+
+
+
+void init_op_array(zend_op_array *op_array, int type, int initial_ops_size CLS_DC)
+{
+	op_array->type = type;
+#if SUPPORT_INTERACTIVE
+	{
+		ELS_FETCH();
+
+		op_array->start_op_number = op_array->end_op_number = op_array->last_executed_op_number = 0;
+		op_array->backpatch_count = 0;
+		if (EG(interactive)) {
+			/* We must avoid a realloc() on the op_array in interactive mode, since pointers to constants
+			 * will become invalid
+			 */
+			initial_ops_size = 8192;
+		}
+	}
+#endif
+
+	op_array->refcount = (zend_uint *) emalloc(sizeof(zend_uint));
+	*op_array->refcount = 1;
+	op_array->size = initial_ops_size;
+	op_array->last = 0;
+	op_array->opcodes = NULL;
+	op_array_alloc_ops(op_array);
+
+	op_array->T = 0;
+
+	op_array->function_name = NULL;
+	op_array->filename = zend_get_compiled_filename(CLS_C);
+
+	op_array->arg_types = NULL;
+
+	op_array->brk_cont_array = NULL;
+	op_array->last_brk_cont = 0;
+	op_array->current_brk_cont = -1;
+
+	op_array->static_variables = NULL;
+
+	op_array->uses_globals = 0;
+
+	op_array->return_reference = 0;
+	op_array->done_pass_two = 0;
+
+	zend_llist_apply_with_argument(&zend_extensions, (void (*)(void *, void *)) zend_extension_op_array_ctor_handler, op_array);
+}
+
+
+ZEND_API void destroy_zend_function(zend_function *function)
+{
+	switch (function->type) {
+		case ZEND_USER_FUNCTION:
+			destroy_op_array((zend_op_array *) function);
+			break;
+		case ZEND_INTERNAL_FUNCTION:
+			/* do nothing */
+			break;
+	}
+}
+
+
+ZEND_API void destroy_zend_class(zend_class_entry *ce)
+{
+	if (--(*ce->refcount)>0) {
+		return;
+	}
+	switch (ce->type) {
+		case ZEND_USER_CLASS:
+			efree(ce->name);
+			efree(ce->refcount);
+			zend_hash_destroy(&ce->function_table);
+			zend_hash_destroy(&ce->default_properties);
+			break;
+		case ZEND_INTERNAL_CLASS:
+			free(ce->name);
+			free(ce->refcount);
+			zend_hash_destroy(&ce->function_table);
+			zend_hash_destroy(&ce->default_properties);
+			break;
+	}
+}
+
+
+void zend_class_add_ref(zend_class_entry *ce)
+{
+	(*ce->refcount)++;
+}
+
+
+ZEND_API void destroy_op_array(zend_op_array *op_array)
+{
+	zend_op *opline = op_array->opcodes;
+	zend_op *end = op_array->opcodes+op_array->last;
+
+	if (op_array->static_variables) {
+		zend_hash_destroy(op_array->static_variables);
+		FREE_HASHTABLE(op_array->static_variables);
+	}
+
+	if (--(*op_array->refcount)>0) {
+		return;
+	}
+
+	efree(op_array->refcount);
+
+	while (opline<end) {
+		if (opline->op1.op_type==IS_CONST) {
+#if DEBUG_ZEND>2
+			printf("Reducing refcount for %x 1=>0 (destroying)\n", &opline->op1.u.constant);
+#endif
+			zval_dtor(&opline->op1.u.constant);
+		}
+		if (opline->op2.op_type==IS_CONST) {
+#if DEBUG_ZEND>2
+			printf("Reducing refcount for %x 1=>0 (destroying)\n", &opline->op2.u.constant);
+#endif
+			zval_dtor(&opline->op2.u.constant);
+		}
+		opline++;
+	}
+	efree(op_array->opcodes);
+	if (op_array->function_name) {
+		efree(op_array->function_name);
+	}
+	if (op_array->arg_types) {
+		efree(op_array->arg_types);
+	}
+	if (op_array->brk_cont_array) {
+		efree(op_array->brk_cont_array);
+	}
+	if (op_array->done_pass_two) {
+		zend_llist_apply_with_argument(&zend_extensions, (void (*)(void *, void *)) zend_extension_op_array_dtor_handler, op_array);
+	}
+}
+
+
+void init_op(zend_op *op CLS_DC)
+{
+	memset(&op->result, 0, sizeof(znode));
+	op->lineno = CG(zend_lineno);
+	SET_UNUSED(op->result);
+	op->extended_value = 0;
+	memset(&op->op1, 0, sizeof(znode));
+	memset(&op->op2, 0, sizeof(znode));
+}
+
+zend_op *get_next_op(zend_op_array *op_array CLS_DC)
+{
+	zend_uint next_op_num = op_array->last++;
+	zend_op *next_op;
+
+	if (next_op_num >= op_array->size) {
+#if SUPPORT_INTERACTIVE
+		ELS_FETCH();
+
+		if (EG(interactive)) {
+			/* we messed up */
+			zend_printf("Ran out of opcode space!\n"
+						"You should probably consider writing this huge script into a file!\n");
+			zend_bailout();
+		}
+#endif
+		op_array->size *= 4;
+		op_array_alloc_ops(op_array);
+	}
+	
+	next_op = &(op_array->opcodes[next_op_num]);
+	
+	init_op(next_op CLS_CC);
+
+	return next_op;
+}
+
+
+int get_next_op_number(zend_op_array *op_array)
+{
+	return op_array->last;
+}
+
+
+
+
+zend_brk_cont_element *get_next_brk_cont_element(zend_op_array *op_array)
+{
+	op_array->last_brk_cont++;
+	op_array->brk_cont_array = erealloc(op_array->brk_cont_array, sizeof(zend_brk_cont_element)*op_array->last_brk_cont);
+	return &op_array->brk_cont_array[op_array->last_brk_cont-1];
+}
+
+
+static void zend_update_extended_info(zend_op_array *op_array CLS_DC)
+{
+	zend_op *opline = op_array->opcodes, *end=opline+op_array->last;
+
+	while (opline<end) {
+		if (opline->opcode == ZEND_EXT_STMT) {
+			if (opline+1<end) {
+				if ((opline+1)->opcode == ZEND_EXT_STMT) {
+					opline->opcode = ZEND_NOP;
+					opline++;
+					continue;
+				}
+				opline->lineno = (opline+1)->lineno;
+			} else {
+				opline->opcode = ZEND_NOP;
+			}
+		}
+		opline++;
+	}
+	opline = get_next_op(op_array CLS_CC);
+	opline->opcode = ZEND_EXT_STMT;
+	SET_UNUSED(opline->op1);
+	SET_UNUSED(opline->op2);
+	if (op_array->last>0) {
+		opline->lineno= op_array->opcodes[op_array->last-2].lineno;
+	}
+}
+
+
+
+static void zend_extension_op_array_handler(zend_extension *extension, zend_op_array *op_array)
+{
+	if (extension->op_array_handler) {
+		extension->op_array_handler(op_array);
+	}
+}
+
+
+int pass_two(zend_op_array *op_array)
+{
+	zend_op *opline=op_array->opcodes, *end=opline+op_array->last;
+	CLS_FETCH();
+
+	if (op_array->type!=ZEND_USER_FUNCTION && op_array->type!=ZEND_EVAL_CODE) {
+		return 0;
+	}
+	if (CG(extended_info)) {
+		zend_update_extended_info(op_array CLS_CC);
+	}
+	if (CG(handle_op_arrays)) {
+		zend_llist_apply_with_argument(&zend_extensions, (void (*)(void *, void *)) zend_extension_op_array_handler, op_array);
+	}
+	while (opline<end) {
+		if (opline->op1.op_type==IS_CONST) {
+			opline->op1.u.constant.is_ref = 1;
+			opline->op1.u.constant.refcount = 2; /* Make sure is_ref won't be reset */
+		}
+		if (opline->op2.op_type==IS_CONST) {
+			opline->op2.u.constant.is_ref = 1;
+			opline->op2.u.constant.refcount = 2;
+		}
+		opline++;
+	}
+	op_array->opcodes = (zend_op *) erealloc(op_array->opcodes, sizeof(zend_op)*op_array->last);
+	op_array->size = op_array->last;
+	op_array->done_pass_two = 1;
+	return 0;
+}
+
+
+int print_class(zend_class_entry *class_entry)
+{
+	printf("Class %s:\n", class_entry->name);
+	zend_hash_apply(&class_entry->function_table, (int (*)(void *)) pass_two);
+	printf("End of class %s.\n\n", class_entry->name);
+	return 0;
+}
+
+ZEND_API unary_op_type get_unary_op(int opcode)
+{
+	switch(opcode) {
+		case ZEND_BW_NOT:
+			return (unary_op_type) bitwise_not_function;
+			break;
+		case ZEND_BOOL_NOT:
+			return (unary_op_type) boolean_not_function;
+			break;
+		default:
+			return (unary_op_type) NULL;
+			break;
+	}
+}
+
+
+ZEND_API void *get_binary_op(int opcode)
+{
+	switch (opcode) {
+		case ZEND_ADD:
+		case ZEND_ASSIGN_ADD:
+			return (void *) add_function;
+			break;
+		case ZEND_SUB:
+		case ZEND_ASSIGN_SUB:
+			return (void *) sub_function;
+			break;
+		case ZEND_MUL:
+		case ZEND_ASSIGN_MUL:
+			return (void *) mul_function;
+			break;
+		case ZEND_DIV:
+		case ZEND_ASSIGN_DIV:
+			return (void *) div_function;
+			break;
+		case ZEND_MOD:
+		case ZEND_ASSIGN_MOD:
+			return (void *) mod_function;
+			break;
+		case ZEND_SL:
+		case ZEND_ASSIGN_SL:
+			return (void *) shift_left_function;
+			break;
+		case ZEND_SR:
+		case ZEND_ASSIGN_SR:
+			return (void *) shift_right_function;
+			break;
+		case ZEND_CONCAT:
+		case ZEND_ASSIGN_CONCAT:
+			return (void *) concat_function;
+			break;
+		case ZEND_IS_IDENTICAL:
+			return (void *) is_identical_function;
+			break;
+		case ZEND_IS_NOT_IDENTICAL:
+			return (void *) is_not_identical_function;
+			break;
+		case ZEND_IS_EQUAL:
+			return (void *) is_equal_function;
+			break;
+		case ZEND_IS_NOT_EQUAL:
+			return (void *) is_not_equal_function;
+			break;
+		case ZEND_IS_SMALLER:
+			return (void *) is_smaller_function;
+			break;
+		case ZEND_IS_SMALLER_OR_EQUAL:
+			return (void *) is_smaller_or_equal_function;
+			break;
+		case ZEND_BW_OR:
+		case ZEND_ASSIGN_BW_OR:
+			return (void *) bitwise_or_function;
+			break;
+		case ZEND_BW_AND:
+		case ZEND_ASSIGN_BW_AND:
+			return (void *) bitwise_and_function;
+			break;
+		case ZEND_BW_XOR:
+		case ZEND_ASSIGN_BW_XOR:
+			return (void *) bitwise_xor_function;
+			break;
+		default:
+			return (void *) NULL;
+			break;
+	}
+}

Zend/zend_operators.h

@@ -0,0 +1,240 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_OPERATORS_H
+#define ZEND_OPERATORS_H
+
+#include <errno.h>
+#include <math.h>
+
+#ifdef HAVE_IEEEFP_H
+#include <ieeefp.h>
+#endif
+
+
+#if 0&&WITH_BCMATH
+#include "ext/bcmath/libbcmath/src/bcmath.h"
+#endif
+
+#define MAX_LENGTH_OF_LONG 18
+#define MAX_LENGTH_OF_DOUBLE 32
+
+ZEND_API int add_function(zval *result, zval *op1, zval *op2);
+ZEND_API int sub_function(zval *result, zval *op1, zval *op2);
+ZEND_API int mul_function(zval *result, zval *op1, zval *op2);
+ZEND_API int div_function(zval *result, zval *op1, zval *op2);
+ZEND_API int mod_function(zval *result, zval *op1, zval *op2);
+ZEND_API int boolean_or_function(zval *result, zval *op1, zval *op2);
+ZEND_API int boolean_xor_function(zval *result, zval *op1, zval *op2);
+ZEND_API int boolean_and_function(zval *result, zval *op1, zval *op2);
+ZEND_API int boolean_not_function(zval *result, zval *op1);
+ZEND_API int bitwise_not_function(zval *result, zval *op1);
+ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2);
+ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2);
+ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2);
+ZEND_API int shift_left_function(zval *result, zval *op1, zval *op2);
+ZEND_API int shift_right_function(zval *result, zval *op1, zval *op2);
+ZEND_API int concat_function(zval *result, zval *op1, zval *op2);
+
+ZEND_API int is_equal_function(zval *result, zval *op1, zval *op2);
+ZEND_API int is_identical_function(zval *result, zval *op1, zval *op2);
+ZEND_API int is_not_identical_function(zval *result, zval *op1, zval *op2);
+ZEND_API int is_not_equal_function(zval *result, zval *op1, zval *op2);
+ZEND_API int is_smaller_function(zval *result, zval *op1, zval *op2);
+ZEND_API int is_smaller_or_equal_function(zval *result, zval *op1, zval *op2);
+static inline int is_numeric_string(char *str, int length, long *lval, double *dval)
+{
+	long local_lval;
+	double local_dval;
+	char *end_ptr;
+
+	if (!length) {
+		return 0;
+	}
+	
+	errno=0;
+	local_lval = strtol(str, &end_ptr, 10);
+	if (errno!=ERANGE && end_ptr == str+length) { /* integer string */
+		if (lval) {
+			*lval = local_lval;
+		}
+		return IS_LONG;
+	}
+
+	errno=0;
+	local_dval = strtod(str, &end_ptr);
+	if (errno!=ERANGE && end_ptr == str+length) { /* floating point string */
+		if (! zend_finite(local_dval)) {
+			/* "inf","nan" and maybe other weird ones */
+			return 0;
+		}
+
+		if (dval) {
+			*dval = local_dval;
+		}
+#if 0&&WITH_BCMATH
+		if (length>16) {
+			register char *ptr=str, *end=str+length;
+			
+			while(ptr<end) {
+				switch(*ptr++) {
+					case 'e':
+					case 'E':
+						/* scientific notation, not handled by the BC library */
+						return IS_DOUBLE;
+						break;
+					default:
+						break;
+				}
+			}
+			return FLAG_IS_BC;
+		} else {
+			return IS_DOUBLE;
+		}
+#else
+		return IS_DOUBLE;
+#endif
+	}
+	
+	return 0;
+}
+
+ZEND_API int increment_function(zval *op1);
+ZEND_API int decrement_function(zval *op2);
+
+BEGIN_EXTERN_C()
+ZEND_API void convert_scalar_to_number(zval *op);
+ZEND_API void _convert_to_string(zval *op ZEND_FILE_LINE_DC);
+ZEND_API void convert_to_long(zval *op);
+ZEND_API void convert_to_double(zval *op);
+ZEND_API void convert_to_long_base(zval *op, int base);
+ZEND_API void convert_to_null(zval *op);
+ZEND_API void convert_to_boolean(zval *op);
+ZEND_API void convert_to_array(zval *op);
+ZEND_API void convert_to_object(zval *op);
+ZEND_API void multi_convert_to_long_ex(int argc, ...);
+ZEND_API void multi_convert_to_double_ex(int argc, ...);
+ZEND_API void multi_convert_to_string_ex(int argc, ...);
+ZEND_API int add_char_to_string(zval *result, zval *op1, zval *op2);
+ZEND_API int add_string_to_string(zval *result, zval *op1, zval *op2);
+#define convert_to_string(op)			_convert_to_string((op) ZEND_FILE_LINE_CC)
+
+ZEND_API double zend_string_to_double(const char *number, zend_uint length);
+END_EXTERN_C()
+
+ZEND_API int zval_is_true(zval *op);
+ZEND_API int compare_function(zval *result, zval *op1, zval *op2);
+ZEND_API int numeric_compare_function(zval *result, zval *op1, zval *op2);
+ZEND_API int string_compare_function(zval *result, zval *op1, zval *op2);
+
+ZEND_API void zend_str_tolower(char *str, unsigned int length);
+ZEND_API int zend_binary_zval_strcmp(zval *s1, zval *s2);
+ZEND_API int zend_binary_zval_strncmp(zval *s1, zval *s2, zval *s3);
+ZEND_API int zend_binary_zval_strcasecmp(zval *s1, zval *s2);
+ZEND_API int zend_binary_zval_strncasecmp(zval *s1, zval *s2, zval *s3);
+ZEND_API int zend_binary_strcmp(char *s1, uint len1, char *s2, uint len2);
+ZEND_API int zend_binary_strncmp(char *s1, uint len1, char *s2, uint len2, uint length);
+ZEND_API int zend_binary_strcasecmp(char *s1, uint len1, char *s2, uint len2);
+ZEND_API int zend_binary_strncasecmp(char *s1, uint len1, char *s2, uint len2, uint length);
+
+ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2);
+ZEND_API void zend_compare_symbol_tables(zval *result, HashTable *ht1, HashTable *ht2);
+ZEND_API void zend_compare_arrays(zval *result, zval *a1, zval *a2);
+ZEND_API void zend_compare_objects(zval *result, zval *o1, zval *o2);
+
+ZEND_API int zend_atoi(const char *str, int str_len);
+
+#define convert_to_ex_master(ppzv, lower_type, upper_type)	\
+	if ((*ppzv)->type!=IS_##upper_type) {					\
+		if (!(*ppzv)->is_ref) {								\
+			SEPARATE_ZVAL(ppzv);							\
+		}													\
+		convert_to_##lower_type(*ppzv);						\
+	}
+
+#define convert_to_writable_ex_master(ppzv, lower_type, upper_type)	\
+	if ((*ppzv)->type!=IS_##upper_type) {							\
+		SEPARATE_ZVAL(ppzv);										\
+		convert_to_##lower_type(*ppzv);								\
+	}
+
+
+#define convert_to_boolean_ex(ppzv)	convert_to_ex_master(ppzv, boolean, BOOL)
+#define convert_to_long_ex(ppzv)	convert_to_ex_master(ppzv, long, LONG)
+#define convert_to_double_ex(ppzv)	convert_to_ex_master(ppzv, double, DOUBLE)
+#define convert_to_string_ex(ppzv)	convert_to_ex_master(ppzv, string, STRING)
+#define convert_to_array_ex(ppzv)	convert_to_ex_master(ppzv, array, ARRAY)
+#define convert_to_object_ex(ppzv)	convert_to_ex_master(ppzv, object, OBJECT)
+#define convert_to_null_ex(ppzv)	convert_to_ex_master(ppzv, null, NULL)
+
+#define convert_to_writable_boolean_ex(ppzv)	convert_to_writable_ex_master(ppzv, boolean, BOOL)
+#define convert_to_writable_long_ex(ppzv)		convert_to_writable_ex_master(ppzv, long, LONG)
+#define convert_to_writable_double_ex(ppzv)		convert_to_writable_ex_master(ppzv, double, DOUBLE)
+#define convert_to_writable_string_ex(ppzv)		convert_to_writable_ex_master(ppzv, string, STRING)
+#define convert_to_writable_array_ex(ppzv)		convert_to_writable_ex_master(ppzv, array, ARRAY)
+#define convert_to_writable_object_ex(ppzv)		convert_to_writable_ex_master(ppzv, object, OBJECT)
+#define convert_to_writable_null_ex(ppzv)		convert_to_writable_ex_master(ppzv, null, NULL)
+
+
+#define convert_scalar_to_number_ex(ppzv)							\
+	if ((*ppzv)->type!=IS_LONG && (*ppzv)->type!=IS_DOUBLE) {		\
+		if (!(*ppzv)->is_ref) {										\
+			SEPARATE_ZVAL(ppzv);									\
+		}															\
+		convert_scalar_to_number(*ppzv);							\
+	}
+
+
+
+#define Z_LVAL(zval)		(zval).value.lval
+#define Z_BVAL(zval)		((zend_bool)(zval).value.lval)
+#define Z_DVAL(zval)		(zval).value.dval
+#define Z_STRVAL(zval)		(zval).value.str.val
+#define Z_STRLEN(zval)		(zval).value.str.len
+#define Z_ARRVAL(zval)		(zval).value.ht
+#define Z_OBJPROP(zval)		(zval).value.obj.properties
+#define Z_OBJCE(zval)		(zval).value.obj.ce
+#define Z_RESVAL(zval)		(zval).value.lval
+
+#define Z_LVAL_P(zval_p)		Z_LVAL(*zval_p)
+#define Z_BVAL_P(zval_p)		Z_BVAL(*zval_p)
+#define Z_DVAL_P(zval_p)		Z_DVAL(*zval_p)
+#define Z_STRVAL_P(zval_p)		Z_STRVAL(*zval_p)
+#define Z_STRLEN_P(zval_p)		Z_STRLEN(*zval_p)
+#define Z_ARRVAL_P(zval_p)		Z_ARRVAL(*zval_p)
+#define Z_OBJPROP_P(zval_p)		Z_OBJPROP(*zval_p)
+#define Z_OBJCE_P(zval_p)		Z_OBJCE(*zval_p)
+#define Z_RESVAL_P(zval_p)		Z_RESVAL(*zval_p)
+
+#define Z_LVAL_PP(zval_pp)		Z_LVAL(**zval_pp)
+#define Z_BVAL_PP(zval_pp)		Z_BVAL(**zval_pp)
+#define Z_DVAL_PP(zval_pp)		Z_DVAL(**zval_pp)
+#define Z_STRVAL_PP(zval_pp)	Z_STRVAL(**zval_pp)
+#define Z_STRLEN_PP(zval_pp)	Z_STRLEN(**zval_pp)
+#define Z_ARRVAL_PP(zval_pp)	Z_ARRVAL(**zval_pp)
+#define Z_OBJPROP_PP(zval_pp)	Z_OBJPROP(**zval_pp)
+#define Z_OBJCE_PP(zval_pp)		Z_OBJCE(**zval_pp)
+#define Z_RESVAL_PP(zval_pp)	Z_RESVAL(**zval_pp)
+
+#define Z_TYPE(zval)		(zval).type
+#define Z_TYPE_P(zval_p)	Z_TYPE(*zval_p)
+#define Z_TYPE_PP(zval_pp)	Z_TYPE(**zval_pp)
+
+#endif

Zend/zend_ptr_stack.c

@@ -0,0 +1,125 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#include "zend.h"
+#include "zend_ptr_stack.h"
+#ifdef HAVE_STDARG_H
+# include <stdarg.h>
+#endif
+
+ZEND_API void zend_ptr_stack_init(zend_ptr_stack *stack)
+{
+	stack->top_element = stack->elements = (void **) emalloc(sizeof(void *)*PTR_STACK_BLOCK_SIZE);
+	stack->max = PTR_STACK_BLOCK_SIZE;
+	stack->top = 0;
+}
+
+
+ZEND_API inline void zend_ptr_stack_push(zend_ptr_stack *stack, void *ptr)
+{
+	if (stack->top >= stack->max) {		/* we need to allocate more memory */
+		stack->elements = (void **) erealloc(stack->elements, (sizeof(void *) * (stack->max *= 2 )));
+		stack->top_element = stack->elements+stack->top;
+	}
+	stack->top++;
+	*(stack->top_element++) = ptr;
+}
+
+ZEND_API void zend_ptr_stack_n_push(zend_ptr_stack *stack, int count, ...)
+{
+	va_list ptr;
+	void *elem;
+	
+	if (stack->top+count > stack->max) {		/* we need to allocate more memory */
+		stack->max *= 2;
+		stack->max += count; 
+		stack->elements = (void **) erealloc(stack->elements, (sizeof(void *) * (stack->max)));
+		stack->top_element = stack->elements+stack->top;
+	}
+	va_start(ptr, count);
+	while (count>0) {
+		elem = va_arg(ptr, void *);
+		stack->top++;
+		*(stack->top_element++) = elem;
+		count--;
+	}
+	va_end(ptr);
+}
+
+
+ZEND_API void zend_ptr_stack_n_pop(zend_ptr_stack *stack, int count, ...)
+{
+	va_list ptr;
+	void **elem;
+	
+	va_start(ptr, count);
+	while (count>0) {
+		elem = va_arg(ptr, void **);
+		*elem = *(--stack->top_element);
+		stack->top--;
+		count--;
+	}
+	va_end(ptr);
+}
+
+ZEND_API inline void *zend_ptr_stack_pop(zend_ptr_stack *stack)
+{
+	stack->top--;
+	return *(--stack->top_element);
+}
+
+
+ZEND_API void zend_ptr_stack_destroy(zend_ptr_stack *stack)
+{
+	if (stack->elements) {
+		efree(stack->elements);
+	}
+}
+
+
+ZEND_API void zend_ptr_stack_apply(zend_ptr_stack *stack, void (*func)(void *))
+{
+	int i = stack->top;
+
+	while (--i >= 0) {
+		func(stack->elements[i]);
+	}
+}
+
+
+ZEND_API void zend_ptr_stack_clean(zend_ptr_stack *stack, void (*func)(void *), zend_bool free_elements)
+{
+	zend_ptr_stack_apply(stack, func);
+	if (free_elements) {
+		int i = stack->top;
+
+		while (--i >= 0) {
+			efree(stack->elements[i]);
+		}
+	}
+	stack->top = 0;
+	stack->top_element = stack->elements;
+}
+
+
+ZEND_API int zend_ptr_stack_num_elements(zend_ptr_stack *stack)
+{
+	return stack->top;
+}

Zend/zend_ptr_stack.h

@@ -0,0 +1,43 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_PTR_STACK_H
+#define ZEND_PTR_STACK_H
+
+typedef struct _zend_ptr_stack {
+	int top, max;
+	void **elements;
+	void **top_element;
+} zend_ptr_stack;
+
+
+#define PTR_STACK_BLOCK_SIZE 64
+
+ZEND_API void zend_ptr_stack_init(zend_ptr_stack *stack);
+ZEND_API void zend_ptr_stack_push(zend_ptr_stack *stack, void *ptr);
+ZEND_API void zend_ptr_stack_n_push(zend_ptr_stack *stack, int count, ...);
+ZEND_API void *zend_ptr_stack_pop(zend_ptr_stack *stack);
+ZEND_API void zend_ptr_stack_n_pop(zend_ptr_stack *stack, int count, ...);
+ZEND_API void zend_ptr_stack_destroy(zend_ptr_stack *stack);
+ZEND_API void zend_ptr_stack_apply(zend_ptr_stack *stack, void (*func)(void *));
+ZEND_API void zend_ptr_stack_clean(zend_ptr_stack *stack, void (*func)(void *), zend_bool free_elements);
+ZEND_API int zend_ptr_stack_num_elements(zend_ptr_stack *stack);
+
+#endif /* ZEND_PTR_STACK_H */

Zend/zend_sprintf.c

@@ -0,0 +1,40 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#include <stdio.h>
+
+#include "zend.h"
+
+#ifdef HAVE_STDARG_H
+# include <stdarg.h>
+#endif
+
+#if ZEND_BROKEN_SPRINTF
+int zend_sprintf(char *buffer, const char *format, ...)
+{
+	va_list args;
+
+	va_start(args, format);
+	vsprintf(buffer, format, args);
+	va_end(args);
+
+	return strlen(buffer);
+}
+#endif

Zend/zend_stack.c

@@ -0,0 +1,164 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#include "zend.h"
+#include "zend_stack.h"
+
+ZEND_API int zend_stack_init(zend_stack *stack)
+{
+	stack->top = 0;
+	stack->elements = (void **) emalloc(sizeof(void **) * STACK_BLOCK_SIZE);
+	if (!stack->elements) {
+		return FAILURE;
+	} else {
+		stack->max = STACK_BLOCK_SIZE;
+		return SUCCESS;
+	}
+}
+
+ZEND_API int zend_stack_push(zend_stack *stack, void *element, int size)
+{
+	if (stack->top >= stack->max) {		/* we need to allocate more memory */
+		stack->elements = (void **) erealloc(stack->elements,
+				   (sizeof(void **) * (stack->max += STACK_BLOCK_SIZE)));
+		if (!stack->elements) {
+			return FAILURE;
+		}
+	}
+	stack->elements[stack->top] = (void *) emalloc(size);
+	memcpy(stack->elements[stack->top], element, size);
+	return stack->top++;
+}
+
+
+ZEND_API int zend_stack_top(zend_stack *stack, void **element)
+{
+	if (stack->top > 0) {
+		*element = stack->elements[stack->top - 1];
+		return SUCCESS;
+	} else {
+		*element = NULL;
+		return FAILURE;
+	}
+}
+
+
+ZEND_API int zend_stack_del_top(zend_stack *stack)
+{
+	if (stack->top > 0) {
+		efree(stack->elements[--stack->top]);
+	}
+	return SUCCESS;
+}
+
+
+ZEND_API int zend_stack_int_top(zend_stack *stack)
+{
+	int *e;
+
+	if (zend_stack_top(stack, (void **) &e) == FAILURE) {
+		return FAILURE;			/* this must be a negative number, since negative numbers can't be address numbers */
+	} else {
+		return *e;
+	}
+}
+
+
+ZEND_API int zend_stack_is_empty(zend_stack *stack)
+{
+	if (stack->top == 0) {
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+
+ZEND_API int zend_stack_destroy(zend_stack *stack)
+{
+	register int i;
+
+	for (i = 0; i < stack->top; i++) {
+		efree(stack->elements[i]);
+	}
+
+	if (stack->elements) {
+		efree(stack->elements);
+	}
+	return SUCCESS;
+}
+
+
+ZEND_API void **zend_stack_base(zend_stack *stack)
+{
+	return stack->elements;
+}
+
+
+ZEND_API int zend_stack_count(zend_stack *stack)
+{
+	return stack->top;
+}
+
+
+ZEND_API void zend_stack_apply(zend_stack *stack, int type, int (*apply_function)(void *element))
+{
+	int i;
+
+	switch (type) {
+		case ZEND_STACK_APPLY_TOPDOWN:
+			for (i=stack->top-1; i>=0; i--) {
+				if (apply_function(stack->elements[i])) {
+					break;
+				}
+			}
+			break;
+		case ZEND_STACK_APPLY_BOTTOMUP:
+			for (i=0; i<stack->top; i++) {
+				if (apply_function(stack->elements[i])) {
+					break;
+				}
+			}
+			break;
+	}
+}
+
+
+ZEND_API void zend_stack_apply_with_argument(zend_stack *stack, int type, int (*apply_function)(void *element, void *arg), void *arg)
+{
+	int i;
+
+	switch (type) {
+		case ZEND_STACK_APPLY_TOPDOWN:
+			for (i=stack->top-1; i>=0; i--) {
+				if (apply_function(stack->elements[i], arg)) {
+					break;
+				}
+			}
+			break;
+		case ZEND_STACK_APPLY_BOTTOMUP:
+			for (i=0; i<stack->top; i++) {
+				if (apply_function(stack->elements[i], arg)) {
+					break;
+				}
+			}
+			break;
+	}
+}

Zend/zend_stack.h

@@ -0,0 +1,47 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_STACK_H
+#define ZEND_STACK_H
+
+typedef struct _zend_stack {
+	int top, max;
+	void **elements;
+} zend_stack;
+
+
+#define STACK_BLOCK_SIZE 64
+
+ZEND_API int zend_stack_init(zend_stack *stack);
+ZEND_API int zend_stack_push(zend_stack *stack, void *element, int size);
+ZEND_API int zend_stack_top(zend_stack *stack, void **element);
+ZEND_API int zend_stack_del_top(zend_stack *stack);
+ZEND_API int zend_stack_int_top(zend_stack *stack);
+ZEND_API int zend_stack_is_empty(zend_stack *stack);
+ZEND_API int zend_stack_destroy(zend_stack *stack);
+ZEND_API void **zend_stack_base(zend_stack *stack);
+ZEND_API int zend_stack_count(zend_stack *stack);
+ZEND_API void zend_stack_apply(zend_stack *stack, int type, int (*apply_function)(void *element));
+ZEND_API void zend_stack_apply_with_argument(zend_stack *stack, int type, int (*apply_function)(void *element, void *arg), void *arg);
+
+#define ZEND_STACK_APPLY_TOPDOWN	1
+#define ZEND_STACK_APPLY_BOTTOMUP	2
+
+#endif /* ZEND_STACK_H */

Zend/zend_static_allocator.c

@@ -0,0 +1,76 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+#include <stdlib.h>
+
+#include "zend_static_allocator.h"
+
+/* Not checking emalloc() and erealloc() return values as they are supposed to bailout */
+
+inline static void block_init(Block *block, zend_uint block_size)
+{
+	block->pos = block->bp = (char *) emalloc(block_size);
+	block->end = block->bp + block_size;
+}
+
+inline static char *block_allocate(Block *block, zend_uint size)
+{
+	char *retval = block->pos;
+	if ((block->pos += size) >= block->end) {
+		return (char *)NULL;
+	}
+	return retval;
+}
+
+inline static void block_destroy(Block *block)
+{
+	efree(block->bp);
+}
+
+void static_allocator_init(StaticAllocator *sa)
+{
+	sa->Blocks = (Block *) emalloc(sizeof(Block));
+	block_init(sa->Blocks, ALLOCATOR_BLOCK_SIZE);
+	sa->num_blocks = 1;
+	sa->current_block = 0;
+}
+
+char *static_allocator_allocate(StaticAllocator *sa, zend_uint size)
+{
+	char *retval;
+
+	retval = block_allocate(&sa->Blocks[sa->current_block], size);
+	if (retval) {
+		return retval;
+	}
+	sa->Blocks = (Block *) erealloc(sa->Blocks, ++sa->num_blocks);
+	sa->current_block++;
+	block_init(&sa->Blocks[sa->current_block], (size > ALLOCATOR_BLOCK_SIZE) ? size : ALLOCATOR_BLOCK_SIZE);
+	retval = block_allocate(&sa->Blocks[sa->current_block], size);
+	return retval;
+}
+
+void static_allocator_destroy(StaticAllocator *sa)
+{
+	zend_uint i;
+
+	for (i=0; i<sa->num_blocks; i++) {
+		block_free(&sa->Blocks[i]);
+	}
+	efree(sa->Blocks);
+}

Zend/zend_static_allocator.h

@@ -0,0 +1,45 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+#ifndef ZEND_STATIC_ALLOCATOR_H
+#define ZEND_STATIC_ALLOCATOR_H
+
+#define ALLOCATOR_BLOCK_SIZE 400000
+
+/* Temporary */
+typedef unsigned int zend_uint;
+#define emalloc(s) malloc(s)
+#define efree(p) free(p)
+
+typedef struct _Block {
+	char *bp;
+	char *pos;
+	char *end;
+} Block;
+
+typedef struct _StaticAllocator {
+	Block *Blocks;
+	zend_uint num_blocks;
+	zend_uint current_block;
+} StaticAllocator;
+
+void static_allocator_init(StaticAllocator *sa);
+char *static_allocator_allocate(StaticAllocator *sa, zend_uint size);
+void static_allocator_destroy(StaticAllocator *sa);
+
+#endif /* ZEND_STATIC_ALLOCATOR_H */

Zend/zend_variables.c

@@ -0,0 +1,192 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#include <stdio.h>
+#include "zend.h"
+#include "zend_API.h"
+#include "zend_globals.h"
+#include "zend_constants.h"
+#include "zend_list.h"
+
+ZEND_API char *empty_string = "";	/* in order to save emalloc() and efree() time for
+									 * empty strings (usually used to denote empty
+									 * return values in failed functions).
+									 * The macro STR_FREE() will not efree() it.
+									 */
+
+/* this function MUST set the value for the variable to an empty string */
+/* and empty strings must be evaluated as FALSE */
+ZEND_API inline void var_reset(zval *var)
+{
+#if 0
+	var->type = IS_STRING;
+	var->value.str.val = empty_string;
+	var->value.str.len = 0;
+#else
+	var->type = IS_BOOL;
+	var->value.lval = 0;
+#endif
+}
+
+ZEND_API inline void var_uninit(zval *var)
+{
+	var->type = IS_NULL;
+}
+		
+
+ZEND_API void _zval_dtor(zval *zvalue ZEND_FILE_LINE_DC)
+{
+	if (zvalue->type==IS_LONG) {
+		return;
+	}
+	switch(zvalue->type) {
+		case IS_STRING:
+		case IS_CONSTANT:
+			STR_FREE_REL(zvalue->value.str.val);
+			break;
+		case IS_ARRAY:
+		case IS_CONSTANT_ARRAY: {
+				ELS_FETCH();
+
+				if (zvalue->value.ht && (zvalue->value.ht != &EG(symbol_table))) {
+					zend_hash_destroy(zvalue->value.ht);
+					FREE_HASHTABLE(zvalue->value.ht);
+				}
+			}
+			break;
+		case IS_OBJECT:
+			zend_hash_destroy(zvalue->value.obj.properties);
+			FREE_HASHTABLE(zvalue->value.obj.properties);
+			break;
+		case IS_RESOURCE:
+			/* destroy resource */
+			zend_list_delete(zvalue->value.lval);
+			break;
+		case IS_LONG:
+		case IS_DOUBLE:
+		case IS_BOOL:
+		case IS_NULL:
+		default:
+			return;
+			break;
+	}
+}
+
+
+ZEND_API void zval_del_ref(zval **p)
+{
+	(*p)->refcount--;
+	if ((*p)->refcount==0) {
+		zval_dtor(*p);
+		FREE_ZVAL(*p);
+	}
+}                                                                                                                               
+
+
+ZEND_API void zval_add_ref(zval **p)
+{
+	(*p)->refcount++;
+}
+
+
+ZEND_API int _zval_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
+{
+	switch (zvalue->type) {
+		case IS_RESOURCE:
+			zend_list_addref(zvalue->value.lval);
+			break;
+		case IS_BOOL:
+		case IS_LONG:
+		case IS_NULL:
+			break;
+		case IS_CONSTANT:
+		case IS_STRING:
+			if (zvalue->value.str.val) {
+				if (zvalue->value.str.len==0) {
+					zvalue->value.str.val = empty_string;
+					return SUCCESS;
+				}
+			}
+			zvalue->value.str.val = (char *) estrndup_rel(zvalue->value.str.val, zvalue->value.str.len);
+			break;
+		case IS_ARRAY:
+		case IS_CONSTANT_ARRAY: {
+				zval *tmp;
+				HashTable *original_ht = zvalue->value.ht;
+				ELS_FETCH();
+
+				if (!zvalue->value.ht) {
+					var_reset(zvalue);
+					return FAILURE;
+				} else if (zvalue->value.ht==&EG(symbol_table)) {
+					return SUCCESS; /* do nothing */
+				}
+				ALLOC_HASHTABLE_REL(zvalue->value.ht);
+				zend_hash_init(zvalue->value.ht, 0, NULL, ZVAL_PTR_DTOR, 0);
+				zend_hash_copy(zvalue->value.ht, original_ht, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
+			}
+			break;
+		case IS_OBJECT: {
+				zval *tmp;
+				HashTable *original_ht = zvalue->value.obj.properties;
+
+				ALLOC_HASHTABLE_REL(zvalue->value.obj.properties);
+				zend_hash_init(zvalue->value.obj.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
+				zend_hash_copy(zvalue->value.obj.properties, original_ht, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
+			}
+			break;
+	}
+	return SUCCESS;
+}
+
+
+ZEND_API int zend_print_variable(zval *var) 
+{
+	return zend_print_zval(var, 0);
+}
+
+
+#if ZEND_DEBUG
+ZEND_API int _zval_copy_ctor_wrapper(zval *zvalue)
+{
+	return zval_copy_ctor(zvalue);
+}
+
+
+ZEND_API void _zval_dtor_wrapper(zval *zvalue)
+{
+	zval_dtor(zvalue);
+}
+
+
+
+ZEND_API void _zval_ptr_dtor_wrapper(zval **zval_ptr)
+{
+	zval_ptr_dtor(zval_ptr);
+}
+#endif
+
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ */

Zend/zend_variables.h

@@ -0,0 +1,61 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2000 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 0.92 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        | 
+   | available at through the world-wide-web at                           |
+   | http://www.zend.com/license/0_92.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+
+#ifndef ZEND_VARIABLES_H
+#define ZEND_VARIABLES_H
+
+
+ZEND_API int zend_print_variable(zval *var);
+
+BEGIN_EXTERN_C()
+ZEND_API int _zval_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC);
+ZEND_API void _zval_dtor(zval *zvalue ZEND_FILE_LINE_DC);
+ZEND_API void _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC);
+#define zval_copy_ctor(zvalue) _zval_copy_ctor((zvalue) ZEND_FILE_LINE_CC)
+#define zval_dtor(zvalue) _zval_dtor((zvalue) ZEND_FILE_LINE_CC)
+#define zval_ptr_dtor(zval_ptr) _zval_ptr_dtor((zval_ptr) ZEND_FILE_LINE_CC)
+
+#if ZEND_DEBUG
+ZEND_API int _zval_copy_ctor_wrapper(zval *zvalue);
+ZEND_API void _zval_dtor_wrapper(zval *zvalue);
+ZEND_API void _zval_ptr_dtor_wrapper(zval **zval_ptr);
+#define zval_copy_ctor_wrapper _zval_copy_ctor_wrapper
+#define zval_dtor_wrapper _zval_dtor_wrapper
+#define zval_ptr_dtor_wrapper _zval_ptr_dtor_wrapper
+#else
+#define zval_copy_ctor_wrapper _zval_copy_ctor
+#define zval_dtor_wrapper _zval_dtor
+#define zval_ptr_dtor_wrapper _zval_ptr_dtor
+#endif
+
+END_EXTERN_C()
+
+
+ZEND_API void zval_add_ref(zval **p);
+ZEND_API void zval_del_ref(zval **p);
+
+#define ZVAL_DESTRUCTOR (void (*)(void *)) zval_dtor_wrapper
+#define ZVAL_PTR_DTOR (void (*)(void *)) zval_ptr_dtor_wrapper
+#define ZVAL_COPY_CTOR (void (*)(void *)) zval_copy_ctor_wrapper
+
+ZEND_API void var_reset(zval *var);
+ZEND_API void var_uninit(zval *var);
+
+#endif

acinclude.m4

@@ -4,84 +4,6 @@ dnl This file contains local autoconf functions.
 
 sinclude(dynlib.m4)
 
-dnl
-dnl PHP_TARGET_RDYNAMIC
-dnl
-dnl Checks whether -rdynamic is supported by the compiler.  This
-dnl is necessary for some targets to populate the global symbol
-dnl table.  Otherwise, dynamic modules would not be able to resolve
-dnl PHP-related symbols.
-dnl
-dnl If successful, adds -rdynamic to PHP_LDFLAGS.
-dnl
-AC_DEFUN(PHP_TARGET_RDYNAMIC,[
-  if test -n "$GCC"; then
-    dnl we should use a PHP-specific macro here
-    TSRM_CHECK_GCC_ARG(-rdynamic, gcc_rdynamic=yes)
-    if test "$gcc_rdynamic" = "yes"; then
-      PHP_LDFLAGS="$PHP_LDFLAGS -rdynamic"
-    fi
-  fi
-])
-
-AC_DEFUN(PHP_REMOVE_USR_LIB,[
-  unset ac_new_flags
-  for i in [$]$1; do
-    case [$]i in
-    -L/usr/lib|-L/usr/lib/) ;;
-    *) ac_new_flags="[$]ac_new_flags [$]i" ;;
-    esac
-  done
-  $1=[$]ac_new_flags
-])
-    
-AC_DEFUN(PHP_SETUP_OPENSSL,[
-  if test "$PHP_OPENSSL" = "no"; then
-    PHP_OPENSSL="/usr/local/ssl /usr/local /usr /usr/local/openssl"
-  fi
-
-  for i in $PHP_OPENSSL; do
-    if test -r $i/include/openssl/evp.h; then
-      OPENSSL_DIR=$i
-      OPENSSL_INC=$i/include
-    fi
-  done
-
-  if test -z "$OPENSSL_DIR"; then
-    AC_MSG_ERROR(Cannot find OpenSSL's <evp.h>)
-  fi
-
-  old_CPPFLAGS=$CPPFLAGS
-  CPPFLAGS=-I$OPENSSL_INC
-  AC_MSG_CHECKING(for OpenSSL version)
-  AC_EGREP_CPP(yes,[
-  #include <openssl/opensslv.h>
-  #if OPENSSL_VERSION_NUMBER >= 0x0090500fL
-  yes
-  #endif
-  ],[
-    AC_MSG_RESULT(>= 0.9.5)
-  ],[
-    AC_MSG_ERROR(OpenSSL version 0.9.5 or greater required.)
-  ])
-  CPPFLAGS=$old_CPPFLAGS
-
-  PHP_ADD_LIBPATH($OPENSSL_DIR/lib)
-
-  AC_CHECK_LIB(crypto, CRYPTO_free, [
-    PHP_ADD_LIBRARY(crypto)
-  ],[
-    AC_MSG_ERROR(libcrypto not found!)
-  ])
-
-  AC_CHECK_LIB(ssl, SSL_CTX_set_ssl_version, [
-    PHP_ADD_LIBRARY(ssl)
-  ],[
-    AC_MSG_ERROR(libssl not found!)
-  ])
-  PHP_ADD_INCLUDE($OPENSSL_INC)
-])
-
 dnl PHP_EVAL_LIBLINE(LINE, SHARED-LIBADD)
 dnl
 dnl Use this macro, if you need to add libraries and or library search
@@ -90,14 +12,14 @@ dnl notation.
 dnl
 AC_DEFUN(PHP_EVAL_LIBLINE,[
   for ac_i in $1; do
-    case $ac_i in
+    case "$ac_i" in
     -l*)
       ac_ii=`echo $ac_i|cut -c 3-`
-      PHP_ADD_LIBRARY($ac_ii,,$2)
+      AC_ADD_LIBRARY($ac_ii,,$2)
     ;;
     -L*)
       ac_ii=`echo $ac_i|cut -c 3-`
-      PHP_ADD_LIBPATH($ac_ii,$2)
+      AC_ADD_LIBPATH($ac_ii,$2)
     ;;
     esac
   done
@@ -110,10 +32,10 @@ dnl build system which are only given in compiler notation.
 dnl
 AC_DEFUN(PHP_EVAL_INCLINE,[
   for ac_i in $1; do
-    case $ac_i in
+    case "$ac_i" in
     -I*)
       ac_ii=`echo $ac_i|cut -c 3-`
-      PHP_ADD_INCLUDE($ac_ii)
+      AC_ADD_INCLUDE($ac_ii)
     ;;
     esac
   done
@@ -162,7 +84,7 @@ int readdir_r(DIR *, struct dirent *);
       ac_cv_what_readdir_r=none
    ])
   ])
-    case $ac_cv_what_readdir_r in
+    case "$ac_cv_what_readdir_r" in
     POSIX)
       AC_DEFINE(HAVE_POSIX_READDIR_R,1,[whether you have POSIX readdir_r]);;
     old-style)
@@ -174,7 +96,7 @@ int readdir_r(DIR *, struct dirent *);
 AC_DEFUN(PHP_SHLIB_SUFFIX_NAME,[
   PHP_SUBST(SHLIB_SUFFIX_NAME)
   SHLIB_SUFFIX_NAME=so
-  case $host_alias in
+  case "$host_alias" in
   *hpux*)
 	SHLIB_SUFFIX_NAME=sl
 	;;
@@ -182,7 +104,7 @@ AC_DEFUN(PHP_SHLIB_SUFFIX_NAME,[
 ])
 
 AC_DEFUN(PHP_DEBUG_MACRO,[
-  DEBUG_LOG=$1
+  DEBUG_LOG="$1"
   cat >$1 <<X
 CONFIGURE:  $CONFIGURE_COMMAND
 CC:         $CC
@@ -208,77 +130,7 @@ X
     (eval echo \"$ac_link\"; eval $ac_link && ./conftest) >>$1 2>&1
     rm -fr conftest*
 ])
-
-AC_DEFUN(PHP_MISSING_PREAD_DECL,[
-  AC_CACHE_CHECK(whether pread works without custom declaration,ac_cv_pread,[
-  AC_TRY_COMPILE([#include <unistd.h>],[size_t (*func)() = pread],[
-    ac_cv_pread=yes
-  ],[
-    echo test > conftest_in
-    AC_TRY_RUN([
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-      main() { char buf[3]; return !(pread(open("conftest_in", O_RDONLY), buf, 2, 0) == 2); }
-    ],[
-      ac_cv_pread=yes
-    ],[
-      echo test > conftest_in
-      AC_TRY_RUN([
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-        ssize_t pread(int, void *, size_t, off64_t);
-        main() { char buf[3]; return !(pread(open("conftest_in", O_RDONLY), buf, 2, 0) == 2); }
-      ],[
-        ac_cv_pread=64
-      ],[
-        ac_cv_pread=no
-      ])
-    ])
-  ])
-  ])
-  case $ac_cv_pread in
-  no) ac_cv_func_pread=no;;
-  64) AC_DEFINE(PHP_PREAD_64, 1, [whether pread64 is default]);;
-  esac
-])
-
-AC_DEFUN(PHP_MISSING_PWRITE_DECL,[
-  AC_CACHE_CHECK(whether pwrite works without custom declaration,ac_cv_pwrite,[
-  AC_TRY_COMPILE([#include <unistd.h>],[size_t (*func)() = pwrite],[
-    ac_cv_pwrite=yes
-  ],[
-    AC_TRY_RUN([
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-      main() { return !(pwrite(open("conftest_out", O_WRONLY|O_CREAT, 0600), "Ok", 2, 0) == 2); }
-    ],[
-      ac_cv_pwrite=yes
-    ],[
-      AC_TRY_RUN([
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-        ssize_t pwrite(int, void *, size_t, off64_t);
-        main() { return !(pwrite(open("conftest_out", O_WRONLY|O_CREAT, 0600), "Ok", 2, 0) == 2); }
-      ],[
-        ac_cv_pwrite=64
-      ],[
-        ac_cv_pwrite=no
-      ])
-    ])
-  ])
-  ])
-  case $ac_cv_pwrite in
-  no) ac_cv_func_pwrite=no;;
-  64) AC_DEFINE(PHP_PWRITE_64, 1, [whether pwrite64 is default]);;
-  esac
-])
-
+	
 AC_DEFUN(PHP_MISSING_TIME_R_DECL,[
   AC_MSG_CHECKING(for missing declarations of reentrant functions)
   AC_TRY_COMPILE([#include <time.h>],[struct tm *(*func)() = localtime_r],[
@@ -315,16 +167,16 @@ dnl Stores the location of libgcc in libgcc_libpath
 dnl
 AC_DEFUN(PHP_LIBGCC_LIBPATH,[
   changequote({,})
-  libgcc_libpath=`$1 --print-libgcc-file-name|sed 's%/*[^/][^/]*$%%'`
+  libgcc_libpath="`$1 --print-libgcc-file-name|sed 's%/*[^/][^/]*$%%'`"
   changequote([,])
 ])
 
 AC_DEFUN(PHP_ARG_ANALYZE,[
-case [$]$1 in
+case "[$]$1" in
 shared,*)
   ext_output="yes, shared"
   ext_shared=yes
-  $1=`echo "[$]$1"|sed 's/^shared,//'`
+  $1=`echo $ac_n "[$]$1$ac_c"|sed s/^shared,//`
   ;;
 shared)
   ext_output="yes, shared"
@@ -332,11 +184,11 @@ shared)
   $1=yes
   ;;
 no)
-  ext_output=no
+  ext_output="no"
   ext_shared=no
   ;;
 *)
-  ext_output=yes
+  ext_output="yes"
   ext_shared=no
   ;;
 esac
@@ -353,8 +205,7 @@ AC_MSG_RESULT($ext_output)
 dnl
 dnl PHP_ARG_WITH(arg-name, check message, help text[, default-val])
 dnl Sets PHP_ARG_NAME either to the user value or to the default value.
-dnl default-val defaults to no.  This will also set the variable ext_shared,
-dnl and will overwrite any previous variable of that name.
+dnl default-val defaults to no. 
 dnl
 AC_DEFUN(PHP_ARG_WITH,[
 PHP_REAL_ARG_WITH([$1],[$2],[$3],[$4],PHP_[]translit($1,a-z0-9-,A-Z0-9_))
@@ -369,8 +220,7 @@ PHP_ARG_ANALYZE($5)
 dnl
 dnl PHP_ARG_ENABLE(arg-name, check message, help text[, default-val])
 dnl Sets PHP_ARG_NAME either to the user value or to the default value.
-dnl default-val defaults to no.  This will also set the variable ext_shared,
-dnl and will overwrite any previous variable of that name.
+dnl default-val defaults to no. 
 dnl
 AC_DEFUN(PHP_ARG_ENABLE,[
 PHP_REAL_ARG_ENABLE([$1],[$2],[$3],[$4],PHP_[]translit($1,a-z-,A-Z_))
@@ -395,15 +245,8 @@ AC_DEFUN(PHP_CONFIG_NICE,[
 
 EOF
 
-  for var in CFLAGS CXXFLAGS CPPFLAGS LDFLAGS LIBS CC CXX; do
-    eval val=\$$var
-    if test -n "$val"; then
-      echo "$var='$val' \\" >> $1
-    fi
-  done
-
   for arg in [$]0 "[$]@"; do
-    echo "'[$]arg' \\" >> $1
+    echo "\"[$]arg\" \\" >> $1
   done
   echo '"[$]@"' >> $1
   chmod +x $1
@@ -413,6 +256,7 @@ AC_DEFUN(PHP_TIME_R_TYPE,[
 AC_CACHE_CHECK(for type of reentrant time-related functions, ac_cv_time_r_type,[
 AC_TRY_RUN([
 #include <time.h>
+#include <stdlib.h>
 
 main() {
 char buf[27];
@@ -422,45 +266,24 @@ int r, s;
 
 s = gmtime_r(&old, &t);
 r = (int) asctime_r(&t, buf, 26);
-if (r == s && s == 0) return (0);
-return (1);
+if (r == s && s == 0) exit(0);
+exit(1);
 }
 ],[
   ac_cv_time_r_type=hpux
 ],[
-  AC_TRY_RUN([
-#include <time.h>
-main() {
-  struct tm t, *s;
-  time_t old = 0;
-  char buf[27], *p;
-  
-  s = gmtime_r(&old, &t);
-  p = asctime_r(&t, buf, 26);
-  if (p == buf && s == &t) return (0);
-  return (1);
-}
-  ],[
-    ac_cv_time_r_type=irix
-  ],[
-    ac_cv_time_r_type=POSIX
-  ])
+  ac_cv_time_r_type=POSIX
 ],[
   ac_cv_time_r_type=POSIX
 ])
 ])
-  case $ac_cv_time_r_type in
-  hpux) AC_DEFINE(PHP_HPUX_TIME_R,1,[Whether you have HP-UX 10.x]) ;;
-  irix) AC_DEFINE(PHP_IRIX_TIME_R,1,[Whether you have IRIX-style functions]) ;;
-  esac
+if test "$ac_cv_time_r_type" = "hpux"; then
+  AC_DEFINE(PHP_HPUX_TIME_R,1,[Whether you have HP-UX 10.x])
+fi
 ])
 
 AC_DEFUN(PHP_SUBST,[
   PHP_VAR_SUBST="$PHP_VAR_SUBST $1"
-])
-
-AC_DEFUN(PHP_SUBST_OLD,[
-  PHP_SUBST($1)
   AC_SUBST($1)
 ])
 
@@ -472,9 +295,7 @@ AC_DEFUN(PHP_MKDIR_P_CHECK,[
   AC_CACHE_CHECK(for working mkdir -p, ac_cv_mkdir_p,[
     test -d conftestdir && rm -rf conftestdir
     mkdir -p conftestdir/somedir >/dev/null 2>&1
-dnl `mkdir -p' must be quiet about creating existing directories
-    mkdir -p conftestdir/somedir >/dev/null 2>&1
-    if test "$?" = "0" && test -d conftestdir/somedir; then
+    if test -d conftestdir/somedir; then
       ac_cv_mkdir_p=yes
     else
       ac_cv_mkdir_p=no
@@ -515,7 +336,7 @@ AC_DEFUN(PHP_CONFIGURE_PART,[
 ])
 
 AC_DEFUN(PHP_PROG_SENDMAIL,[
-AC_PATH_PROG(PROG_SENDMAIL, sendmail,[], $PATH:/usr/bin:/usr/sbin:/usr/etc:/etc:/usr/ucblib:/usr/lib)
+AC_PATH_PROG(PROG_SENDMAIL, sendmail, /usr/lib/sendmail, $PATH:/usr/bin:/usr/sbin:/usr/etc:/etc:/usr/ucblib)
 if test -n "$PROG_SENDMAIL"; then
   AC_DEFINE(HAVE_SENDMAIL,1,[whether you have sendmail])
 fi
@@ -525,26 +346,26 @@ AC_DEFUN(PHP_RUNPATH_SWITCH,[
 dnl check for -R, etc. switch
 AC_MSG_CHECKING(if compiler supports -R)
 AC_CACHE_VAL(php_cv_cc_dashr,[
-	SAVE_LIBS=$LIBS
-	LIBS="-R /usr/lib $LIBS"
+	SAVE_LIBS="${LIBS}"
+	LIBS="-R /usr/lib ${LIBS}"
 	AC_TRY_LINK([], [], php_cv_cc_dashr=yes, php_cv_cc_dashr=no)
-	LIBS=$SAVE_LIBS])
+	LIBS="${SAVE_LIBS}"])
 AC_MSG_RESULT($php_cv_cc_dashr)
 if test $php_cv_cc_dashr = "yes"; then
-	ld_runpath_switch=-R
+	ld_runpath_switch="-R"
 else
 	AC_MSG_CHECKING([if compiler supports -Wl,-rpath,])
 	AC_CACHE_VAL(php_cv_cc_rpath,[
-		SAVE_LIBS=$LIBS
-		LIBS="-Wl,-rpath,/usr/lib $LIBS"
+		SAVE_LIBS="${LIBS}"
+		LIBS="-Wl,-rpath,/usr/lib ${LIBS}"
 		AC_TRY_LINK([], [], php_cv_cc_rpath=yes, php_cv_cc_rpath=no)
-		LIBS=$SAVE_LIBS])
+		LIBS="${SAVE_LIBS}"])
 	AC_MSG_RESULT($php_cv_cc_rpath)
 	if test $php_cv_cc_rpath = "yes"; then
-		ld_runpath_switch=-Wl,-rpath,
+		ld_runpath_switch="-Wl,-rpath,"
 	else
 		dnl something innocuous
-		ld_runpath_switch=-L
+		ld_runpath_switch="-L"
 	fi
 fi
 ])
@@ -591,7 +412,7 @@ dnl set the path of the file which contains the symbol export list
 dnl
 AC_DEFUN(PHP_SET_SYM_FILE,
 [
-  PHP_SYM_FILE=$1
+  PHP_SYM_FILE="$1"
 ])
 
 dnl
@@ -650,13 +471,13 @@ AC_DEFUN(AC_PHP_ONCE,[
 ])
 
 dnl
-dnl PHP_EXPAND_PATH(path, variable)
+dnl AC_EXPAND_PATH(path, variable)
 dnl
 dnl expands path to an absolute path and assigns it to variable
 dnl
-AC_DEFUN(PHP_EXPAND_PATH,[
+AC_DEFUN(AC_EXPAND_PATH,[
   if test -z "$1" || echo "$1" | grep '^/' >/dev/null ; then
-    $2=$1
+    $2="$1"
   else
     changequote({,})
     ep_dir="`echo $1|sed 's%/*[^/][^/]*/*$%%'`"
@@ -667,13 +488,13 @@ AC_DEFUN(PHP_EXPAND_PATH,[
 ])
 
 dnl
-dnl PHP_ADD_LIBPATH(path[, shared-libadd])
+dnl AC_ADD_LIBPATH(path[, shared-libadd])
 dnl
 dnl add a library to linkpath/runpath
 dnl
-AC_DEFUN(PHP_ADD_LIBPATH,[
+AC_DEFUN(AC_ADD_LIBPATH,[
   if test "$1" != "/usr/lib"; then
-    PHP_EXPAND_PATH($1, ai_p)
+    AC_EXPAND_PATH($1, ai_p)
     if test "$ext_shared" = "yes" && test -n "$2"; then
       $2="-R$1 -L$1 [$]$2"
     else
@@ -687,37 +508,32 @@ AC_DEFUN(PHP_ADD_LIBPATH,[
 ])
 
 dnl
-dnl PHP_BUILD_RPATH()
+dnl AC_BUILD_RPATH()
 dnl
 dnl builds RPATH from PHP_RPATHS
 dnl
-AC_DEFUN(PHP_BUILD_RPATH,[
+AC_DEFUN(AC_BUILD_RPATH,[
   if test "$PHP_RPATH" = "yes" && test -n "$PHP_RPATHS"; then
     OLD_RPATHS="$PHP_RPATHS"
-    unset PHP_RPATHS
+    PHP_RPATHS=""
     for i in $OLD_RPATHS; do
       PHP_LDFLAGS="$PHP_LDFLAGS -L$i"
       PHP_RPATHS="$PHP_RPATHS -R $i"
-      NATIVE_RPATHS="$NATIVE_RPATHS $ld_runpath_switch$i"
+      NATIVE_RPATHS="$NATIVE_RPATHS ${ld_runpath_switch}$i"
     done
   fi
 ])
 
 dnl
-dnl PHP_ADD_INCLUDE(path [,before])
+dnl AC_ADD_INCLUDE(path)
 dnl
-dnl add an include path. 
-dnl if before is 1, add in the beginning of INCLUDES.
+dnl add a include path
 dnl
-AC_DEFUN(PHP_ADD_INCLUDE,[
+AC_DEFUN(AC_ADD_INCLUDE,[
   if test "$1" != "/usr/include"; then
-    PHP_EXPAND_PATH($1, ai_p)
+    AC_EXPAND_PATH($1, ai_p)
     AC_PHP_ONCE(INCLUDEPATH, $ai_p, [
-      if test "$2"; then
-        INCLUDES="-I$ai_p $INCLUDES"
-      else
-        INCLUDES="$INCLUDES -I$ai_p"
-      fi
+      INCLUDES="$INCLUDES -I$ai_p"
     ])
   fi
 ])
@@ -727,12 +543,12 @@ AC_DEFUN(PHP_X_ADD_LIBRARY,[
 ])
 
 dnl
-dnl PHP_ADD_LIBRARY(library[, append[, shared-libadd]])
+dnl AC_ADD_LIBRARY(library[, append[, shared-libadd]])
 dnl
 dnl add a library to the link line
 dnl
-AC_DEFUN(PHP_ADD_LIBRARY,[
- case $1 in
+AC_DEFUN(AC_ADD_LIBRARY,[
+ case "$1" in
  c|c_r|pthread*) ;;
  *)
 ifelse($3,,[
@@ -741,7 +557,7 @@ ifelse($3,,[
    if test "$ext_shared" = "yes"; then
      PHP_X_ADD_LIBRARY($1,$2,$3)
    else
-     PHP_ADD_LIBRARY($1,$2)
+     AC_ADD_LIBRARY($1,$2)
    fi
 ])
   ;;
@@ -749,66 +565,49 @@ ifelse($3,,[
 ])
 
 dnl
-dnl PHP_ADD_LIBRARY_DEFER(library[, append[, shared-libadd]])
+dnl AC_ADD_LIBRARY_DEFER(library[, append])
 dnl
 dnl add a library to the link line (deferred)
-dnl
-AC_DEFUN(PHP_ADD_LIBRARY_DEFER,[
- case $1 in
- c|c_r|pthread*) ;;
- *)
-ifelse($3,,[
-   PHP_X_ADD_LIBRARY($1,$2,DLIBS)
-],[
-   if test "$ext_shared" = "yes"; then
-     PHP_X_ADD_LIBRARY($1,$2,$3)
-   else
-     PHP_ADD_LIBRARY_DEFER($1,$2)
-   fi
+AC_DEFUN(AC_ADD_LIBRARY_DEFER,[
+  ifelse($#, 1, DLIBS="-l$1 $DLIBS", DLIBS="$DLIBS -l$1")
 ])
-  ;;
-  esac
-])
-  
+
 dnl
-dnl PHP_ADD_LIBRARY_WITH_PATH(library, path[, shared-libadd])
+dnl AC_ADD_LIBRARY_WITH_PATH(library, path[, shared-libadd])
 dnl
 dnl add a library to the link line and path to linkpath/runpath.
 dnl if shared-libadd is not empty and $ext_shared is yes,
 dnl shared-libadd will be assigned the library information
 dnl
-AC_DEFUN(PHP_ADD_LIBRARY_WITH_PATH,[
+AC_DEFUN(AC_ADD_LIBRARY_WITH_PATH,[
 ifelse($3,,[
   if test -n "$2"; then
-    PHP_ADD_LIBPATH($2)
+    AC_ADD_LIBPATH($2)
   fi
-  PHP_ADD_LIBRARY($1)
+  AC_ADD_LIBRARY($1)
 ],[
   if test "$ext_shared" = "yes"; then
     $3="-l$1 [$]$3"
     if test -n "$2"; then
-      PHP_ADD_LIBPATH($2,$3)
+      AC_ADD_LIBPATH($2,$3)
     fi
   else
-    PHP_ADD_LIBRARY_WITH_PATH($1,$2)
+    AC_ADD_LIBRARY_WITH_PATH($1,$2)
   fi
 ])
 ])
 
 dnl
-dnl PHP_ADD_LIBRARY_DEFER_WITH_PATH(library, path)
+dnl AC_ADD_LIBRARY_DEFER_WITH_PATH(library, path)
 dnl
 dnl add a library to the link line (deferred)
 dnl and path to linkpath/runpath (not deferred)
 dnl
-AC_DEFUN(PHP_ADD_LIBRARY_DEFER_WITH_PATH,[
-  PHP_ADD_LIBPATH($2)
-  PHP_ADD_LIBRARY_DEFER($1)
+AC_DEFUN(AC_ADD_LIBRARY_DEFER_WITH_PATH,[
+  AC_ADD_LIBPATH($2)
+  AC_ADD_LIBRARY_DEFER($1)
 ])
 
-dnl
-dnl Set libtool variable
-dnl
 AC_DEFUN(AM_SET_LIBTOOL_VARIABLE,[
   LIBTOOL='$(SHELL) $(top_builddir)/libtool $1'
 ])
@@ -816,9 +615,9 @@ AC_DEFUN(AM_SET_LIBTOOL_VARIABLE,[
 dnl
 dnl Check for cc option
 dnl
-AC_DEFUN(PHP_CHECK_CC_OPTION,[
+AC_DEFUN(AC_CHECK_CC_OPTION,[
   echo "main(){return 0;}" > conftest.$ac_ext
-  opt=$1
+  opt="$1"
   changequote({,})
   var=`echo $opt|sed 's/[^a-zA-Z0-9]/_/g'`
   changequote([,])
@@ -861,7 +660,7 @@ PHP_SUBST(HSREGEX)
 dnl
 dnl See if we have broken header files like SunOS has.
 dnl
-AC_DEFUN(PHP_MISSING_FCLOSE_DECL,[
+AC_DEFUN(AC_MISSING_FCLOSE_DECL,[
   AC_MSG_CHECKING([for fclose declaration])
   AC_TRY_COMPILE([#include <stdio.h>],[int (*func)() = fclose],[
     AC_DEFINE(MISSING_FCLOSE_DECL,0,[ ])
@@ -875,7 +674,7 @@ AC_DEFUN(PHP_MISSING_FCLOSE_DECL,[
 dnl
 dnl Check for broken sprintf()
 dnl
-AC_DEFUN(PHP_AC_BROKEN_SPRINTF,[
+AC_DEFUN(AC_BROKEN_SPRINTF,[
   AC_CACHE_CHECK(whether sprintf is broken, ac_cv_broken_sprintf,[
     AC_TRY_RUN([main() {char buf[20];exit(sprintf(buf,"testing 123")!=11); }],[
       ac_cv_broken_sprintf=no
@@ -906,12 +705,12 @@ AC_DEFUN(PHP_EXTENSION,[
   
   if test -d "$abs_srcdir/ext/$1"; then
 dnl ---------------------------------------------- Internal Module
-    ext_builddir=ext/$1
-    ext_srcdir=$abs_srcdir/ext/$1
+    ext_builddir="ext/$1"
+    ext_srcdir="$abs_srcdir/ext/$1"
   else
 dnl ---------------------------------------------- External Module
-    ext_builddir=.
-    ext_srcdir=$abs_srcdir
+    ext_builddir="."
+    ext_srcdir="$abs_srcdir"
   fi
 
   if test "$2" != "shared" && test "$2" != "yes"; then
@@ -928,6 +727,12 @@ dnl ---------------------------------------------- Shared module
   PHP_FAST_OUTPUT($ext_builddir/Makefile)
 ])
 
+PHP_SUBST(EXT_SUBDIRS)
+PHP_SUBST(EXT_STATIC)
+PHP_SUBST(EXT_SHARED)
+PHP_SUBST(EXT_LIBS)
+PHP_SUBST(EXT_LTLIBS)
+
 dnl
 dnl Solaris requires main code to be position independent in order
 dnl to let shared objects find symbols.  Weird.  Ugly.
@@ -937,11 +742,11 @@ dnl choose dynamic extensions, and after the gcc test.
 dnl
 AC_DEFUN(PHP_SOLARIS_PIC_WEIRDNESS,[
   AC_MSG_CHECKING(whether -fPIC is required)
-  if test -n "$EXT_SHARED"; then
+  if test "$EXT_SHARED" != ""; then
     os=`uname -sr 2>/dev/null`
-    case $os in
+    case "$os" in
         "SunOS 5.6"|"SunOS 5.7")
-          case $CC in
+          case "$CC" in
 	    gcc*|egcs*) CFLAGS="$CFLAGS -fPIC";;
 	    *) CFLAGS="$CFLAGS -fpic";;
 	  esac
@@ -986,7 +791,7 @@ dnl http://www.sas.com/standards/large.file/x_open.20Mar96.html
 
 dnl Written by Paul Eggert <eggert@twinsun.com>.
 
-AC_DEFUN(PHP_SYS_LFS,
+AC_DEFUN(AC_SYS_LFS,
 [dnl
   # If available, prefer support for large files unless the user specified
   # one of the CPPFLAGS, LDFLAGS, or LIBS variables.
@@ -1021,7 +826,7 @@ AC_DEFUN(PHP_SYS_LFS,
   esac
 ])
 
-AC_DEFUN(PHP_SOCKADDR_SA_LEN,[
+AC_DEFUN(AC_SOCKADDR_SA_LEN,[
   AC_CACHE_CHECK([for field sa_len in struct sockaddr],ac_cv_sockaddr_sa_len,[
     AC_TRY_COMPILE([#include <sys/types.h>
 #include <sys/socket.h>],
@@ -1067,22 +872,17 @@ int main(void) {
   return (unsigned char)'A' != (unsigned char)0xC1; 
 } 
 ],[
-  ac_cv_ebcdic=yes
+  ac_cv_ebcdic="yes"
 ],[
-  ac_cv_ebcdic=no
+  ac_cv_ebcdic="no"
 ],[
-  ac_cv_ebcdic=no
+  ac_cv_ebcdic="no"
 ])])
   if test "$ac_cv_ebcdic" = "yes"; then
     AC_DEFINE(CHARSET_EBCDIC,1, [Define if system uses EBCDIC])
   fi
 ])
 
-AC_DEFUN(AC_ADD_LIBPATH, [indir([PHP_ADD_LIBPATH], $@)])
-AC_DEFUN(AC_ADD_LIBRARY, [indir([PHP_ADD_LIBRARY], $@)])
-AC_DEFUN(AC_ADD_LIBRARY_WITH_PATH, [indir([PHP_ADD_LIBRARY_WITH_PATH], $@)])
-AC_DEFUN(AC_ADD_INCLUDE, [indir([PHP_ADD_INCLUDE], $@)])
-
 AC_DEFUN(PHP_FOPENCOOKIE,[
 	AC_CHECK_FUNC(fopencookie, [ have_glibc_fopencookie=yes ])
 

build/build.mk

@@ -34,7 +34,7 @@ generated_lists:
 		TSRM/Makefile.am > $@
 	@echo config_h_files = Zend/acconfig.h TSRM/acconfig.h >> $@
 	@echo config_m4_files = Zend/Zend.m4 TSRM/tsrm.m4 \
-		Zend/acinclude.m4 ext/*/config*.m4 sapi/*/config.m4 >> $@
+		Zend/acinclude.m4 ext/*/config.m4 sapi/*/config.m4 >> $@
 
 $(STAMP): build/buildcheck.sh
 	@build/buildcheck.sh && touch $(STAMP)